yum-mirror/slang

Making it easier to work with shaders

git clone https://git.yummers.dev/yum-mirror/slang

Julius IkkalaIntroduce CDataLayout & -fvk-use-c-layout (#8136)35f8e092f

master
branchesmasterall refs →
13.7 KiB467 linesraw
1#include "slang.h"
2
3namespace SlangRecord
4{
5static Slang::String SlangCompileTargetToString(const SlangCompileTarget target)
6{
7#define CASE(x) \
8    case x:     \
9        return #x
10
11    switch (target)
12    {
13        CASE(SLANG_TARGET_UNKNOWN);
14        CASE(SLANG_GLSL);
15        CASE(SLANG_GLSL_VULKAN_DEPRECATED);
16        CASE(SLANG_GLSL_VULKAN_ONE_DESC_DEPRECATED);
17        CASE(SLANG_HLSL);
18        CASE(SLANG_SPIRV);
19        CASE(SLANG_SPIRV_ASM);
20        CASE(SLANG_DXBC);
21        CASE(SLANG_DXIL);
22        CASE(SLANG_DXIL_ASM);
23        CASE(SLANG_C_SOURCE);
24        CASE(SLANG_CPP_SOURCE);
25        CASE(SLANG_HOST_EXECUTABLE);
26        CASE(SLANG_SHADER_SHARED_LIBRARY);
27        CASE(SLANG_SHADER_HOST_CALLABLE);
28        CASE(SLANG_CUDA_SOURCE);
29        CASE(SLANG_PTX);
30        CASE(SLANG_CUDA_OBJECT_CODE);
31        CASE(SLANG_OBJECT_CODE);
32        CASE(SLANG_HOST_CPP_SOURCE);
33        CASE(SLANG_HOST_HOST_CALLABLE);
34        CASE(SLANG_CPP_PYTORCH_BINDING);
35        CASE(SLANG_METAL);
36        CASE(SLANG_METAL_LIB);
37        CASE(SLANG_METAL_LIB_ASM);
38        CASE(SLANG_HOST_SHARED_LIBRARY);
39        CASE(SLANG_WGSL);
40        CASE(SLANG_TARGET_COUNT_OF);
41    default:
42        Slang::StringBuilder str;
43        str << "Unknown SlangCompileTarget: " << static_cast<uint32_t>(target);
44        return str.toString();
45    }
46#undef CASE
47}
48
49static Slang::String SlangProfileIDToString(const SlangProfileID profile)
50{
51    switch (profile)
52    {
53    case SLANG_PROFILE_UNKNOWN:
54        return "SLANG_PROFILE_UNKNOWN";
55    default:
56        Slang::StringBuilder str;
57        str << "Unknown SlangProfileID: " << static_cast<uint32_t>(profile);
58        return str.toString();
59    }
60}
61
62static Slang::String SlangTargetFlagsToString(const SlangTargetFlags flags)
63{
64    switch (flags)
65    {
66    case SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES:
67        return "SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES";
68    case SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM:
69        return "SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM";
70    case SLANG_TARGET_FLAG_DUMP_IR:
71        return "SLANG_TARGET_FLAG_DUMP_IR";
72    case SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY:
73        return "SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY";
74    default:
75        Slang::StringBuilder str;
76        str << "Unknown SlangTargetFlags: " << static_cast<uint32_t>(flags);
77        return str.toString();
78    }
79}
80
81static Slang::String SlangFloatingPointModeToString(const SlangFloatingPointMode mode)
82{
83    switch (mode)
84    {
85    case SLANG_FLOATING_POINT_MODE_DEFAULT:
86        return "SLANG_FLOATING_POINT_MODE_DEFAULT";
87    case SLANG_FLOATING_POINT_MODE_FAST:
88        return "SLANG_FLOATING_POINT_MODE_FAST";
89    case SLANG_FLOATING_POINT_MODE_PRECISE:
90        return "SLANG_FLOATING_POINT_MODE_PRECISE";
91    default:
92        Slang::StringBuilder str;
93        str << "Unknown SlangFloatingPointMode: " << static_cast<uint32_t>(mode);
94        return str.toString();
95    }
96}
97
98static Slang::String SlangLineDirectiveModeToString(const SlangLineDirectiveMode mode)
99{
100    switch (mode)
101    {
102    case SLANG_LINE_DIRECTIVE_MODE_DEFAULT:
103        return "SLANG_LINE_DIRECTIVE_MODE_DEFAULT";
104    case SLANG_LINE_DIRECTIVE_MODE_NONE:
105        return "SLANG_LINE_DIRECTIVE_MODE_NONE";
106    case SLANG_LINE_DIRECTIVE_MODE_STANDARD:
107        return "SLANG_LINE_DIRECTIVE_MODE_STANDARD";
108    case SLANG_LINE_DIRECTIVE_MODE_GLSL:
109        return "SLANG_LINE_DIRECTIVE_MODE_GLSL";
110    case SLANG_LINE_DIRECTIVE_MODE_SOURCE_MAP:
111        return "SLANG_LINE_DIRECTIVE_MODE_SOURCE_MAP";
112    default:
113        Slang::StringBuilder str;
114        str << "Unknown SlangLineDirectiveMode: " << static_cast<uint32_t>(mode);
115        return str.toString();
116    }
117}
118
119static Slang::String CompilerOptionNameToString(const slang::CompilerOptionName name)
120{
121#define CASE(x)                 \
122    case CompilerOptionName::x: \
123        return #x
124
125    using namespace slang;
126    switch (name)
127    {
128        CASE(MacroDefine);
129        CASE(DepFile);
130        CASE(EntryPointName);
131        CASE(Specialize);
132        CASE(Help);
133        CASE(HelpStyle);
134        CASE(Include);
135        CASE(Language);
136        CASE(MatrixLayoutColumn);
137        CASE(MatrixLayoutRow);
138        CASE(ZeroInitialize);
139        CASE(IgnoreCapabilities);
140        CASE(RestrictiveCapabilityCheck);
141        CASE(ModuleName);
142        CASE(Output);
143        CASE(Profile);
144        CASE(Stage);
145        CASE(Target);
146        CASE(Version);
147        CASE(WarningsAsErrors);
148        CASE(DisableWarnings);
149        CASE(EnableWarning);
150        CASE(DisableWarning);
151        CASE(DumpWarningDiagnostics);
152        CASE(InputFilesRemain);
153        CASE(EmitIr);
154        CASE(ReportDownstreamTime);
155        CASE(ReportPerfBenchmark);
156        CASE(ReportCheckpointIntermediates);
157        CASE(SkipSPIRVValidation);
158        CASE(SourceEmbedStyle);
159        CASE(SourceEmbedName);
160        CASE(SourceEmbedLanguage);
161        CASE(DisableShortCircuit);
162        CASE(MinimumSlangOptimization);
163        CASE(DisableNonEssentialValidations);
164        CASE(DisableSourceMap);
165        CASE(UnscopedEnum);
166        CASE(PreserveParameters);
167        CASE(Capability);
168        CASE(DefaultImageFormatUnknown);
169        CASE(DisableDynamicDispatch);
170        CASE(DisableSpecialization);
171        CASE(FloatingPointMode);
172        CASE(DebugInformation);
173        CASE(LineDirectiveMode);
174        CASE(Optimization);
175        CASE(Obfuscate);
176        CASE(VulkanBindShift);
177        CASE(VulkanBindGlobals);
178        CASE(VulkanInvertY);
179        CASE(VulkanUseDxPositionW);
180        CASE(VulkanUseEntryPointName);
181        CASE(VulkanUseGLLayout);
182        CASE(VulkanEmitReflection);
183        CASE(GLSLForceScalarLayout);
184        CASE(ForceDXLayout);
185        CASE(ForceCLayout);
186        CASE(EnableEffectAnnotations);
187        CASE(EmitSpirvViaGLSL);
188        CASE(EmitSpirvDirectly);
189        CASE(SPIRVCoreGrammarJSON);
190        CASE(IncompleteLibrary);
191        CASE(CompilerPath);
192        CASE(DefaultDownstreamCompiler);
193        CASE(DownstreamArgs);
194        CASE(PassThrough);
195        CASE(DumpRepro);
196        CASE(DumpReproOnError);
197        CASE(ExtractRepro);
198        CASE(LoadRepro);
199        CASE(LoadReproDirectory);
200        CASE(ReproFallbackDirectory);
201        CASE(DumpAst);
202        CASE(DumpIntermediatePrefix);
203        CASE(DumpIntermediates);
204        CASE(DumpIr);
205        CASE(DumpIrIds);
206        CASE(PreprocessorOutput);
207        CASE(OutputIncludes);
208        CASE(ReproFileSystem);
209        CASE(REMOVED_SerialIR);
210        CASE(SkipCodeGen);
211        CASE(ValidateIr);
212        CASE(VerbosePaths);
213        CASE(VerifyDebugSerialIr);
214        CASE(NoCodeGen);
215        CASE(FileSystem);
216        CASE(Heterogeneous);
217        CASE(NoMangle);
218        CASE(NoHLSLBinding);
219        CASE(NoHLSLPackConstantBufferElements);
220        CASE(ValidateUniformity);
221        CASE(AllowGLSL);
222        CASE(ArchiveType);
223        CASE(CompileCoreModule);
224        CASE(Doc);
225        CASE(IrCompression);
226        CASE(LoadCoreModule);
227        CASE(ReferenceModule);
228        CASE(SaveCoreModule);
229        CASE(SaveCoreModuleBinSource);
230        CASE(SaveGLSLModuleBinSource);
231        CASE(TrackLiveness);
232        CASE(LoopInversion);
233        CASE(CountOfParsableOptions);
234        CASE(DebugInformationFormat);
235        CASE(VulkanBindShiftAll);
236        CASE(GenerateWholeProgram);
237        CASE(UseUpToDateBinaryModule);
238        CASE(CountOf);
239    default:
240        Slang::StringBuilder str;
241        str << "Unknown CompilerOptionName: " << static_cast<uint32_t>(name);
242        return str.toString();
243    }
244#undef CASE
245}
246
247static Slang::String CompilerOptionValueKindToString(const slang::CompilerOptionValueKind kind)
248{
249    using namespace slang;
250    switch (kind)
251    {
252    case CompilerOptionValueKind::Int:
253        return "Int";
254    case CompilerOptionValueKind::String:
255        return "String";
256    default:
257        Slang::StringBuilder str;
258        str << "Unknown CompilerOptionValueKind: " << static_cast<uint32_t>(kind);
259        return str.toString();
260    }
261}
262
263static Slang::String SessionFlagsToString(const slang::SessionFlags flags)
264{
265    using namespace slang;
266    switch (flags)
267    {
268    case kSessionFlags_None:
269        return "kSessionFlags_None";
270    default:
271        Slang::StringBuilder str;
272        str << "Unknown SessionFlags: " << static_cast<uint32_t>(flags);
273        return str.toString();
274    }
275}
276
277static Slang::String SlangMatrixLayoutModeToString(const SlangMatrixLayoutMode mode)
278{
279    switch (mode)
280    {
281    case SLANG_MATRIX_LAYOUT_MODE_UNKNOWN:
282        return "SLANG_MATRIX_LAYOUT_MODE_UNKNOWN";
283    case SLANG_MATRIX_LAYOUT_ROW_MAJOR:
284        return "SLANG_MATRIX_LAYOUT_ROW_MAJOR";
285    case SLANG_MATRIX_LAYOUT_COLUMN_MAJOR:
286        return "SLANG_MATRIX_LAYOUT_COLUMN_MAJOR";
287    default:
288        Slang::StringBuilder str;
289        str << "Unknown SlangMatrixLayoutMode: " << static_cast<uint32_t>(mode);
290        return str.toString();
291    }
292}
293
294static Slang::String SlangPassThroughToString(const SlangPassThrough passThrough)
295{
296#define CASE(x) \
297    case x:     \
298        return #x
299
300    switch (passThrough)
301    {
302        CASE(SLANG_PASS_THROUGH_NONE);
303        CASE(SLANG_PASS_THROUGH_FXC);
304        CASE(SLANG_PASS_THROUGH_DXC);
305        CASE(SLANG_PASS_THROUGH_GLSLANG);
306        CASE(SLANG_PASS_THROUGH_SPIRV_DIS);
307        CASE(SLANG_PASS_THROUGH_CLANG);
308        CASE(SLANG_PASS_THROUGH_VISUAL_STUDIO);
309        CASE(SLANG_PASS_THROUGH_GCC);
310        CASE(SLANG_PASS_THROUGH_GENERIC_C_CPP);
311        CASE(SLANG_PASS_THROUGH_NVRTC);
312        CASE(SLANG_PASS_THROUGH_LLVM);
313        CASE(SLANG_PASS_THROUGH_SPIRV_OPT);
314        CASE(SLANG_PASS_THROUGH_METAL);
315        CASE(SLANG_PASS_THROUGH_COUNT_OF);
316    default:
317        Slang::StringBuilder str;
318        str << "Unknown SlangPassThrough: " << static_cast<uint32_t>(passThrough);
319        return str.toString();
320    }
321#undef CASE
322}
323
324static Slang::String SlangSourceLanguageToString(const SlangSourceLanguage language)
325{
326#define CASE(x) \
327    case x:     \
328        return #x
329
330    switch (language)
331    {
332        CASE(SLANG_SOURCE_LANGUAGE_UNKNOWN);
333        CASE(SLANG_SOURCE_LANGUAGE_SLANG);
334        CASE(SLANG_SOURCE_LANGUAGE_HLSL);
335        CASE(SLANG_SOURCE_LANGUAGE_GLSL);
336        CASE(SLANG_SOURCE_LANGUAGE_C);
337        CASE(SLANG_SOURCE_LANGUAGE_CPP);
338        CASE(SLANG_SOURCE_LANGUAGE_CUDA);
339        CASE(SLANG_SOURCE_LANGUAGE_SPIRV);
340        CASE(SLANG_SOURCE_LANGUAGE_METAL);
341        CASE(SLANG_SOURCE_LANGUAGE_COUNT_OF);
342    default:
343        Slang::StringBuilder str;
344        str << "Unknown SlangSourceLanguage: " << static_cast<uint32_t>(language);
345        return str.toString();
346    }
347}
348
349static Slang::String CompileCoreModuleFlagsToString(const slang::CompileCoreModuleFlags flags)
350{
351    using namespace slang;
352    switch (flags)
353    {
354    case CompileCoreModuleFlag::WriteDocumentation:
355        return "WriteDocumentation";
356    default:
357        Slang::StringBuilder str;
358        str << "Unknown CompileCoreModuleFlags: " << static_cast<uint32_t>(flags);
359        return str.toString();
360    }
361}
362
363static Slang::String SlangArchiveTypeToString(const SlangArchiveType type)
364{
365#define CASE(x) \
366    case x:     \
367        return #x
368    switch (type)
369    {
370        CASE(SLANG_ARCHIVE_TYPE_UNDEFINED);
371        CASE(SLANG_ARCHIVE_TYPE_ZIP);
372        CASE(SLANG_ARCHIVE_TYPE_RIFF);
373        CASE(SLANG_ARCHIVE_TYPE_RIFF_DEFLATE);
374        CASE(SLANG_ARCHIVE_TYPE_RIFF_LZ4);
375        CASE(SLANG_ARCHIVE_TYPE_COUNT_OF);
376    default:
377        Slang::StringBuilder str;
378        str << "Unknown SlangArchiveType: " << static_cast<uint32_t>(type);
379        return str.toString();
380    }
381}
382
383static Slang::String SpecializationArgKindToString(const slang::SpecializationArg::Kind kind)
384{
385    using namespace slang;
386    switch (kind)
387    {
388    case SpecializationArg::Kind::Unknown:
389        return "Unknown";
390    case SpecializationArg::Kind::Type:
391        return "Type";
392    default:
393        Slang::StringBuilder str;
394        str << "Unknown SpecializationArg::Kind: " << static_cast<uint32_t>(kind);
395        return str.toString();
396    }
397}
398
399static Slang::String LayoutRulesToString(const slang::LayoutRules rules)
400{
401    using namespace slang;
402    switch (rules)
403    {
404    case LayoutRules::Default:
405        return "Default";
406    case LayoutRules::MetalArgumentBufferTier2:
407        return "MetalArgumentBufferTier2";
408    default:
409        Slang::StringBuilder str;
410        str << "Unknown LayoutRules: " << static_cast<uint32_t>(rules);
411        return str.toString();
412    }
413}
414
415static Slang::String SlangStageToString(const SlangStage stage)
416{
417#define CASE(x) \
418    case x:     \
419        return #x
420
421    switch (stage)
422    {
423        CASE(SLANG_STAGE_NONE);
424        CASE(SLANG_STAGE_VERTEX);
425        CASE(SLANG_STAGE_HULL);
426        CASE(SLANG_STAGE_DOMAIN);
427        CASE(SLANG_STAGE_GEOMETRY);
428        CASE(SLANG_STAGE_FRAGMENT);
429        CASE(SLANG_STAGE_COMPUTE);
430        CASE(SLANG_STAGE_RAY_GENERATION);
431        CASE(SLANG_STAGE_INTERSECTION);
432        CASE(SLANG_STAGE_ANY_HIT);
433        CASE(SLANG_STAGE_CLOSEST_HIT);
434        CASE(SLANG_STAGE_MISS);
435        CASE(SLANG_STAGE_CALLABLE);
436        CASE(SLANG_STAGE_MESH);
437        CASE(SLANG_STAGE_AMPLIFICATION);
438    default:
439        Slang::StringBuilder str;
440        str << "Unknown SlangStage: " << static_cast<uint32_t>(stage);
441        return str.toString();
442    }
443#undef CASE
444}
445
446static Slang::String ContainerTypeToString(const slang::ContainerType type)
447{
448    using namespace slang;
449    switch (type)
450    {
451    case ContainerType::None:
452        return "None";
453    case ContainerType::UnsizedArray:
454        return "UnsizedArray";
455    case ContainerType::StructuredBuffer:
456        return "StructuredBuffer";
457    case ContainerType::ConstantBuffer:
458        return "ConstantBuffer";
459    case ContainerType::ParameterBlock:
460        return "ParameterBlock";
461    default:
462        Slang::StringBuilder str;
463        str << "Unknown ContainerType: " << static_cast<uint32_t>(type);
464        return str.toString();
465    }
466}
467} // namespace SlangRecord