slang.h

浏览该文件的文档.

#ifndef SLANG_H
#define SLANG_H
 
#ifdef SLANG_USER_CONFIG
    #include SLANG_USER_CONFIG
#endif
 
/*
The following section attempts to detect the compiler and version in use.
 
If an application defines `SLANG_COMPILER` before including this header,
they take responsibility for setting any compiler-dependent macros
used later in the file.
 
Most applications should not need to touch this section.
*/
#ifndef SLANG_COMPILER
    #define SLANG_COMPILER
 
    /*
    Compiler defines, see http://sourceforge.net/p/predef/wiki/Compilers/
    NOTE that SLANG_VC holds the compiler version - not just 1 or 0
    */
    #if defined(_MSC_VER)
        #if _MSC_VER >= 1900
            #define SLANG_VC 14
        #elif _MSC_VER >= 1800
            #define SLANG_VC 12
        #elif _MSC_VER >= 1700
            #define SLANG_VC 11
        #elif _MSC_VER >= 1600
            #define SLANG_VC 10
        #elif _MSC_VER >= 1500
            #define SLANG_VC 9
        #else
            #error "unknown version of Visual C++ compiler"
        #endif
    #elif defined(__clang__)
        #define SLANG_CLANG 1
    #elif defined(__SNC__)
        #define SLANG_SNC 1
    #elif defined(__ghs__)
        #define SLANG_GHS 1
    #elif defined(__GNUC__) /* note: __clang__, __SNC__, or __ghs__ imply __GNUC__ */
        #define SLANG_GCC 1
    #else
        #error "unknown compiler"
    #endif
    /*
    Any compilers not detected by the above logic are now now explicitly zeroed out.
    */
    #ifndef SLANG_VC
        #define SLANG_VC 0
    #endif
    #ifndef SLANG_CLANG
        #define SLANG_CLANG 0
    #endif
    #ifndef SLANG_SNC
        #define SLANG_SNC 0
    #endif
    #ifndef SLANG_GHS
        #define SLANG_GHS 0
    #endif
    #ifndef SLANG_GCC
        #define SLANG_GCC 0
    #endif
#endif /* SLANG_COMPILER */
 
/*
The following section attempts to detect the target platform being compiled for.
 
If an application defines `SLANG_PLATFORM` before including this header,
they take responsibility for setting any compiler-dependent macros
used later in the file.
 
Most applications should not need to touch this section.
*/
#ifndef SLANG_PLATFORM
    #define SLANG_PLATFORM
    #if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_PARTITION_APP
        #define SLANG_WINRT 1 /* Windows Runtime, either on Windows RT or Windows 8 */
    #elif defined(XBOXONE)
        #define SLANG_XBOXONE 1
    #elif defined(_WIN64) /* note: XBOXONE implies _WIN64 */
        #define SLANG_WIN64 1
    #elif defined(_M_PPC)
        #define SLANG_X360 1
    #elif defined(_WIN32) /* note: _M_PPC implies _WIN32 */
        #define SLANG_WIN32 1
    #elif defined(__ANDROID__)
        #define SLANG_ANDROID 1
    #elif defined(__linux__) || defined(__CYGWIN__) /* note: __ANDROID__ implies __linux__ */
        #define SLANG_LINUX 1
    #elif defined(__APPLE__)
        #include "TargetConditionals.h"
        #if TARGET_OS_MAC
            #define SLANG_OSX 1
        #else
            #define SLANG_IOS 1
        #endif
    #elif defined(__CELLOS_LV2__)
        #define SLANG_PS3 1
    #elif defined(__ORBIS__)
        #define SLANG_PS4 1
    #elif defined(__SNC__) && defined(__arm__)
        #define SLANG_PSP2 1
    #elif defined(__ghs__)
        #define SLANG_WIIU 1
    #elif defined(__EMSCRIPTEN__)
        #define SLANG_WASM 1
    #else
        #error "unknown target platform"
    #endif
    /*
    Any platforms not detected by the above logic are now now explicitly zeroed out.
    */
    #ifndef SLANG_WINRT
        #define SLANG_WINRT 0
    #endif
    #ifndef SLANG_XBOXONE
        #define SLANG_XBOXONE 0
    #endif
    #ifndef SLANG_WIN64
        #define SLANG_WIN64 0
    #endif
    #ifndef SLANG_X360
        #define SLANG_X360 0
    #endif
    #ifndef SLANG_WIN32
        #define SLANG_WIN32 0
    #endif
    #ifndef SLANG_ANDROID
        #define SLANG_ANDROID 0
    #endif
    #ifndef SLANG_LINUX
        #define SLANG_LINUX 0
    #endif
    #ifndef SLANG_IOS
        #define SLANG_IOS 0
    #endif
    #ifndef SLANG_OSX
        #define SLANG_OSX 0
    #endif
    #ifndef SLANG_PS3
        #define SLANG_PS3 0
    #endif
    #ifndef SLANG_PS4
        #define SLANG_PS4 0
    #endif
    #ifndef SLANG_PSP2
        #define SLANG_PSP2 0
    #endif
    #ifndef SLANG_WIIU
        #define SLANG_WIIU 0
    #endif
    #ifndef SLANG_WASM
        #define SLANG_WASM 0
    #endif
#endif /* SLANG_PLATFORM */
 
/* Shorthands for "families" of compilers/platforms */
#define SLANG_GCC_FAMILY (SLANG_CLANG || SLANG_SNC || SLANG_GHS || SLANG_GCC)
#define SLANG_WINDOWS_FAMILY (SLANG_WINRT || SLANG_WIN32 || SLANG_WIN64)
#define SLANG_MICROSOFT_FAMILY (SLANG_XBOXONE || SLANG_X360 || SLANG_WINDOWS_FAMILY)
#define SLANG_LINUX_FAMILY (SLANG_LINUX || SLANG_ANDROID)
#define SLANG_APPLE_FAMILY (SLANG_IOS || SLANG_OSX) /* equivalent to #if __APPLE__ */
#define SLANG_UNIX_FAMILY \
    (SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY) /* shortcut for unix/posix platforms */
 
/* Macros concerning DirectX */
#if !defined(SLANG_CONFIG_DX_ON_VK) || !SLANG_CONFIG_DX_ON_VK
    #define SLANG_ENABLE_DXVK 0
    #define SLANG_ENABLE_VKD3D 0
#else
    #define SLANG_ENABLE_DXVK 1
    #define SLANG_ENABLE_VKD3D 1
#endif
 
#if SLANG_WINDOWS_FAMILY
    #define SLANG_ENABLE_DIRECTX 1
    #define SLANG_ENABLE_DXGI_DEBUG 1
    #define SLANG_ENABLE_DXBC_SUPPORT 1
    #define SLANG_ENABLE_PIX 1
#elif SLANG_LINUX_FAMILY
    #define SLANG_ENABLE_DIRECTX (SLANG_ENABLE_DXVK || SLANG_ENABLE_VKD3D)
    #define SLANG_ENABLE_DXGI_DEBUG 0
    #define SLANG_ENABLE_DXBC_SUPPORT 0
    #define SLANG_ENABLE_PIX 0
#else
    #define SLANG_ENABLE_DIRECTX 0
    #define SLANG_ENABLE_DXGI_DEBUG 0
    #define SLANG_ENABLE_DXBC_SUPPORT 0
    #define SLANG_ENABLE_PIX 0
#endif
 
/* Macro for declaring if a method is no throw. Should be set before the return parameter. */
#ifndef SLANG_NO_THROW
    #if SLANG_WINDOWS_FAMILY && !defined(SLANG_DISABLE_EXCEPTIONS)
        #define SLANG_NO_THROW __declspec(nothrow)
    #endif
#endif
#ifndef SLANG_NO_THROW
    #define SLANG_NO_THROW
#endif
 
/* The `SLANG_STDCALL` and `SLANG_MCALL` defines are used to set the calling
convention for interface methods.
*/
#ifndef SLANG_STDCALL
    #if SLANG_MICROSOFT_FAMILY
        #define SLANG_STDCALL __stdcall
    #else
        #define SLANG_STDCALL
    #endif
#endif
#ifndef SLANG_MCALL
    #define SLANG_MCALL SLANG_STDCALL
#endif
 
 
#if !defined(SLANG_STATIC) && !defined(SLANG_DYNAMIC)
    #define SLANG_DYNAMIC
#endif
 
#if defined(_MSC_VER)
    #define SLANG_DLL_EXPORT __declspec(dllexport)
#else
    #if SLANG_WINDOWS_FAMILY
        #define SLANG_DLL_EXPORT \
            __attribute__((dllexport)) __attribute__((__visibility__("default")))
    #else
        #define SLANG_DLL_EXPORT __attribute__((__visibility__("default")))
    #endif
#endif
 
#if defined(SLANG_DYNAMIC)
    #if defined(_MSC_VER)
        #ifdef SLANG_DYNAMIC_EXPORT
            #define SLANG_API SLANG_DLL_EXPORT
        #else
            #define SLANG_API __declspec(dllimport)
        #endif
    #else
        // TODO: need to consider compiler capabilities
        // #     ifdef SLANG_DYNAMIC_EXPORT
        #define SLANG_API SLANG_DLL_EXPORT
    // #     endif
    #endif
#endif
 
#ifndef SLANG_API
    #define SLANG_API
#endif
 
// GCC Specific
#if SLANG_GCC_FAMILY
    #define SLANG_NO_INLINE __attribute__((noinline))
    #define SLANG_FORCE_INLINE inline __attribute__((always_inline))
    #define SLANG_BREAKPOINT(id) __builtin_trap();
#endif // SLANG_GCC_FAMILY
 
#if SLANG_GCC_FAMILY || defined(__clang__)
    // Use the builtin directly so we don't need to have an include of stddef.h
    #define SLANG_OFFSET_OF(T, ELEMENT) __builtin_offsetof(T, ELEMENT)
#endif
 
#ifndef SLANG_OFFSET_OF
    #define SLANG_OFFSET_OF(T, ELEMENT) (size_t(&((T*)1)->ELEMENT) - 1)
#endif
 
// Microsoft VC specific
#if SLANG_VC
    #define SLANG_NO_INLINE __declspec(noinline)
    #define SLANG_FORCE_INLINE __forceinline
    #define SLANG_BREAKPOINT(id) __debugbreak();
 
    #define SLANG_INT64(x) (x##i64)
    #define SLANG_UINT64(x) (x##ui64)
#endif // SLANG_MICROSOFT_FAMILY
 
#ifndef SLANG_FORCE_INLINE
    #define SLANG_FORCE_INLINE inline
#endif
#ifndef SLANG_NO_INLINE
    #define SLANG_NO_INLINE
#endif
 
#ifndef SLANG_COMPILE_TIME_ASSERT
    #define SLANG_COMPILE_TIME_ASSERT(x) static_assert(x)
#endif
 
#ifndef SLANG_BREAKPOINT
    // Make it crash with a write to 0!
    #define SLANG_BREAKPOINT(id) (*((int*)0) = int(id));
#endif
 
// Use for getting the amount of members of a standard C array.
// Use 0[x] here to catch the case where x has an overloaded subscript operator
#define SLANG_COUNT_OF(x) (SlangSSizeT(sizeof(x) / sizeof(0 [x])))
#define SLANG_INLINE inline
 
// If explicitly disabled and not set, set to not available
#if !defined(SLANG_HAS_EXCEPTIONS) && defined(SLANG_DISABLE_EXCEPTIONS)
    #define SLANG_HAS_EXCEPTIONS 0
#endif
 
// If not set, the default is exceptions are available
#ifndef SLANG_HAS_EXCEPTIONS
    #define SLANG_HAS_EXCEPTIONS 1
#endif
 
// Other defines
#define SLANG_STRINGIZE_HELPER(X) #X
#define SLANG_STRINGIZE(X) SLANG_STRINGIZE_HELPER(X)
 
#define SLANG_CONCAT_HELPER(X, Y) X##Y
#define SLANG_CONCAT(X, Y) SLANG_CONCAT_HELPER(X, Y)
 
#ifndef SLANG_UNUSED
    #define SLANG_UNUSED(v) (void)v;
#endif
 
#if defined(__llvm__)
    #define SLANG_MAYBE_UNUSED [[maybe_unused]]
#else
    #define SLANG_MAYBE_UNUSED
#endif
 
// Used for doing constant literals
#ifndef SLANG_INT64
    #define SLANG_INT64(x) (x##ll)
#endif
#ifndef SLANG_UINT64
    #define SLANG_UINT64(x) (x##ull)
#endif
 
 
#ifdef __cplusplus
    #define SLANG_EXTERN_C extern "C"
#else
    #define SLANG_EXTERN_C
#endif
 
#ifdef __cplusplus
    // C++ specific macros
    // Clang
    #if SLANG_CLANG
        #if (__clang_major__ * 10 + __clang_minor__) >= 33
            #define SLANG_HAS_MOVE_SEMANTICS 1
            #define SLANG_HAS_ENUM_CLASS 1
            #define SLANG_OVERRIDE override
        #endif
 
    // Gcc
    #elif SLANG_GCC_FAMILY
        // Check for C++11
        #if (__cplusplus >= 201103L)
            #if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405
                #define SLANG_HAS_MOVE_SEMANTICS 1
            #endif
            #if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
                #define SLANG_HAS_ENUM_CLASS 1
            #endif
            #if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407
                #define SLANG_OVERRIDE override
            #endif
        #endif
    #endif // SLANG_GCC_FAMILY
 
    // Visual Studio
 
    #if SLANG_VC
        // C4481: nonstandard extension used: override specifier 'override'
        #if _MSC_VER < 1700
            #pragma warning(disable : 4481)
        #endif
        #define SLANG_OVERRIDE override
        #if _MSC_VER >= 1600
            #define SLANG_HAS_MOVE_SEMANTICS 1
        #endif
        #if _MSC_VER >= 1700
            #define SLANG_HAS_ENUM_CLASS 1
        #endif
    #endif // SLANG_VC
 
    // Set non set
    #ifndef SLANG_OVERRIDE
        #define SLANG_OVERRIDE
    #endif
    #ifndef SLANG_HAS_ENUM_CLASS
        #define SLANG_HAS_ENUM_CLASS 0
    #endif
    #ifndef SLANG_HAS_MOVE_SEMANTICS
        #define SLANG_HAS_MOVE_SEMANTICS 0
    #endif
 
#endif // __cplusplus
 
/* Macros for detecting processor */
#if defined(_M_ARM) || defined(__ARM_EABI__)
    // This is special case for nVidia tegra
    #define SLANG_PROCESSOR_ARM 1
#elif defined(__i386__) || defined(_M_IX86)
    #define SLANG_PROCESSOR_X86 1
#elif defined(_M_AMD64) || defined(_M_X64) || defined(__amd64) || defined(__x86_64)
    #define SLANG_PROCESSOR_X86_64 1
#elif defined(_PPC_) || defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC)
    #if defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__) || \
        defined(__64BIT__) || defined(_LP64) || defined(__LP64__)
        #define SLANG_PROCESSOR_POWER_PC_64 1
    #else
        #define SLANG_PROCESSOR_POWER_PC 1
    #endif
#elif defined(__arm__)
    #define SLANG_PROCESSOR_ARM 1
#elif defined(_M_ARM64) || defined(__aarch64__) || defined(__ARM_ARCH_ISA_A64)
    #define SLANG_PROCESSOR_ARM_64 1
#elif defined(__EMSCRIPTEN__)
    #define SLANG_PROCESSOR_WASM 1
#endif
 
#ifndef SLANG_PROCESSOR_ARM
    #define SLANG_PROCESSOR_ARM 0
#endif
 
#ifndef SLANG_PROCESSOR_ARM_64
    #define SLANG_PROCESSOR_ARM_64 0
#endif
 
#ifndef SLANG_PROCESSOR_X86
    #define SLANG_PROCESSOR_X86 0
#endif
 
#ifndef SLANG_PROCESSOR_X86_64
    #define SLANG_PROCESSOR_X86_64 0
#endif
 
#ifndef SLANG_PROCESSOR_POWER_PC
    #define SLANG_PROCESSOR_POWER_PC 0
#endif
 
#ifndef SLANG_PROCESSOR_POWER_PC_64
    #define SLANG_PROCESSOR_POWER_PC_64 0
#endif
 
#ifndef SLANG_PROCESSOR_WASM
    #define SLANG_PROCESSOR_WASM 0
#endif
 
// Processor families
 
#define SLANG_PROCESSOR_FAMILY_X86 (SLANG_PROCESSOR_X86_64 | SLANG_PROCESSOR_X86)
#define SLANG_PROCESSOR_FAMILY_ARM (SLANG_PROCESSOR_ARM | SLANG_PROCESSOR_ARM_64)
#define SLANG_PROCESSOR_FAMILY_POWER_PC (SLANG_PROCESSOR_POWER_PC_64 | SLANG_PROCESSOR_POWER_PC)
 
// Pointer size
#define SLANG_PTR_IS_64 \
    (SLANG_PROCESSOR_ARM_64 | SLANG_PROCESSOR_X86_64 | SLANG_PROCESSOR_POWER_PC_64)
#define SLANG_PTR_IS_32 (SLANG_PTR_IS_64 ^ 1)
 
// Processor features
#if SLANG_PROCESSOR_FAMILY_X86
    #define SLANG_LITTLE_ENDIAN 1
    #define SLANG_UNALIGNED_ACCESS 1
#elif SLANG_PROCESSOR_FAMILY_ARM
    #if defined(__ARMEB__)
        #define SLANG_BIG_ENDIAN 1
    #else
        #define SLANG_LITTLE_ENDIAN 1
    #endif
#elif SLANG_PROCESSOR_FAMILY_POWER_PC
    #define SLANG_BIG_ENDIAN 1
#elif SLANG_WASM
    #define SLANG_LITTLE_ENDIAN 1
#endif
 
#ifndef SLANG_LITTLE_ENDIAN
    #define SLANG_LITTLE_ENDIAN 0
#endif
 
#ifndef SLANG_BIG_ENDIAN
    #define SLANG_BIG_ENDIAN 0
#endif
 
#ifndef SLANG_UNALIGNED_ACCESS
    #define SLANG_UNALIGNED_ACCESS 0
#endif
 
// Backtrace
#if SLANG_LINUX_FAMILY
    #include <features.h> // for __GLIBC__ define, if using GNU libc
    #if defined(__GLIBC__) || (__ANDROID_API__ >= 33)
        #define SLANG_HAS_BACKTRACE 1
    #else
        #define SLANG_HAS_BACKTRACE 0
    #endif
#else
    #define SLANG_HAS_BACKTRACE 0
#endif
 
// One endianness must be set
#if ((SLANG_BIG_ENDIAN | SLANG_LITTLE_ENDIAN) == 0)
    #error "Couldn't determine endianness"
#endif
 
#ifndef SLANG_NO_INTTYPES
    #include <inttypes.h>
#endif // ! SLANG_NO_INTTYPES
 
#ifndef SLANG_NO_STDDEF
    #include <stddef.h>
#endif // ! SLANG_NO_STDDEF
 
#ifdef SLANG_NO_DEPRECATION
    #define SLANG_DEPRECATED
#else
    #define SLANG_DEPRECATED [[deprecated]]
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
    typedef uint32_t SlangUInt32;
    typedef int32_t SlangInt32;
 
    // Use SLANG_PTR_ macros to determine SlangInt/SlangUInt types.
    // This is used over say using size_t/ptrdiff_t/intptr_t/uintptr_t, because on some targets,
    // these types are distinct from their uint_t/int_t equivalents and so produce ambiguity with
    // function overloading.
    //
    // SlangSizeT is helpful as on some compilers size_t is distinct from a regular integer type and
    // so overloading doesn't work. Casting to SlangSizeT works around this.
#if SLANG_PTR_IS_64
    typedef int64_t SlangInt;
    typedef uint64_t SlangUInt;
 
    typedef int64_t SlangSSizeT;
    typedef uint64_t SlangSizeT;
#else
typedef int32_t SlangInt;
typedef uint32_t SlangUInt;
 
typedef int32_t SlangSSizeT;
typedef uint32_t SlangSizeT;
#endif
 
    typedef bool SlangBool;
 
 
    typedef int SlangSeverityIntegral;
    enum SlangSeverity : SlangSeverityIntegral
    {
        SLANG_SEVERITY_DISABLED = 0, 
        SLANG_SEVERITY_NOTE = 1,     
        SLANG_SEVERITY_WARNING = 2,  
        SLANG_SEVERITY_ERROR = 3,    
        SLANG_SEVERITY_FATAL = 4, 
        SLANG_SEVERITY_INTERNAL =
            5, 
    };
 
    typedef int SlangDiagnosticFlags;
    enum
    {
        SLANG_DIAGNOSTIC_FLAG_VERBOSE_PATHS = 0x01,
        SLANG_DIAGNOSTIC_FLAG_TREAT_WARNINGS_AS_ERRORS = 0x02
    };
 
    typedef int SlangBindableResourceIntegral;
    enum SlangBindableResourceType : SlangBindableResourceIntegral
    {
        SLANG_NON_BINDABLE = 0,
        SLANG_TEXTURE = 1,
        SLANG_SAMPLER = 2,
        SLANG_UNIFORM_BUFFER = 3,
        SLANG_STORAGE_BUFFER = 4,
    };
 
    /* NOTE! To keep binary compatibility care is needed with this enum!
 
    * To add value, only add at the bottom (before COUNT_OF)
    * To remove a value, add _DEPRECATED as a suffix, but leave in the list
 
    This will make the enum values stable, and compatible with libraries that might not use the
    latest enum values.
    */
    typedef int SlangCompileTargetIntegral;
    enum SlangCompileTarget : SlangCompileTargetIntegral
    {
        SLANG_TARGET_UNKNOWN = 0,
        SLANG_TARGET_NONE = 1,
        SLANG_GLSL = 2,
        SLANG_GLSL_VULKAN_DEPRECATED = 3, //< deprecated and removed: just use `SLANG_GLSL`.
        SLANG_GLSL_VULKAN_ONE_DESC_DEPRECATED = 4, //< deprecated and removed.
        SLANG_HLSL = 5,
        SLANG_SPIRV = 6,
        SLANG_SPIRV_ASM = 7,
        SLANG_DXBC = 8,
        SLANG_DXBC_ASM = 9,
        SLANG_DXIL = 10,
        SLANG_DXIL_ASM = 11,
        SLANG_C_SOURCE = 12,              
        SLANG_CPP_SOURCE = 13,            
        SLANG_HOST_EXECUTABLE = 14,       
        SLANG_SHADER_SHARED_LIBRARY = 15, 
        SLANG_SHADER_HOST_CALLABLE = 16,  
        SLANG_CUDA_SOURCE = 17,           
        SLANG_PTX = 18,                   
        SLANG_CUDA_OBJECT_CODE = 19,      
        SLANG_OBJECT_CODE = 20, 
        SLANG_HOST_CPP_SOURCE = 21,     
        SLANG_HOST_HOST_CALLABLE = 22,  
        SLANG_CPP_PYTORCH_BINDING = 23, 
        SLANG_METAL = 24,               
        SLANG_METAL_LIB = 25,           
        SLANG_METAL_LIB_ASM = 26,       
        SLANG_HOST_SHARED_LIBRARY = 27, 
        SLANG_WGSL = 28,                
        SLANG_WGSL_SPIRV_ASM = 29,      
        SLANG_WGSL_SPIRV = 30,          
 
        SLANG_HOST_VM = 31,     
        SLANG_CPP_HEADER = 32,  
        SLANG_CUDA_HEADER = 33, 
 
        SLANG_HOST_OBJECT_CODE = 34, 
        SLANG_HOST_LLVM_IR = 35,     
        SLANG_SHADER_LLVM_IR = 36,   
 
        SLANG_TARGET_COUNT_OF,
    };
 
    /* A "container format" describes the way that the outputs
    for multiple files, entry points, targets, etc. should be
    combined into a single artifact for output. */
    typedef int SlangContainerFormatIntegral;
    enum SlangContainerFormat : SlangContainerFormatIntegral
    {
        /* Don't generate a container. */
        SLANG_CONTAINER_FORMAT_NONE = 0,
 
        /* Generate a container in the `.slang-module` format,
        which includes reflection information, compiled kernels, etc. */
        SLANG_CONTAINER_FORMAT_SLANG_MODULE = 1,
    };
 
    typedef int SlangPassThroughIntegral;
    enum SlangPassThrough : SlangPassThroughIntegral
    {
        SLANG_PASS_THROUGH_NONE = 0,
        SLANG_PASS_THROUGH_FXC = 1,
        SLANG_PASS_THROUGH_DXC = 2,
        SLANG_PASS_THROUGH_GLSLANG = 3,
        SLANG_PASS_THROUGH_SPIRV_DIS = 4,
        SLANG_PASS_THROUGH_CLANG = 5,         
        SLANG_PASS_THROUGH_VISUAL_STUDIO = 6, 
        SLANG_PASS_THROUGH_GCC = 7,           
        SLANG_PASS_THROUGH_GENERIC_C_CPP = 8, 
        SLANG_PASS_THROUGH_NVRTC = 9,         
        SLANG_PASS_THROUGH_LLVM = 10,         
        SLANG_PASS_THROUGH_SPIRV_OPT = 11,    
        SLANG_PASS_THROUGH_METAL = 12,        
        SLANG_PASS_THROUGH_TINT = 13,         
        SLANG_PASS_THROUGH_SPIRV_LINK = 14,   
        SLANG_PASS_THROUGH_COUNT_OF,
    };
 
    /* Defines an archive type used to holds a 'file system' type structure. */
    typedef int SlangArchiveTypeIntegral;
    enum SlangArchiveType : SlangArchiveTypeIntegral
    {
        SLANG_ARCHIVE_TYPE_UNDEFINED = 0,
        SLANG_ARCHIVE_TYPE_ZIP = 1,
        SLANG_ARCHIVE_TYPE_RIFF = 2, 
        SLANG_ARCHIVE_TYPE_RIFF_DEFLATE = 3,
        SLANG_ARCHIVE_TYPE_RIFF_LZ4 = 4,
        SLANG_ARCHIVE_TYPE_COUNT_OF,
    };
 
    typedef unsigned int SlangCompileFlags;
    enum
    {
        /* Do as little mangling of names as possible, to try to preserve original names */
        SLANG_COMPILE_FLAG_NO_MANGLING = 1 << 3,
 
        /* Skip code generation step, just check the code and generate layout */
        SLANG_COMPILE_FLAG_NO_CODEGEN = 1 << 4,
 
        /* Obfuscate shader names on release products */
        SLANG_COMPILE_FLAG_OBFUSCATE = 1 << 5,
 
        /* Deprecated flags: kept around to allow existing applications to
        compile. Note that the relevant features will still be left in
        their default state. */
        SLANG_COMPILE_FLAG_NO_CHECKING = 0,
        SLANG_COMPILE_FLAG_SPLIT_MIXED_TYPES = 0,
    };
 
    typedef unsigned int SlangTargetFlags;
    enum
    {
        /* When compiling for a D3D Shader Model 5.1 or higher target, allocate
           distinct register spaces for parameter blocks.
 
           @deprecated This behavior is now enabled unconditionally.
        */
        SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES = 1 << 4,
 
        /* When set, will generate target code that contains all entrypoints defined
           in the input source or specified via the `spAddEntryPoint` function in a
           single output module (library/source file).
        */
        SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM = 1 << 8,
 
        /* When set, will dump out the IR between intermediate compilation steps.*/
        SLANG_TARGET_FLAG_DUMP_IR = 1 << 9,
 
        /* When set, will generate SPIRV directly rather than via glslang. */
        // This flag will be deprecated, use CompilerOption instead.
        SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY = 1 << 10,
    };
    inline constexpr SlangTargetFlags kDefaultTargetFlags =
        SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY;
 
    typedef unsigned int SlangFloatingPointModeIntegral;
    enum SlangFloatingPointMode : SlangFloatingPointModeIntegral
    {
        SLANG_FLOATING_POINT_MODE_DEFAULT = 0,
        SLANG_FLOATING_POINT_MODE_FAST = 1,
        SLANG_FLOATING_POINT_MODE_PRECISE = 2,
    };
 
    typedef unsigned int SlangFpDenormalModeIntegral;
    enum SlangFpDenormalMode : SlangFpDenormalModeIntegral
    {
        SLANG_FP_DENORM_MODE_ANY = 0,
        SLANG_FP_DENORM_MODE_PRESERVE = 1,
        SLANG_FP_DENORM_MODE_FTZ = 2,
    };
 
    typedef unsigned int SlangLineDirectiveModeIntegral;
    enum SlangLineDirectiveMode : SlangLineDirectiveModeIntegral
    {
        SLANG_LINE_DIRECTIVE_MODE_DEFAULT =
            0,                              
        SLANG_LINE_DIRECTIVE_MODE_NONE = 1, 
        SLANG_LINE_DIRECTIVE_MODE_STANDARD = 2,   
        SLANG_LINE_DIRECTIVE_MODE_GLSL = 3,       
        SLANG_LINE_DIRECTIVE_MODE_SOURCE_MAP = 4, 
    };
 
    typedef int SlangSourceLanguageIntegral;
    enum SlangSourceLanguage : SlangSourceLanguageIntegral
    {
        SLANG_SOURCE_LANGUAGE_UNKNOWN = 0,
        SLANG_SOURCE_LANGUAGE_SLANG = 1,
        SLANG_SOURCE_LANGUAGE_HLSL = 2,
        SLANG_SOURCE_LANGUAGE_GLSL = 3,
        SLANG_SOURCE_LANGUAGE_C = 4,
        SLANG_SOURCE_LANGUAGE_CPP = 5,
        SLANG_SOURCE_LANGUAGE_CUDA = 6,
        SLANG_SOURCE_LANGUAGE_SPIRV = 7,
        SLANG_SOURCE_LANGUAGE_METAL = 8,
        SLANG_SOURCE_LANGUAGE_WGSL = 9,
        SLANG_SOURCE_LANGUAGE_LLVM = 10,
        SLANG_SOURCE_LANGUAGE_COUNT_OF,
    };
 
    typedef unsigned int SlangProfileIDIntegral;
    enum SlangProfileID : SlangProfileIDIntegral
    {
        SLANG_PROFILE_UNKNOWN = 0,
    };
 
 
    typedef SlangInt32 SlangCapabilityIDIntegral;
    enum SlangCapabilityID : SlangCapabilityIDIntegral
    {
        SLANG_CAPABILITY_UNKNOWN = 0,
    };
 
    typedef unsigned int SlangMatrixLayoutModeIntegral;
    enum SlangMatrixLayoutMode : SlangMatrixLayoutModeIntegral
    {
        SLANG_MATRIX_LAYOUT_MODE_UNKNOWN = 0,
        SLANG_MATRIX_LAYOUT_ROW_MAJOR = 1,
        SLANG_MATRIX_LAYOUT_COLUMN_MAJOR = 2,
    };
 
    typedef SlangUInt32 SlangStageIntegral;
    enum SlangStage : SlangStageIntegral
    {
        SLANG_STAGE_NONE = 0,
        SLANG_STAGE_VERTEX = 1,
        SLANG_STAGE_HULL = 2,
        SLANG_STAGE_DOMAIN = 3,
        SLANG_STAGE_GEOMETRY = 4,
        SLANG_STAGE_FRAGMENT = 5,
        SLANG_STAGE_COMPUTE = 6,
        SLANG_STAGE_RAY_GENERATION = 7,
        SLANG_STAGE_INTERSECTION = 8,
        SLANG_STAGE_ANY_HIT = 9,
        SLANG_STAGE_CLOSEST_HIT = 10,
        SLANG_STAGE_MISS = 11,
        SLANG_STAGE_CALLABLE = 12,
        SLANG_STAGE_MESH = 13,
        SLANG_STAGE_AMPLIFICATION = 14,
        SLANG_STAGE_DISPATCH = 15,
        //
        SLANG_STAGE_COUNT,
 
        // alias:
        SLANG_STAGE_PIXEL = SLANG_STAGE_FRAGMENT,
    };
 
    typedef SlangUInt32 SlangScopeIntegral;
    enum SlangScope : SlangScopeIntegral
    {
        SLANG_SCOPE_NONE,
        SLANG_SCOPE_THREAD,
        SLANG_SCOPE_WAVE,
        SLANG_SCOPE_THREAD_GROUP,
    };
 
    typedef SlangUInt32 SlangCooperativeMatrixUseIntegral;
    enum SlangCooperativeMatrixUse : SlangCooperativeMatrixUseIntegral
    {
        SLANG_COOPERATIVE_MATRIX_USE_A = 0,
        SLANG_COOPERATIVE_MATRIX_USE_B = 1,
        SLANG_COOPERATIVE_MATRIX_USE_ACCUMULATOR = 2,
    };
 
    typedef SlangUInt32 SlangCooperativeVectorMatrixLayoutIntegral;
    enum SlangCooperativeVectorMatrixLayout : SlangCooperativeVectorMatrixLayoutIntegral
    {
        SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR = 0,
        SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR = 1,
        SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL = 2,
        SLANG_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL = 3,
    };
 
    typedef SlangUInt32 SlangDebugInfoLevelIntegral;
    enum SlangDebugInfoLevel : SlangDebugInfoLevelIntegral
    {
        SLANG_DEBUG_INFO_LEVEL_NONE = 0,     
        SLANG_DEBUG_INFO_LEVEL_MINIMAL = 1,  
        SLANG_DEBUG_INFO_LEVEL_STANDARD = 2, 
        SLANG_DEBUG_INFO_LEVEL_MAXIMAL = 3,  
    };
 
    /* Describes the debugging information format produced during a compilation. */
    typedef SlangUInt32 SlangDebugInfoFormatIntegral;
    enum SlangDebugInfoFormat : SlangDebugInfoFormatIntegral
    {
        SLANG_DEBUG_INFO_FORMAT_DEFAULT = 0, 
        SLANG_DEBUG_INFO_FORMAT_C7 = 1,      
        SLANG_DEBUG_INFO_FORMAT_PDB = 2,     
 
        SLANG_DEBUG_INFO_FORMAT_STABS = 3, 
        SLANG_DEBUG_INFO_FORMAT_COFF = 4,  
        SLANG_DEBUG_INFO_FORMAT_DWARF = 5, 
 
        SLANG_DEBUG_INFO_FORMAT_COUNT_OF,
    };
 
    typedef SlangUInt32 SlangOptimizationLevelIntegral;
    enum SlangOptimizationLevel : SlangOptimizationLevelIntegral
    {
        SLANG_OPTIMIZATION_LEVEL_NONE = 0,    
        SLANG_OPTIMIZATION_LEVEL_DEFAULT = 1, 
        SLANG_OPTIMIZATION_LEVEL_HIGH = 2,    
        SLANG_OPTIMIZATION_LEVEL_MAXIMAL = 3, 
    };
 
    enum SlangEmitSpirvMethod
    {
        SLANG_EMIT_SPIRV_DEFAULT = 0,
        SLANG_EMIT_SPIRV_VIA_GLSL = 1,
        SLANG_EMIT_SPIRV_DIRECTLY = 2,
    };
 
    enum SlangEmitCPUMethod
    {
        SLANG_EMIT_CPU_DEFAULT = 0,
        SLANG_EMIT_CPU_VIA_CPP = 1,
        SLANG_EMIT_CPU_VIA_LLVM = 2,
    };
 
    enum SlangDiagnosticColor
    {
        SLANG_DIAGNOSTIC_COLOR_AUTO = 0,   // Use color if output sink is a tty
        SLANG_DIAGNOSTIC_COLOR_ALWAYS = 1, // Always use color
        SLANG_DIAGNOSTIC_COLOR_NEVER = 2,  // Never use color
    };
 
    // All compiler option names supported by Slang.
    //
    // IMPORTANT: ABI STABILITY POLICY FOR CompilerOptionName
    //
    // Every enumerator has an explicit integer value. Rules:
    //   1. NEVER insert a new enumerator in the middle of the list.
    //   2. NEVER remove an enumerator; rename to REMOVED_<Name> and keep the value.
    //   3. NEVER reuse an integer value from a removed/deprecated entry.
    //   4. NEW entries MUST be appended immediately before CountOf, assigning the next
    //      sequential integer (equal to the preceding enumerator's value + 1).
    //
    // Violation of these rules silently breaks binary compatibility for any caller
    // compiled against an older version of this header.
    namespace slang
    {
    enum class CompilerOptionName
    {
        MacroDefine = 0, // stringValue0: macro name;  stringValue1: macro value
        DepFile = 1,
        EntryPointName = 2,
        Specialize = 3,
        Help = 4,
        HelpStyle = 5,
        Include = 6, // stringValue: additional include path.
        Language = 7,
        MatrixLayoutColumn = 8,          // bool
        MatrixLayoutRow = 9,             // bool
        ZeroInitialize = 10,             // bool
        IgnoreCapabilities = 11,         // bool
        RestrictiveCapabilityCheck = 12, // bool
        ModuleName = 13,                 // stringValue0: module name.
        Output = 14,
        Profile = 15, // intValue0: profile
        Stage = 16,   // intValue0: stage
        Target = 17,  // intValue0: CodeGenTarget
        Version = 18,
        WarningsAsErrors = 19, // stringValue0: "all" or comma-separated list of
                               // warning codes or names.
        DisableWarnings = 20,  // stringValue0: comma separated list of warning codes or names.
        EnableWarning = 21,    // stringValue0: warning code or name.
        DisableWarning = 22,   // stringValue0: warning code or name.
        DumpWarningDiagnostics = 23,
        InputFilesRemain = 24,
        EmitIr = 25,                        // bool
        ReportDownstreamTime = 26,          // bool
        ReportPerfBenchmark = 27,           // bool
        ReportCheckpointIntermediates = 28, // bool
        SkipSPIRVValidation = 29,           // bool
        SourceEmbedStyle = 30,
        SourceEmbedName = 31,
        SourceEmbedLanguage = 32,
        DisableShortCircuit = 33,            // bool
        MinimumSlangOptimization = 34,       // bool
        DisableNonEssentialValidations = 35, // bool
        DisableSourceMap = 36,               // bool
        UnscopedEnum = 37,                   // bool
        PreserveParameters = 38, // bool: preserve all resource parameters in the output code.
 
        // Target
        Capability = 39,                // intValue0: CapabilityName
        DefaultImageFormatUnknown = 40, // bool
        DisableDynamicDispatch = 41,    // bool
        DisableSpecialization = 42,     // bool
        FloatingPointMode = 43,         // intValue0: FloatingPointMode
        DebugInformation = 44,          // intValue0: DebugInfoLevel
        LineDirectiveMode = 45,
        Optimization = 46, // intValue0: OptimizationLevel
        Obfuscate = 47,    // bool
 
        VulkanBindShift = 48,      // intValue0 (higher 8 bits): kind; intValue0(lower bits): set;
                                   // intValue1: shift
        VulkanBindGlobals = 49,    // intValue0: index; intValue1: set
        VulkanInvertY = 50,        // bool
        VulkanUseDxPositionW = 51, // bool
        VulkanUseEntryPointName = 52, // bool
        VulkanUseGLLayout = 53,       // bool
        VulkanEmitReflection = 54,    // bool
 
        GLSLForceScalarLayout = 55,   // bool
        EnableEffectAnnotations = 56, // bool
 
        EmitSpirvViaGLSL = 57,     // bool (will be deprecated)
        EmitSpirvDirectly = 58,    // bool (will be deprecated)
        SPIRVCoreGrammarJSON = 59, // stringValue0: json path
        IncompleteLibrary = 60, // bool, when set, will not issue an error when the linked program
                                // has unresolved extern function symbols.
 
        // Downstream
        CompilerPath = 61,
        DefaultDownstreamCompiler = 62,
        DownstreamArgs = 63, // stringValue0: downstream compiler name. stringValue1: argument list,
                             // one per line.
        PassThrough = 64,
 
        // Repro
        DumpRepro = 65,
        DumpReproOnError = 66,
        ExtractRepro = 67,
        LoadRepro = 68,
        LoadReproDirectory = 69,
        ReproFallbackDirectory = 70,
 
        // Debugging
        DumpAst = 71,
        DumpIntermediatePrefix = 72,
        DumpIntermediates = 73, // bool
        DumpIr = 74,            // bool
        DumpIrIds = 75,
        PreprocessorOutput = 76,
        OutputIncludes = 77,
        ReproFileSystem = 78,
        REMOVED_SerialIR = 79, // deprecated and removed; value must never be reused
        SkipCodeGen = 80,      // bool
        ValidateIr = 81,       // bool
        VerbosePaths = 82,
        VerifyDebugSerialIr = 83,
        NoCodeGen = 84, // Not used.
 
        // Experimental
        FileSystem = 85,
        Heterogeneous = 86,
        NoMangle = 87,
        NoHLSLBinding = 88,
        NoHLSLPackConstantBufferElements = 89,
        ValidateUniformity = 90,
        AllowGLSL = 91,
        EnableExperimentalPasses = 92,
        BindlessSpaceIndex = 93,      // int
        SPIRVResourceHeapStride = 94, // int: byte stride for SPIRV resource descriptor heap
        SPIRVSamplerHeapStride = 95,  // int: byte stride for SPIRV sampler descriptor heap
 
        // Internal
        ArchiveType = 96,
        CompileCoreModule = 97,
        Doc = 98,
 
        IrCompression = 99, // deprecated; value must never be reused
 
        LoadCoreModule = 100,
        ReferenceModule = 101,
        SaveCoreModule = 102,
        SaveCoreModuleBinSource = 103,
        TrackLiveness = 104,
        LoopInversion = 105, // bool, enable loop inversion optimization
 
        ParameterBlocksUseRegisterSpaces = 106,  // Deprecated; value must never be reused
        LanguageVersion = 107,                   // intValue0: SlangLanguageVersion
        TypeConformance = 108,                   // stringValue0: type conformance to link; format:
                                                 // "<TypeName>:<IInterfaceName>[=<sequentialId>]",
                                                 // e.g. "Impl:IFoo=3" or "Impl:IFoo".
        EnableExperimentalDynamicDispatch = 109, // bool, experimental
        EmitReflectionJSON = 110,                // bool
 
        CountOfParsableOptions = 111, // historical sentinel; value must not be reused
 
        // Options added after the original set. Most have CLI flags; a few are
        // API-only (marked below). All future additions belong after DiagnosticColor,
        // immediately before CountOf.
        DebugInformationFormat = 112,  // intValue0: DebugInfoFormat (derived from -g; no direct CLI
                                       // flag)
        VulkanBindShiftAll = 113,      // intValue0: kind; intValue1: shift (derived from
                                       // -fvk-x-shift; no direct CLI flag)
        GenerateWholeProgram = 114,    // bool
        UseUpToDateBinaryModule = 115, // bool, when set, will only load precompiled modules
                                       // if up-to-date with source. (API-only; no direct CLI flag)
        EmbedDownstreamIR = 116,       // bool
        ForceDXLayout = 117,           // bool
 
        // Setting of EmitSpirvDirectly or EmitSpirvViaGLSL will turn into this option internally.
        EmitSpirvMethod = 118, // enum SlangEmitSpirvMethod (derived; no direct CLI flag)
 
        SaveGLSLModuleBinSource = 119,
 
        SkipDownstreamLinking = 120, // bool, experimental (API-only; no direct CLI flag)
        DumpModule = 121,
 
        GetModuleInfo = 122,              // Print serialized module version and name
        GetSupportedModuleVersions = 123, // Print the min and max module versions this compiler
                                          // supports
 
        EmitSeparateDebug = 124, // bool
 
        // Floating point denormal handling modes
        DenormalModeFp16 = 125,
        DenormalModeFp32 = 126,
        DenormalModeFp64 = 127,
 
        // Bitfield options
        UseMSVCStyleBitfieldPacking = 128, // bool
 
        ForceCLayout = 129, // bool
 
        ExperimentalFeature = 130, // bool, enable experimental features
 
        ReportDetailedPerfBenchmark = 131, // bool, reports detailed compiler performance benchmark
                                           // results
        ValidateIRDetailed = 132,          // bool, enable detailed IR validation
        DumpIRBefore = 133,                // string, pass name to dump IR before
        DumpIRAfter = 134,                 // string, pass name to dump IR after
 
        EmitCPUMethod = 135,    // enum SlangEmitCPUMethod (derived; no direct CLI flag)
        EmitCPUViaCPP = 136,    // bool
        EmitCPUViaLLVM = 137,   // bool
        LLVMTargetTriple = 138, // string
        LLVMCPU = 139,          // string
        LLVMFeatures = 140,     // string
 
        EnableRichDiagnostics = 141, // bool, enable the experimental rich diagnostics
 
        ReportDynamicDispatchSites = 142, // bool
 
        EnableMachineReadableDiagnostics = 143, // bool, enable machine-readable diagnostic output
                                                // (implies EnableRichDiagnostics)
 
        DiagnosticColor = 144, // intValue0: SlangDiagnosticColor (always, never, auto)
 
        // Add new options HERE, immediately before CountOf.
 
        TraceCoverage = 145, // bool: insert per-statement execution counters
        TraceCoverageBinding =
            146, // intValue0: register index; intValue1: register space — explicit
                 //   binding for the synthesized __slang_coverage buffer. Consumed
                 //   only when TraceCoverage is enabled; the slangc CLI spelling also
                 //   enables TraceCoverage.
        TraceCoverageReservedSpace =
            147, // intValue0: descriptor/register space reserved by the host when
                 //   auto-allocating the synthesized __slang_coverage buffer. This is
                 //   a repeatable hint consumed only when TraceCoverage is enabled.
 
        CountOf,
    };
 
    enum class CompilerOptionValueKind
    {
        Int = 0,
        String = 1,
    };
 
    struct CompilerOptionValue
    {
        CompilerOptionValueKind kind = CompilerOptionValueKind::Int;
        int32_t intValue0 = 0;
        int32_t intValue1 = 0;
        const char* stringValue0 = nullptr;
        const char* stringValue1 = nullptr;
    };
 
    struct CompilerOptionEntry
    {
        CompilerOptionName name;
        CompilerOptionValue value;
    };
    } // namespace slang
 
    typedef int32_t SlangResult;
 
#define SLANG_FAILED(status) ((status) < 0)
#define SLANG_SUCCEEDED(status) ((status) >= 0)
 
#define SLANG_GET_RESULT_FACILITY(r) ((int32_t)(((r) >> 16) & 0x7fff))
#define SLANG_GET_RESULT_CODE(r) ((int32_t)((r) & 0xffff))
 
#define SLANG_MAKE_ERROR(fac, code) \
    ((((int32_t)(fac)) << 16) | ((int32_t)(code)) | int32_t(0x80000000))
#define SLANG_MAKE_SUCCESS(fac, code) ((((int32_t)(fac)) << 16) | ((int32_t)(code)))
 
    /*************************** Facilities ************************************/
 
#define SLANG_FACILITY_WIN_GENERAL 0
#define SLANG_FACILITY_WIN_INTERFACE 4
#define SLANG_FACILITY_WIN_API 7
 
#define SLANG_FACILITY_BASE 0x200
 
#define SLANG_FACILITY_CORE SLANG_FACILITY_BASE
    /* Facility for codes, that are not uniquely defined/protected. Can be used to pass back a
    specific error without requiring system wide facility uniqueness. Codes should never be part of
    a public API. */
#define SLANG_FACILITY_INTERNAL SLANG_FACILITY_BASE + 1
 
#define SLANG_FACILITY_EXTERNAL_BASE 0x210
 
    /* ************************ Win COM compatible Results ******************************/
    // https://msdn.microsoft.com/en-us/library/windows/desktop/aa378137(v=vs.85).aspx
 
#define SLANG_OK 0
#define SLANG_FAIL SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_GENERAL, 0x4005)
 
#define SLANG_MAKE_WIN_GENERAL_ERROR(code) SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_GENERAL, code)
 
#define SLANG_E_NOT_IMPLEMENTED SLANG_MAKE_WIN_GENERAL_ERROR(0x4001)
#define SLANG_E_NO_INTERFACE SLANG_MAKE_WIN_GENERAL_ERROR(0x4002)
#define SLANG_E_ABORT SLANG_MAKE_WIN_GENERAL_ERROR(0x4004)
 
#define SLANG_E_INVALID_HANDLE SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 6)
#define SLANG_E_INVALID_ARG SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 0x57)
#define SLANG_E_OUT_OF_MEMORY SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 0xe)
 
    /* *************************** other Results **************************************/
 
#define SLANG_MAKE_CORE_ERROR(code) SLANG_MAKE_ERROR(SLANG_FACILITY_CORE, code)
 
    // Supplied buffer is too small to be able to complete
#define SLANG_E_BUFFER_TOO_SMALL SLANG_MAKE_CORE_ERROR(1)
#define SLANG_E_UNINITIALIZED SLANG_MAKE_CORE_ERROR(2)
#define SLANG_E_PENDING SLANG_MAKE_CORE_ERROR(3)
#define SLANG_E_CANNOT_OPEN SLANG_MAKE_CORE_ERROR(4)
#define SLANG_E_NOT_FOUND SLANG_MAKE_CORE_ERROR(5)
#define SLANG_E_INTERNAL_FAIL SLANG_MAKE_CORE_ERROR(6)
#define SLANG_E_NOT_AVAILABLE SLANG_MAKE_CORE_ERROR(7)
#define SLANG_E_TIME_OUT SLANG_MAKE_CORE_ERROR(8)
 
    struct SlangUUID
    {
        uint32_t data1;
        uint16_t data2;
        uint16_t data3;
        uint8_t data4[8];
    };
 
// Place at the start of an interface with the guid.
// Guid should be specified as SLANG_COM_INTERFACE(0x00000000, 0x0000, 0x0000, { 0xC0, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x46 }) NOTE: it's the typical guid struct definition, without the
// surrounding {} It is not necessary to use the multiple parameters (we can wrap in parens), but
// this is simple.
#define SLANG_COM_INTERFACE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
public:                                                              \
    SLANG_FORCE_INLINE constexpr static SlangUUID getTypeGuid()      \
    {                                                                \
        return {a, b, c, d0, d1, d2, d3, d4, d5, d6, d7};            \
    }
 
// Sometimes it's useful to associate a guid with a class to identify it. This macro can used for
// this, and the guid extracted via the getTypeGuid() function defined in the type
#define SLANG_CLASS_GUID(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
    SLANG_FORCE_INLINE constexpr static SlangUUID getTypeGuid()   \
    {                                                             \
        return {a, b, c, d0, d1, d2, d3, d4, d5, d6, d7};         \
    }
 
// Helper to fill in pairs of GUIDs and return pointers. This ensures that the
// type of the GUID passed matches the pointer type, and that it is derived
// from ISlangUnknown,
// TODO(c++20): would is_derived_from be more appropriate here for private inheritance of
// ISlangUnknown?
//
// with     : void createFoo(SlangUUID, void**);
//            Slang::ComPtr<Bar> myBar;
// call with: createFoo(SLANG_IID_PPV_ARGS(myBar.writeRef()))
// to call  : createFoo(Bar::getTypeGuid(), (void**)(myBar.writeRef()))
#define SLANG_IID_PPV_ARGS(ppType)                                                         \
    std::decay_t<decltype(**(ppType))>::getTypeGuid(),                                     \
        (                                                                                  \
            (void)[] {                                                                     \
                static_assert(                                                             \
                    std::is_base_of_v<ISlangUnknown, std::decay_t<decltype(**(ppType))>>); \
            },                                                                             \
            reinterpret_cast<void**>(ppType))
 
 
    struct ISlangUnknown
    {
        SLANG_COM_INTERFACE(
            0x00000000,
            0x0000,
            0x0000,
            {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46})
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
        queryInterface(SlangUUID const& uuid, void** outObject) = 0;
        virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() = 0;
        virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() = 0;
 
        /*
        Inline methods are provided to allow the above operations to be called
        using their traditional COM names/signatures:
        */
        SlangResult QueryInterface(struct _GUID const& uuid, void** outObject)
        {
            return queryInterface(*(SlangUUID const*)&uuid, outObject);
        }
        uint32_t AddRef() { return addRef(); }
        uint32_t Release() { return release(); }
    };
#define SLANG_UUID_ISlangUnknown ISlangUnknown::getTypeGuid()
 
 
    /* An interface to provide a mechanism to cast, that doesn't require ref counting
    and doesn't have to return a pointer to a ISlangUnknown derived class */
    class ISlangCastable : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(
            0x87ede0e1,
            0x4852,
            0x44b0,
            {0x8b, 0xf2, 0xcb, 0x31, 0x87, 0x4d, 0xe2, 0x39});
 
        virtual SLANG_NO_THROW void* SLANG_MCALL castAs(const SlangUUID& guid) = 0;
    };
 
    class ISlangClonable : public ISlangCastable
    {
        SLANG_COM_INTERFACE(
            0x1ec36168,
            0xe9f4,
            0x430d,
            {0xbb, 0x17, 0x4, 0x8a, 0x80, 0x46, 0xb3, 0x1f});
 
        SLANG_NO_THROW virtual void* SLANG_MCALL clone(const SlangUUID& guid) = 0;
    };
 
    struct ISlangBlob : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(
            0x8BA5FB08,
            0x5195,
            0x40e2,
            {0xAC, 0x58, 0x0D, 0x98, 0x9C, 0x3A, 0x01, 0x02})
 
        virtual SLANG_NO_THROW void const* SLANG_MCALL getBufferPointer() = 0;
        virtual SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() = 0;
    };
#define SLANG_UUID_ISlangBlob ISlangBlob::getTypeGuid()
 
    /* Can be requested from ISlangCastable cast to indicate the contained chars are null
     * terminated.
     */
    struct SlangTerminatedChars
    {
        SLANG_CLASS_GUID(
            0xbe0db1a8,
            0x3594,
            0x4603,
            {0xa7, 0x8b, 0xc4, 0x86, 0x84, 0x30, 0xdf, 0xbb});
        operator const char*() const { return chars; }
        char chars[1];
    };
 
    struct ISlangFileSystem : public ISlangCastable
    {
        SLANG_COM_INTERFACE(
            0x003A09FC,
            0x3A4D,
            0x4BA0,
            {0xAD, 0x60, 0x1F, 0xD8, 0x63, 0xA9, 0x15, 0xAB})
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
        loadFile(char const* path, ISlangBlob** outBlob) = 0;
    };
#define SLANG_UUID_ISlangFileSystem ISlangFileSystem::getTypeGuid()
 
 
    typedef void (*SlangFuncPtr)(void);
 
    struct ISlangSharedLibrary_Dep1 : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(
            0x9c9d5bc5,
            0xeb61,
            0x496f,
            {0x80, 0xd7, 0xd1, 0x47, 0xc4, 0xa2, 0x37, 0x30})
 
        virtual SLANG_NO_THROW void* SLANG_MCALL findSymbolAddressByName(char const* name) = 0;
    };
#define SLANG_UUID_ISlangSharedLibrary_Dep1 ISlangSharedLibrary_Dep1::getTypeGuid()
 
    struct ISlangSharedLibrary : public ISlangCastable
    {
        SLANG_COM_INTERFACE(
            0x70dbc7c4,
            0xdc3b,
            0x4a07,
            {0xae, 0x7e, 0x75, 0x2a, 0xf6, 0xa8, 0x15, 0x55})
 
        SLANG_FORCE_INLINE SlangFuncPtr findFuncByName(char const* name)
        {
            return (SlangFuncPtr)findSymbolAddressByName(name);
        }
 
        virtual SLANG_NO_THROW void* SLANG_MCALL findSymbolAddressByName(char const* name) = 0;
    };
#define SLANG_UUID_ISlangSharedLibrary ISlangSharedLibrary::getTypeGuid()
 
    struct ISlangSharedLibraryLoader : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(
            0x6264ab2b,
            0xa3e8,
            0x4a06,
            {0x97, 0xf1, 0x49, 0xbc, 0x2d, 0x2a, 0xb1, 0x4d})
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
        loadSharedLibrary(const char* path, ISlangSharedLibrary** sharedLibraryOut) = 0;
    };
#define SLANG_UUID_ISlangSharedLibraryLoader ISlangSharedLibraryLoader::getTypeGuid()
 
    /* Type that identifies how a path should be interpreted */
    typedef unsigned int SlangPathTypeIntegral;
    enum SlangPathType : SlangPathTypeIntegral
    {
        SLANG_PATH_TYPE_DIRECTORY = 0, 
        SLANG_PATH_TYPE_FILE = 1,      
    };
 
    /* Callback to enumerate the contents of of a directory in a ISlangFileSystemExt.
    The name is the name of a file system object (directory/file) in the specified path (ie it is
    without a path) */
    typedef void (
        *FileSystemContentsCallBack)(SlangPathType pathType, const char* name, void* userData);
 
    /* Determines how paths map to files on the OS file system */
    enum class OSPathKind : uint8_t
    {
        None = 0,            
        Direct = 1,          
        OperatingSystem = 2, 
    };
 
    /* Used to determine what kind of path is required from an input path */
    enum class PathKind
    {
        Simplified = 0,
 
        Canonical = 1,
 
        Display = 2,
 
        OperatingSystem = 3,
 
        CountOf,
    };
 
    struct ISlangFileSystemExt : public ISlangFileSystem
    {
        SLANG_COM_INTERFACE(
            0x5fb632d2,
            0x979d,
            0x4481,
            {0x9f, 0xee, 0x66, 0x3c, 0x3f, 0x14, 0x49, 0xe1})
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
        getFileUniqueIdentity(const char* path, ISlangBlob** outUniqueIdentity) = 0;
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL calcCombinedPath(
            SlangPathType fromPathType,
            const char* fromPath,
            const char* path,
            ISlangBlob** pathOut) = 0;
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
        getPathType(const char* path, SlangPathType* pathTypeOut) = 0;
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
        getPath(PathKind kind, const char* path, ISlangBlob** outPath) = 0;
 
        virtual SLANG_NO_THROW void SLANG_MCALL clearCache() = 0;
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL enumeratePathContents(
            const char* path,
            FileSystemContentsCallBack callback,
            void* userData) = 0;
 
        virtual SLANG_NO_THROW OSPathKind SLANG_MCALL getOSPathKind() = 0;
    };
 
#define SLANG_UUID_ISlangFileSystemExt ISlangFileSystemExt::getTypeGuid()
 
    struct ISlangMutableFileSystem : public ISlangFileSystemExt
    {
        SLANG_COM_INTERFACE(
            0xa058675c,
            0x1d65,
            0x452a,
            {0x84, 0x58, 0xcc, 0xde, 0xd1, 0x42, 0x71, 0x5})
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
        saveFile(const char* path, const void* data, size_t size) = 0;
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
        saveFileBlob(const char* path, ISlangBlob* dataBlob) = 0;
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL remove(const char* path) = 0;
 
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createDirectory(const char* path) = 0;
    };
 
#define SLANG_UUID_ISlangMutableFileSystem ISlangMutableFileSystem::getTypeGuid()
 
    /* Identifies different types of writer target*/
    typedef unsigned int SlangWriterChannelIntegral;
    enum SlangWriterChannel : SlangWriterChannelIntegral
    {
        SLANG_WRITER_CHANNEL_DIAGNOSTIC = 0,
        SLANG_WRITER_CHANNEL_STD_OUTPUT = 1,
        SLANG_WRITER_CHANNEL_STD_ERROR = 2,
        SLANG_WRITER_CHANNEL_COUNT_OF,
    };
 
    typedef unsigned int SlangWriterModeIntegral;
    enum SlangWriterMode : SlangWriterModeIntegral
    {
        SLANG_WRITER_MODE_TEXT = 0,
        SLANG_WRITER_MODE_BINARY = 1,
    };
 
    struct ISlangWriter : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(
            0xec457f0e,
            0x9add,
            0x4e6b,
            {0x85, 0x1c, 0xd7, 0xfa, 0x71, 0x6d, 0x15, 0xfd})
 
        virtual SLANG_NO_THROW char* SLANG_MCALL beginAppendBuffer(size_t maxNumChars) = 0;
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
        endAppendBuffer(char* buffer, size_t numChars) = 0;
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
        write(const char* chars, size_t numChars) = 0;
        virtual SLANG_NO_THROW void SLANG_MCALL flush() = 0;
        virtual SLANG_NO_THROW SlangBool SLANG_MCALL isConsole() = 0;
        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setMode(SlangWriterMode mode) = 0;
    };
 
#define SLANG_UUID_ISlangWriter ISlangWriter::getTypeGuid()
 
    struct ISlangProfiler : public ISlangUnknown
    {
        SLANG_COM_INTERFACE(
            0x197772c7,
            0x0155,
            0x4b91,
            {0x84, 0xe8, 0x66, 0x68, 0xba, 0xff, 0x06, 0x19})
        virtual SLANG_NO_THROW size_t SLANG_MCALL getEntryCount() = 0;
        virtual SLANG_NO_THROW const char* SLANG_MCALL getEntryName(uint32_t index) = 0;
        virtual SLANG_NO_THROW long SLANG_MCALL getEntryTimeMS(uint32_t index) = 0;
        virtual SLANG_NO_THROW uint32_t SLANG_MCALL getEntryInvocationTimes(uint32_t index) = 0;
    };
#define SLANG_UUID_ISlangProfiler ISlangProfiler::getTypeGuid()
 
    namespace slang
    {
    struct IGlobalSession;
    struct ICompileRequest;
 
    } // namespace slang
 
    typedef slang::IGlobalSession SlangSession;
 
 
    typedef struct SlangProgramLayout SlangProgramLayout;
 
    typedef struct slang::ICompileRequest SlangCompileRequest;
 
 
    typedef void (*SlangDiagnosticCallback)(char const* message, void* userData);
 
    SLANG_API const char* spGetBuildTagString();
 
    /*
    Forward declarations of types used in the reflection interface;
    */
 
    typedef struct SlangProgramLayout SlangProgramLayout;
    typedef struct SlangEntryPoint SlangEntryPoint;
    typedef struct SlangEntryPointLayout SlangEntryPointLayout;
 
    typedef struct SlangReflectionDecl SlangReflectionDecl;
    typedef struct SlangReflectionModifier SlangReflectionModifier;
    typedef struct SlangReflectionType SlangReflectionType;
    typedef struct SlangReflectionTypeLayout SlangReflectionTypeLayout;
    typedef struct SlangReflectionVariable SlangReflectionVariable;
    typedef struct SlangReflectionVariableLayout SlangReflectionVariableLayout;
    typedef struct SlangReflectionTypeParameter SlangReflectionTypeParameter;
    typedef struct SlangReflectionUserAttribute SlangReflectionUserAttribute;
    typedef SlangReflectionUserAttribute SlangReflectionAttribute;
    typedef struct SlangReflectionFunction SlangReflectionFunction;
    typedef struct SlangReflectionGeneric SlangReflectionGeneric;
 
    union SlangReflectionGenericArg
    {
        SlangReflectionType* typeVal;
        int64_t intVal;
        bool boolVal;
    };
 
    enum SlangReflectionGenericArgType
    {
        SLANG_GENERIC_ARG_TYPE = 0,
        SLANG_GENERIC_ARG_INT = 1,
        SLANG_GENERIC_ARG_BOOL = 2
    };
 
    /*
    Type aliases to maintain backward compatibility.
    */
    typedef SlangProgramLayout SlangReflection;
    typedef SlangEntryPointLayout SlangReflectionEntryPoint;
 
    // type reflection
 
    typedef unsigned int SlangTypeKindIntegral;
    enum SlangTypeKind : SlangTypeKindIntegral
    {
        SLANG_TYPE_KIND_NONE = 0,
        SLANG_TYPE_KIND_STRUCT = 1,
        SLANG_TYPE_KIND_ARRAY = 2,
        SLANG_TYPE_KIND_MATRIX = 3,
        SLANG_TYPE_KIND_VECTOR = 4,
        SLANG_TYPE_KIND_SCALAR = 5,
        SLANG_TYPE_KIND_CONSTANT_BUFFER = 6,
        SLANG_TYPE_KIND_RESOURCE = 7,
        SLANG_TYPE_KIND_SAMPLER_STATE = 8,
        SLANG_TYPE_KIND_TEXTURE_BUFFER = 9,
        SLANG_TYPE_KIND_SHADER_STORAGE_BUFFER = 10,
        SLANG_TYPE_KIND_PARAMETER_BLOCK = 11,
        SLANG_TYPE_KIND_GENERIC_TYPE_PARAMETER = 12,
        SLANG_TYPE_KIND_INTERFACE = 13,
        SLANG_TYPE_KIND_OUTPUT_STREAM = 14,
        SLANG_TYPE_KIND_MESH_OUTPUT = 15,
        SLANG_TYPE_KIND_SPECIALIZED = 16,
        SLANG_TYPE_KIND_FEEDBACK = 17,
        SLANG_TYPE_KIND_POINTER = 18,
        SLANG_TYPE_KIND_DYNAMIC_RESOURCE = 19,
        SLANG_TYPE_KIND_ENUM = 20,
        SLANG_TYPE_KIND_COUNT,
    };
 
    typedef unsigned int SlangScalarTypeIntegral;
    enum SlangScalarType : SlangScalarTypeIntegral
    {
        SLANG_SCALAR_TYPE_NONE = 0,
        SLANG_SCALAR_TYPE_VOID = 1,
        SLANG_SCALAR_TYPE_BOOL = 2,
        SLANG_SCALAR_TYPE_INT32 = 3,
        SLANG_SCALAR_TYPE_UINT32 = 4,
        SLANG_SCALAR_TYPE_INT64 = 5,
        SLANG_SCALAR_TYPE_UINT64 = 6,
        SLANG_SCALAR_TYPE_FLOAT16 = 7,
        SLANG_SCALAR_TYPE_FLOAT32 = 8,
        SLANG_SCALAR_TYPE_FLOAT64 = 9,
        SLANG_SCALAR_TYPE_INT8 = 10,
        SLANG_SCALAR_TYPE_UINT8 = 11,
        SLANG_SCALAR_TYPE_INT16 = 12,
        SLANG_SCALAR_TYPE_UINT16 = 13,
        SLANG_SCALAR_TYPE_INTPTR = 14,
        SLANG_SCALAR_TYPE_UINTPTR = 15,
        SLANG_SCALAR_TYPE_BFLOAT16 = 16,
        SLANG_SCALAR_TYPE_FLOAT_E4M3 = 17,
        SLANG_SCALAR_TYPE_FLOAT_E5M2 = 18,
    };
 
    // abstract decl reflection
    typedef unsigned int SlangDeclKindIntegral;
    enum SlangDeclKind : SlangDeclKindIntegral
    {
        SLANG_DECL_KIND_UNSUPPORTED_FOR_REFLECTION = 0,
        SLANG_DECL_KIND_STRUCT = 1,
        SLANG_DECL_KIND_FUNC = 2,
        SLANG_DECL_KIND_MODULE = 3,
        SLANG_DECL_KIND_GENERIC = 4,
        SLANG_DECL_KIND_VARIABLE = 5,
        SLANG_DECL_KIND_NAMESPACE = 6,
        SLANG_DECL_KIND_ENUM = 7,
    };
 
#ifndef SLANG_RESOURCE_SHAPE
    #define SLANG_RESOURCE_SHAPE
    typedef unsigned int SlangResourceShapeIntegral;
    enum SlangResourceShape : SlangResourceShapeIntegral
    {
        SLANG_RESOURCE_BASE_SHAPE_MASK = 0x0F,
 
        SLANG_RESOURCE_NONE = 0x00,
 
        SLANG_TEXTURE_1D = 0x01,
        SLANG_TEXTURE_2D = 0x02,
        SLANG_TEXTURE_3D = 0x03,
        SLANG_TEXTURE_CUBE = 0x04,
        SLANG_TEXTURE_BUFFER = 0x05,
 
        SLANG_STRUCTURED_BUFFER = 0x06,
        SLANG_BYTE_ADDRESS_BUFFER = 0x07,
        SLANG_RESOURCE_UNKNOWN = 0x08,
        SLANG_ACCELERATION_STRUCTURE = 0x09,
        SLANG_TEXTURE_SUBPASS = 0x0A,
 
        SLANG_RESOURCE_EXT_SHAPE_MASK = 0x1F0,
 
        SLANG_TEXTURE_FEEDBACK_FLAG = 0x10,
        SLANG_TEXTURE_SHADOW_FLAG = 0x20,
        SLANG_TEXTURE_ARRAY_FLAG = 0x40,
        SLANG_TEXTURE_MULTISAMPLE_FLAG = 0x80,
        SLANG_TEXTURE_COMBINED_FLAG = 0x100,
 
        SLANG_TEXTURE_1D_ARRAY = SLANG_TEXTURE_1D | SLANG_TEXTURE_ARRAY_FLAG,
        SLANG_TEXTURE_2D_ARRAY = SLANG_TEXTURE_2D | SLANG_TEXTURE_ARRAY_FLAG,
        SLANG_TEXTURE_CUBE_ARRAY = SLANG_TEXTURE_CUBE | SLANG_TEXTURE_ARRAY_FLAG,
 
        SLANG_TEXTURE_2D_MULTISAMPLE = SLANG_TEXTURE_2D | SLANG_TEXTURE_MULTISAMPLE_FLAG,
        SLANG_TEXTURE_2D_MULTISAMPLE_ARRAY =
            SLANG_TEXTURE_2D | SLANG_TEXTURE_MULTISAMPLE_FLAG | SLANG_TEXTURE_ARRAY_FLAG,
        SLANG_TEXTURE_SUBPASS_MULTISAMPLE = SLANG_TEXTURE_SUBPASS | SLANG_TEXTURE_MULTISAMPLE_FLAG,
    };
#endif
    typedef unsigned int SlangResourceAccessIntegral;
    enum SlangResourceAccess : SlangResourceAccessIntegral
    {
        SLANG_RESOURCE_ACCESS_NONE = 0,
        SLANG_RESOURCE_ACCESS_READ = 1,
        SLANG_RESOURCE_ACCESS_READ_WRITE = 2,
        SLANG_RESOURCE_ACCESS_RASTER_ORDERED = 3,
        SLANG_RESOURCE_ACCESS_APPEND = 4,
        SLANG_RESOURCE_ACCESS_CONSUME = 5,
        SLANG_RESOURCE_ACCESS_WRITE = 6,
        SLANG_RESOURCE_ACCESS_FEEDBACK = 7,
        SLANG_RESOURCE_ACCESS_UNKNOWN = 0x7FFFFFFF,
    };
 
    typedef unsigned int SlangParameterCategoryIntegral;
    enum SlangParameterCategory : SlangParameterCategoryIntegral
    {
        SLANG_PARAMETER_CATEGORY_NONE = 0,
        SLANG_PARAMETER_CATEGORY_MIXED = 1,
        SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER = 2,
        SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE = 3,
        SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS = 4,
        SLANG_PARAMETER_CATEGORY_VARYING_INPUT = 5,
        SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT = 6,
        SLANG_PARAMETER_CATEGORY_SAMPLER_STATE = 7,
        SLANG_PARAMETER_CATEGORY_UNIFORM = 8,
        SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT = 9,
        SLANG_PARAMETER_CATEGORY_SPECIALIZATION_CONSTANT = 10,
        SLANG_PARAMETER_CATEGORY_PUSH_CONSTANT_BUFFER = 11,
 
        // HLSL register `space`, Vulkan GLSL `set`
        SLANG_PARAMETER_CATEGORY_REGISTER_SPACE = 12,
 
        // TODO: Ellie, Both APIs treat mesh outputs as more or less varying output,
        // Does it deserve to be represented here??
 
        // A parameter whose type is to be specialized by a global generic type argument
        SLANG_PARAMETER_CATEGORY_GENERIC = 13,
 
        SLANG_PARAMETER_CATEGORY_RAY_PAYLOAD = 14,
        SLANG_PARAMETER_CATEGORY_HIT_ATTRIBUTES = 15,
        SLANG_PARAMETER_CATEGORY_CALLABLE_PAYLOAD = 16,
        SLANG_PARAMETER_CATEGORY_SHADER_RECORD = 17,
 
        // An existential type parameter represents a "hole" that
        // needs to be filled with a concrete type to enable
        // generation of specialized code.
        //
        // Consider this example:
        //
        //      struct MyParams
        //      {
        //          IMaterial material;
        //          ILight lights[3];
        //      };
        //
        // This `MyParams` type introduces two existential type parameters:
        // one for `material` and one for `lights`. Even though `lights`
        // is an array, it only introduces one type parameter, because
        // we need to have a *single* concrete type for all the array
        // elements to be able to generate specialized code.
        //
        SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM = 18,
 
        // An existential object parameter represents a value
        // that needs to be passed in to provide data for some
        // interface-type shader parameter.
        //
        // Consider this example:
        //
        //      struct MyParams
        //      {
        //          IMaterial material;
        //          ILight lights[3];
        //      };
        //
        // This `MyParams` type introduces four existential object parameters:
        // one for `material` and three for `lights` (one for each array
        // element). This is consistent with the number of interface-type
        // "objects" that are being passed through to the shader.
        //
        SLANG_PARAMETER_CATEGORY_EXISTENTIAL_OBJECT_PARAM = 19,
 
        // The register space offset for the sub-elements that occupies register spaces.
        SLANG_PARAMETER_CATEGORY_SUB_ELEMENT_REGISTER_SPACE = 20,
 
        // The input_attachment_index subpass occupancy tracker
        SLANG_PARAMETER_CATEGORY_SUBPASS = 21,
 
        // Metal tier-1 argument buffer element [[id]].
        SLANG_PARAMETER_CATEGORY_METAL_ARGUMENT_BUFFER_ELEMENT = 22,
 
        // Metal [[attribute]] inputs.
        SLANG_PARAMETER_CATEGORY_METAL_ATTRIBUTE = 23,
 
        // Metal [[payload]] inputs
        SLANG_PARAMETER_CATEGORY_METAL_PAYLOAD = 24,
 
        //
        SLANG_PARAMETER_CATEGORY_COUNT,
 
        // Aliases for Metal-specific categories.
        SLANG_PARAMETER_CATEGORY_METAL_BUFFER = SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
        SLANG_PARAMETER_CATEGORY_METAL_TEXTURE = SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE,
        SLANG_PARAMETER_CATEGORY_METAL_SAMPLER = SLANG_PARAMETER_CATEGORY_SAMPLER_STATE,
 
        // DEPRECATED:
        SLANG_PARAMETER_CATEGORY_VERTEX_INPUT = SLANG_PARAMETER_CATEGORY_VARYING_INPUT,
        SLANG_PARAMETER_CATEGORY_FRAGMENT_OUTPUT = SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT,
        SLANG_PARAMETER_CATEGORY_COUNT_V1 = SLANG_PARAMETER_CATEGORY_SUBPASS,
    };
 
    typedef SlangUInt32 SlangBindingTypeIntegral;
    enum SlangBindingType : SlangBindingTypeIntegral
    {
        SLANG_BINDING_TYPE_UNKNOWN = 0,
 
        SLANG_BINDING_TYPE_SAMPLER = 1,
        SLANG_BINDING_TYPE_TEXTURE = 2,
        SLANG_BINDING_TYPE_CONSTANT_BUFFER = 3,
        SLANG_BINDING_TYPE_PARAMETER_BLOCK = 4,
        SLANG_BINDING_TYPE_TYPED_BUFFER = 5,
        SLANG_BINDING_TYPE_RAW_BUFFER = 6,
        SLANG_BINDING_TYPE_COMBINED_TEXTURE_SAMPLER = 7,
        SLANG_BINDING_TYPE_INPUT_RENDER_TARGET = 8,
        SLANG_BINDING_TYPE_INLINE_UNIFORM_DATA = 9,
        SLANG_BINDING_TYPE_RAY_TRACING_ACCELERATION_STRUCTURE = 10,
 
        SLANG_BINDING_TYPE_VARYING_INPUT = 11,
        SLANG_BINDING_TYPE_VARYING_OUTPUT = 12,
 
        SLANG_BINDING_TYPE_EXISTENTIAL_VALUE = 13,
        SLANG_BINDING_TYPE_PUSH_CONSTANT = 14,
 
        SLANG_BINDING_TYPE_MUTABLE_FLAG = 0x100,
 
        SLANG_BINDING_TYPE_MUTABLE_TETURE =
            SLANG_BINDING_TYPE_TEXTURE | SLANG_BINDING_TYPE_MUTABLE_FLAG,
        SLANG_BINDING_TYPE_MUTABLE_TYPED_BUFFER =
            SLANG_BINDING_TYPE_TYPED_BUFFER | SLANG_BINDING_TYPE_MUTABLE_FLAG,
        SLANG_BINDING_TYPE_MUTABLE_RAW_BUFFER =
            SLANG_BINDING_TYPE_RAW_BUFFER | SLANG_BINDING_TYPE_MUTABLE_FLAG,
 
        SLANG_BINDING_TYPE_BASE_MASK = 0x00FF,
        SLANG_BINDING_TYPE_EXT_MASK = 0xFF00,
    };
 
    typedef SlangUInt32 SlangLayoutRulesIntegral;
    enum SlangLayoutRules : SlangLayoutRulesIntegral
    {
        SLANG_LAYOUT_RULES_DEFAULT = 0,
        SLANG_LAYOUT_RULES_METAL_ARGUMENT_BUFFER_TIER_2 = 1,
        SLANG_LAYOUT_RULES_DEFAULT_STRUCTURED_BUFFER = 2,
        SLANG_LAYOUT_RULES_DEFAULT_CONSTANT_BUFFER = 3,
    };
 
    typedef SlangUInt32 SlangModifierIDIntegral;
    enum SlangModifierID : SlangModifierIDIntegral
    {
        SLANG_MODIFIER_SHARED = 0,
        SLANG_MODIFIER_NO_DIFF = 1,
        SLANG_MODIFIER_STATIC = 2,
        SLANG_MODIFIER_CONST = 3,
        SLANG_MODIFIER_EXPORT = 4,
        SLANG_MODIFIER_EXTERN = 5,
        SLANG_MODIFIER_DIFFERENTIABLE = 6,
        SLANG_MODIFIER_MUTATING = 7,
        SLANG_MODIFIER_IN = 8,
        SLANG_MODIFIER_OUT = 9,
        SLANG_MODIFIER_INOUT = 10,
    };
 
    typedef SlangUInt32 SlangImageFormatIntegral;
    enum SlangImageFormat : SlangImageFormatIntegral
    {
#define SLANG_FORMAT(NAME, DESC) SLANG_IMAGE_FORMAT_##NAME,
#include "slang-image-format-defs.h"
#undef SLANG_FORMAT
    };
 
#define SLANG_UNBOUNDED_SIZE (~size_t(0))
#define SLANG_UNKNOWN_SIZE (SLANG_UNBOUNDED_SIZE - 1)
 
    // Shader Parameter Reflection
 
    typedef SlangReflectionVariableLayout SlangReflectionParameter;
 
#ifdef __cplusplus
}
#endif
 
#ifdef __cplusplus
namespace slang
{
struct ISession;
}
#endif
 
#include "slang-deprecated.h"
 
#ifdef __cplusplus
 
/* Helper interfaces for C++ users */
namespace slang
{
struct BufferReflection;
struct DeclReflection;
struct TypeLayoutReflection;
struct TypeReflection;
struct VariableLayoutReflection;
struct VariableReflection;
struct FunctionReflection;
struct GenericReflection;
 
union GenericArgReflection
{
    TypeReflection* typeVal;
    int64_t intVal;
    bool boolVal;
};
 
struct Attribute
{
    char const* getName()
    {
        return spReflectionUserAttribute_GetName((SlangReflectionAttribute*)this);
    }
    uint32_t getArgumentCount()
    {
        return (uint32_t)spReflectionUserAttribute_GetArgumentCount(
            (SlangReflectionAttribute*)this);
    }
    TypeReflection* getArgumentType(uint32_t index)
    {
        return (TypeReflection*)spReflectionUserAttribute_GetArgumentType(
            (SlangReflectionAttribute*)this,
            index);
    }
    SlangResult getArgumentValueInt(uint32_t index, int* value)
    {
        return spReflectionUserAttribute_GetArgumentValueInt(
            (SlangReflectionAttribute*)this,
            index,
            value);
    }
    SlangResult getArgumentValueFloat(uint32_t index, float* value)
    {
        return spReflectionUserAttribute_GetArgumentValueFloat(
            (SlangReflectionAttribute*)this,
            index,
            value);
    }
    const char* getArgumentValueString(uint32_t index, size_t* outSize)
    {
        return spReflectionUserAttribute_GetArgumentValueString(
            (SlangReflectionAttribute*)this,
            index,
            outSize);
    }
};
 
typedef Attribute UserAttribute;
 
struct TypeReflection
{
    enum class Kind
    {
        None = SLANG_TYPE_KIND_NONE,
        Struct = SLANG_TYPE_KIND_STRUCT,
        Array = SLANG_TYPE_KIND_ARRAY,
        Matrix = SLANG_TYPE_KIND_MATRIX,
        Vector = SLANG_TYPE_KIND_VECTOR,
        Scalar = SLANG_TYPE_KIND_SCALAR,
        ConstantBuffer = SLANG_TYPE_KIND_CONSTANT_BUFFER,
        Resource = SLANG_TYPE_KIND_RESOURCE,
        SamplerState = SLANG_TYPE_KIND_SAMPLER_STATE,
        TextureBuffer = SLANG_TYPE_KIND_TEXTURE_BUFFER,
        ShaderStorageBuffer = SLANG_TYPE_KIND_SHADER_STORAGE_BUFFER,
        ParameterBlock = SLANG_TYPE_KIND_PARAMETER_BLOCK,
        GenericTypeParameter = SLANG_TYPE_KIND_GENERIC_TYPE_PARAMETER,
        Interface = SLANG_TYPE_KIND_INTERFACE,
        OutputStream = SLANG_TYPE_KIND_OUTPUT_STREAM,
        Specialized = SLANG_TYPE_KIND_SPECIALIZED,
        Feedback = SLANG_TYPE_KIND_FEEDBACK,
        Pointer = SLANG_TYPE_KIND_POINTER,
        DynamicResource = SLANG_TYPE_KIND_DYNAMIC_RESOURCE,
        MeshOutput = SLANG_TYPE_KIND_MESH_OUTPUT,
        Enum = SLANG_TYPE_KIND_ENUM,
    };
 
    enum ScalarType : SlangScalarTypeIntegral
    {
        None = SLANG_SCALAR_TYPE_NONE,
        Void = SLANG_SCALAR_TYPE_VOID,
        Bool = SLANG_SCALAR_TYPE_BOOL,
        Int32 = SLANG_SCALAR_TYPE_INT32,
        UInt32 = SLANG_SCALAR_TYPE_UINT32,
        Int64 = SLANG_SCALAR_TYPE_INT64,
        UInt64 = SLANG_SCALAR_TYPE_UINT64,
        Float16 = SLANG_SCALAR_TYPE_FLOAT16,
        Float32 = SLANG_SCALAR_TYPE_FLOAT32,
        Float64 = SLANG_SCALAR_TYPE_FLOAT64,
        Int8 = SLANG_SCALAR_TYPE_INT8,
        UInt8 = SLANG_SCALAR_TYPE_UINT8,
        Int16 = SLANG_SCALAR_TYPE_INT16,
        UInt16 = SLANG_SCALAR_TYPE_UINT16,
        IntPtr = SLANG_SCALAR_TYPE_INTPTR,
        UIntPtr = SLANG_SCALAR_TYPE_UINTPTR,
        BFloat16 = SLANG_SCALAR_TYPE_BFLOAT16,
        FloatE4M3 = SLANG_SCALAR_TYPE_FLOAT_E4M3,
        FloatE5M2 = SLANG_SCALAR_TYPE_FLOAT_E5M2,
    };
 
    Kind getKind() { return (Kind)spReflectionType_GetKind((SlangReflectionType*)this); }
 
    // only useful if `getKind() == Kind::Struct`
    unsigned int getFieldCount()
    {
        return spReflectionType_GetFieldCount((SlangReflectionType*)this);
    }
 
    VariableReflection* getFieldByIndex(unsigned int index)
    {
        return (
            VariableReflection*)spReflectionType_GetFieldByIndex((SlangReflectionType*)this, index);
    }
 
    bool isArray() { return getKind() == TypeReflection::Kind::Array; }
 
    TypeReflection* unwrapArray()
    {
        TypeReflection* type = this;
        while (type->isArray())
        {
            type = type->getElementType();
        }
        return type;
    }
 
    size_t getElementCount(SlangReflection* reflection = nullptr)
    {
        return spReflectionType_GetSpecializedElementCount((SlangReflectionType*)this, reflection);
    }
 
    size_t getTotalArrayElementCount()
    {
        if (!isArray())
            return 0;
        size_t result = 1;
        TypeReflection* type = this;
        for (;;)
        {
            if (!type->isArray())
                return result;
 
            const auto c = type->getElementCount();
            if (c == SLANG_UNKNOWN_SIZE)
                return SLANG_UNKNOWN_SIZE;
            if (c == SLANG_UNBOUNDED_SIZE)
                return SLANG_UNBOUNDED_SIZE;
            result *= c;
            type = type->getElementType();
        }
    }
 
    TypeReflection* getElementType()
    {
        return (TypeReflection*)spReflectionType_GetElementType((SlangReflectionType*)this);
    }
 
    unsigned getRowCount() { return spReflectionType_GetRowCount((SlangReflectionType*)this); }
 
    unsigned getColumnCount()
    {
        return spReflectionType_GetColumnCount((SlangReflectionType*)this);
    }
 
    ScalarType getScalarType()
    {
        return (ScalarType)spReflectionType_GetScalarType((SlangReflectionType*)this);
    }
 
    TypeReflection* getResourceResultType()
    {
        return (TypeReflection*)spReflectionType_GetResourceResultType((SlangReflectionType*)this);
    }
 
    SlangResourceShape getResourceShape()
    {
        return spReflectionType_GetResourceShape((SlangReflectionType*)this);
    }
 
    SlangResourceAccess getResourceAccess()
    {
        return spReflectionType_GetResourceAccess((SlangReflectionType*)this);
    }
 
    char const* getName() { return spReflectionType_GetName((SlangReflectionType*)this); }
 
    SlangResult getFullName(ISlangBlob** outNameBlob)
    {
        return spReflectionType_GetFullName((SlangReflectionType*)this, outNameBlob);
    }
 
    unsigned int getUserAttributeCount()
    {
        return spReflectionType_GetUserAttributeCount((SlangReflectionType*)this);
    }
 
    UserAttribute* getUserAttributeByIndex(unsigned int index)
    {
        return (UserAttribute*)spReflectionType_GetUserAttribute((SlangReflectionType*)this, index);
    }
 
    UserAttribute* findAttributeByName(char const* name)
    {
        return (UserAttribute*)spReflectionType_FindUserAttributeByName(
            (SlangReflectionType*)this,
            name);
    }
 
    UserAttribute* findUserAttributeByName(char const* name) { return findAttributeByName(name); }
 
    TypeReflection* applySpecializations(GenericReflection* generic)
    {
        return (TypeReflection*)spReflectionType_applySpecializations(
            (SlangReflectionType*)this,
            (SlangReflectionGeneric*)generic);
    }
 
    GenericReflection* getGenericContainer()
    {
        return (GenericReflection*)spReflectionType_GetGenericContainer((SlangReflectionType*)this);
    }
};
 
enum ParameterCategory : SlangParameterCategoryIntegral
{
    // TODO: these aren't scoped...
    None = SLANG_PARAMETER_CATEGORY_NONE,
    Mixed = SLANG_PARAMETER_CATEGORY_MIXED,
    ConstantBuffer = SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
    ShaderResource = SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE,
    UnorderedAccess = SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS,
    VaryingInput = SLANG_PARAMETER_CATEGORY_VARYING_INPUT,
    VaryingOutput = SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT,
    SamplerState = SLANG_PARAMETER_CATEGORY_SAMPLER_STATE,
    Uniform = SLANG_PARAMETER_CATEGORY_UNIFORM,
    DescriptorTableSlot = SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT,
    SpecializationConstant = SLANG_PARAMETER_CATEGORY_SPECIALIZATION_CONSTANT,
    PushConstantBuffer = SLANG_PARAMETER_CATEGORY_PUSH_CONSTANT_BUFFER,
    RegisterSpace = SLANG_PARAMETER_CATEGORY_REGISTER_SPACE,
    GenericResource = SLANG_PARAMETER_CATEGORY_GENERIC,
 
    RayPayload = SLANG_PARAMETER_CATEGORY_RAY_PAYLOAD,
    HitAttributes = SLANG_PARAMETER_CATEGORY_HIT_ATTRIBUTES,
    CallablePayload = SLANG_PARAMETER_CATEGORY_CALLABLE_PAYLOAD,
 
    ShaderRecord = SLANG_PARAMETER_CATEGORY_SHADER_RECORD,
 
    ExistentialTypeParam = SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM,
    ExistentialObjectParam = SLANG_PARAMETER_CATEGORY_EXISTENTIAL_OBJECT_PARAM,
 
    SubElementRegisterSpace = SLANG_PARAMETER_CATEGORY_SUB_ELEMENT_REGISTER_SPACE,
 
    InputAttachmentIndex = SLANG_PARAMETER_CATEGORY_SUBPASS,
 
    MetalBuffer = SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
    MetalTexture = SLANG_PARAMETER_CATEGORY_METAL_TEXTURE,
    MetalArgumentBufferElement = SLANG_PARAMETER_CATEGORY_METAL_ARGUMENT_BUFFER_ELEMENT,
    MetalAttribute = SLANG_PARAMETER_CATEGORY_METAL_ATTRIBUTE,
    MetalPayload = SLANG_PARAMETER_CATEGORY_METAL_PAYLOAD,
 
    // DEPRECATED:
    VertexInput = SLANG_PARAMETER_CATEGORY_VERTEX_INPUT,
    FragmentOutput = SLANG_PARAMETER_CATEGORY_FRAGMENT_OUTPUT,
};
 
enum class BindingType : SlangBindingTypeIntegral
{
    Unknown = SLANG_BINDING_TYPE_UNKNOWN,
 
    Sampler = SLANG_BINDING_TYPE_SAMPLER,
    Texture = SLANG_BINDING_TYPE_TEXTURE,
    ConstantBuffer = SLANG_BINDING_TYPE_CONSTANT_BUFFER,
    ParameterBlock = SLANG_BINDING_TYPE_PARAMETER_BLOCK,
    TypedBuffer = SLANG_BINDING_TYPE_TYPED_BUFFER,
    RawBuffer = SLANG_BINDING_TYPE_RAW_BUFFER,
    CombinedTextureSampler = SLANG_BINDING_TYPE_COMBINED_TEXTURE_SAMPLER,
    InputRenderTarget = SLANG_BINDING_TYPE_INPUT_RENDER_TARGET,
    InlineUniformData = SLANG_BINDING_TYPE_INLINE_UNIFORM_DATA,
    RayTracingAccelerationStructure = SLANG_BINDING_TYPE_RAY_TRACING_ACCELERATION_STRUCTURE,
    VaryingInput = SLANG_BINDING_TYPE_VARYING_INPUT,
    VaryingOutput = SLANG_BINDING_TYPE_VARYING_OUTPUT,
    ExistentialValue = SLANG_BINDING_TYPE_EXISTENTIAL_VALUE,
    PushConstant = SLANG_BINDING_TYPE_PUSH_CONSTANT,
 
    MutableFlag = SLANG_BINDING_TYPE_MUTABLE_FLAG,
 
    MutableTexture = SLANG_BINDING_TYPE_MUTABLE_TETURE,
    MutableTypedBuffer = SLANG_BINDING_TYPE_MUTABLE_TYPED_BUFFER,
    MutableRawBuffer = SLANG_BINDING_TYPE_MUTABLE_RAW_BUFFER,
 
    BaseMask = SLANG_BINDING_TYPE_BASE_MASK,
    ExtMask = SLANG_BINDING_TYPE_EXT_MASK,
};
 
struct ShaderReflection;
 
struct TypeLayoutReflection
{
    TypeReflection* getType()
    {
        return (TypeReflection*)spReflectionTypeLayout_GetType((SlangReflectionTypeLayout*)this);
    }
 
    TypeReflection::Kind getKind()
    {
        return (TypeReflection::Kind)spReflectionTypeLayout_getKind(
            (SlangReflectionTypeLayout*)this);
    }
 
    size_t getSize(SlangParameterCategory category)
    {
        return spReflectionTypeLayout_GetSize((SlangReflectionTypeLayout*)this, category);
    }
 
    size_t getStride(SlangParameterCategory category)
    {
        return spReflectionTypeLayout_GetStride((SlangReflectionTypeLayout*)this, category);
    }
 
    int32_t getAlignment(SlangParameterCategory category)
    {
        return spReflectionTypeLayout_getAlignment((SlangReflectionTypeLayout*)this, category);
    }
 
    size_t getSize(slang::ParameterCategory category = slang::ParameterCategory::Uniform)
    {
        return spReflectionTypeLayout_GetSize(
            (SlangReflectionTypeLayout*)this,
            (SlangParameterCategory)category);
    }
 
    size_t getStride(slang::ParameterCategory category = slang::ParameterCategory::Uniform)
    {
        return spReflectionTypeLayout_GetStride(
            (SlangReflectionTypeLayout*)this,
            (SlangParameterCategory)category);
    }
 
    int32_t getAlignment(slang::ParameterCategory category = slang::ParameterCategory::Uniform)
    {
        return spReflectionTypeLayout_getAlignment(
            (SlangReflectionTypeLayout*)this,
            (SlangParameterCategory)category);
    }
 
 
    unsigned int getFieldCount()
    {
        return spReflectionTypeLayout_GetFieldCount((SlangReflectionTypeLayout*)this);
    }
 
    VariableLayoutReflection* getFieldByIndex(unsigned int index)
    {
        return (VariableLayoutReflection*)spReflectionTypeLayout_GetFieldByIndex(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    SlangInt findFieldIndexByName(char const* nameBegin, char const* nameEnd = nullptr)
    {
        return spReflectionTypeLayout_findFieldIndexByName(
            (SlangReflectionTypeLayout*)this,
            nameBegin,
            nameEnd);
    }
 
    VariableLayoutReflection* getExplicitCounter()
    {
        return (VariableLayoutReflection*)spReflectionTypeLayout_GetExplicitCounter(
            (SlangReflectionTypeLayout*)this);
    }
 
    bool isArray() { return getType()->isArray(); }
 
    TypeLayoutReflection* unwrapArray()
    {
        TypeLayoutReflection* typeLayout = this;
        while (typeLayout->isArray())
        {
            typeLayout = typeLayout->getElementTypeLayout();
        }
        return typeLayout;
    }
 
    size_t getElementCount(ShaderReflection* reflection = nullptr)
    {
        return getType()->getElementCount((SlangReflection*)reflection);
    }
 
    size_t getTotalArrayElementCount() { return getType()->getTotalArrayElementCount(); }
 
    size_t getElementStride(SlangParameterCategory category)
    {
        return spReflectionTypeLayout_GetElementStride((SlangReflectionTypeLayout*)this, category);
    }
 
    TypeLayoutReflection* getElementTypeLayout()
    {
        return (TypeLayoutReflection*)spReflectionTypeLayout_GetElementTypeLayout(
            (SlangReflectionTypeLayout*)this);
    }
 
    VariableLayoutReflection* getElementVarLayout()
    {
        return (VariableLayoutReflection*)spReflectionTypeLayout_GetElementVarLayout(
            (SlangReflectionTypeLayout*)this);
    }
 
    VariableLayoutReflection* getContainerVarLayout()
    {
        return (VariableLayoutReflection*)spReflectionTypeLayout_getContainerVarLayout(
            (SlangReflectionTypeLayout*)this);
    }
 
    // How is this type supposed to be bound?
    ParameterCategory getParameterCategory()
    {
        return (ParameterCategory)spReflectionTypeLayout_GetParameterCategory(
            (SlangReflectionTypeLayout*)this);
    }
 
    unsigned int getCategoryCount()
    {
        return spReflectionTypeLayout_GetCategoryCount((SlangReflectionTypeLayout*)this);
    }
 
    ParameterCategory getCategoryByIndex(unsigned int index)
    {
        return (ParameterCategory)spReflectionTypeLayout_GetCategoryByIndex(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    unsigned getRowCount() { return getType()->getRowCount(); }
 
    unsigned getColumnCount() { return getType()->getColumnCount(); }
 
    TypeReflection::ScalarType getScalarType() { return getType()->getScalarType(); }
 
    TypeReflection* getResourceResultType() { return getType()->getResourceResultType(); }
 
    SlangResourceShape getResourceShape() { return getType()->getResourceShape(); }
 
    SlangResourceAccess getResourceAccess() { return getType()->getResourceAccess(); }
 
    char const* getName() { return getType()->getName(); }
 
    SlangMatrixLayoutMode getMatrixLayoutMode()
    {
        return spReflectionTypeLayout_GetMatrixLayoutMode((SlangReflectionTypeLayout*)this);
    }
 
    int getGenericParamIndex()
    {
        return spReflectionTypeLayout_getGenericParamIndex((SlangReflectionTypeLayout*)this);
    }
 
    // Pending Type Layout functionality has been removed
    [[deprecated]] TypeLayoutReflection* getPendingDataTypeLayout() { return nullptr; }
 
    // Pending Type Layout functionality has been removed
    [[deprecated]] VariableLayoutReflection* getSpecializedTypePendingDataVarLayout()
    {
        return nullptr;
    }
 
    SlangInt getBindingRangeCount()
    {
        return spReflectionTypeLayout_getBindingRangeCount((SlangReflectionTypeLayout*)this);
    }
 
    BindingType getBindingRangeType(SlangInt index)
    {
        return (BindingType)spReflectionTypeLayout_getBindingRangeType(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    bool isBindingRangeSpecializable(SlangInt index)
    {
        return (bool)spReflectionTypeLayout_isBindingRangeSpecializable(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    SlangInt getBindingRangeBindingCount(SlangInt index)
    {
        return spReflectionTypeLayout_getBindingRangeBindingCount(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    /*
    SlangInt getBindingRangeIndexOffset(SlangInt index)
    {
        return spReflectionTypeLayout_getBindingRangeIndexOffset(
            (SlangReflectionTypeLayout*) this,
            index);
    }
 
    SlangInt getBindingRangeSpaceOffset(SlangInt index)
    {
        return spReflectionTypeLayout_getBindingRangeSpaceOffset(
            (SlangReflectionTypeLayout*) this,
            index);
    }
    */
 
    SlangInt getFieldBindingRangeOffset(SlangInt fieldIndex)
    {
        return spReflectionTypeLayout_getFieldBindingRangeOffset(
            (SlangReflectionTypeLayout*)this,
            fieldIndex);
    }
 
    SlangInt getExplicitCounterBindingRangeOffset()
    {
        return spReflectionTypeLayout_getExplicitCounterBindingRangeOffset(
            (SlangReflectionTypeLayout*)this);
    }
 
    TypeLayoutReflection* getBindingRangeLeafTypeLayout(SlangInt index)
    {
        return (TypeLayoutReflection*)spReflectionTypeLayout_getBindingRangeLeafTypeLayout(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    VariableReflection* getBindingRangeLeafVariable(SlangInt index)
    {
        return (VariableReflection*)spReflectionTypeLayout_getBindingRangeLeafVariable(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    SlangImageFormat getBindingRangeImageFormat(SlangInt index)
    {
        return spReflectionTypeLayout_getBindingRangeImageFormat(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    SlangInt getBindingRangeDescriptorSetIndex(SlangInt index)
    {
        return spReflectionTypeLayout_getBindingRangeDescriptorSetIndex(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    SlangInt getBindingRangeFirstDescriptorRangeIndex(SlangInt index)
    {
        return spReflectionTypeLayout_getBindingRangeFirstDescriptorRangeIndex(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    SlangInt getBindingRangeDescriptorRangeCount(SlangInt index)
    {
        return spReflectionTypeLayout_getBindingRangeDescriptorRangeCount(
            (SlangReflectionTypeLayout*)this,
            index);
    }
 
    SlangInt getDescriptorSetCount()
    {
        return spReflectionTypeLayout_getDescriptorSetCount((SlangReflectionTypeLayout*)this);
    }
 
    SlangInt getDescriptorSetSpaceOffset(SlangInt setIndex)
    {
        return spReflectionTypeLayout_getDescriptorSetSpaceOffset(
            (SlangReflectionTypeLayout*)this,
            setIndex);
    }
 
    SlangInt getDescriptorSetDescriptorRangeCount(SlangInt setIndex)
    {
        return spReflectionTypeLayout_getDescriptorSetDescriptorRangeCount(
            (SlangReflectionTypeLayout*)this,
            setIndex);
    }
 
    SlangInt getDescriptorSetDescriptorRangeIndexOffset(SlangInt setIndex, SlangInt rangeIndex)
    {
        return spReflectionTypeLayout_getDescriptorSetDescriptorRangeIndexOffset(
            (SlangReflectionTypeLayout*)this,
            setIndex,
            rangeIndex);
    }
 
    SlangInt getDescriptorSetDescriptorRangeDescriptorCount(SlangInt setIndex, SlangInt rangeIndex)
    {
        return spReflectionTypeLayout_getDescriptorSetDescriptorRangeDescriptorCount(
            (SlangReflectionTypeLayout*)this,
            setIndex,
            rangeIndex);
    }
 
    BindingType getDescriptorSetDescriptorRangeType(SlangInt setIndex, SlangInt rangeIndex)
    {
        return (BindingType)spReflectionTypeLayout_getDescriptorSetDescriptorRangeType(
            (SlangReflectionTypeLayout*)this,
            setIndex,
            rangeIndex);
    }
 
    ParameterCategory getDescriptorSetDescriptorRangeCategory(
        SlangInt setIndex,
        SlangInt rangeIndex)
    {
        return (ParameterCategory)spReflectionTypeLayout_getDescriptorSetDescriptorRangeCategory(
            (SlangReflectionTypeLayout*)this,
            setIndex,
            rangeIndex);
    }
 
    SlangInt getSubObjectRangeCount()
    {
        return spReflectionTypeLayout_getSubObjectRangeCount((SlangReflectionTypeLayout*)this);
    }
 
    SlangInt getSubObjectRangeBindingRangeIndex(SlangInt subObjectRangeIndex)
    {
        return spReflectionTypeLayout_getSubObjectRangeBindingRangeIndex(
            (SlangReflectionTypeLayout*)this,
            subObjectRangeIndex);
    }
 
    SlangInt getSubObjectRangeSpaceOffset(SlangInt subObjectRangeIndex)
    {
        return spReflectionTypeLayout_getSubObjectRangeSpaceOffset(
            (SlangReflectionTypeLayout*)this,
            subObjectRangeIndex);
    }
 
    VariableLayoutReflection* getSubObjectRangeOffset(SlangInt subObjectRangeIndex)
    {
        return (VariableLayoutReflection*)spReflectionTypeLayout_getSubObjectRangeOffset(
            (SlangReflectionTypeLayout*)this,
            subObjectRangeIndex);
    }
};
 
struct Modifier
{
    enum ID : SlangModifierIDIntegral
    {
        Shared = SLANG_MODIFIER_SHARED,
        NoDiff = SLANG_MODIFIER_NO_DIFF,
        Static = SLANG_MODIFIER_STATIC,
        Const = SLANG_MODIFIER_CONST,
        Export = SLANG_MODIFIER_EXPORT,
        Extern = SLANG_MODIFIER_EXTERN,
        Differentiable = SLANG_MODIFIER_DIFFERENTIABLE,
        Mutating = SLANG_MODIFIER_MUTATING,
        In = SLANG_MODIFIER_IN,
        Out = SLANG_MODIFIER_OUT,
        InOut = SLANG_MODIFIER_INOUT
    };
};
 
struct VariableReflection
{
    char const* getName() { return spReflectionVariable_GetName((SlangReflectionVariable*)this); }
 
    TypeReflection* getType()
    {
        return (TypeReflection*)spReflectionVariable_GetType((SlangReflectionVariable*)this);
    }
 
    Modifier* findModifier(Modifier::ID id)
    {
        return (Modifier*)spReflectionVariable_FindModifier(
            (SlangReflectionVariable*)this,
            (SlangModifierID)id);
    }
 
    unsigned int getUserAttributeCount()
    {
        return spReflectionVariable_GetUserAttributeCount((SlangReflectionVariable*)this);
    }
 
    Attribute* getUserAttributeByIndex(unsigned int index)
    {
        return (UserAttribute*)spReflectionVariable_GetUserAttribute(
            (SlangReflectionVariable*)this,
            index);
    }
 
    Attribute* findAttributeByName(SlangSession* globalSession, char const* name)
    {
        return (UserAttribute*)spReflectionVariable_FindUserAttributeByName(
            (SlangReflectionVariable*)this,
            globalSession,
            name);
    }
 
    Attribute* findUserAttributeByName(SlangSession* globalSession, char const* name)
    {
        return findAttributeByName(globalSession, name);
    }
 
    bool hasDefaultValue()
    {
        return spReflectionVariable_HasDefaultValue((SlangReflectionVariable*)this);
    }
 
    SlangResult getDefaultValueInt(int64_t* value)
    {
        return spReflectionVariable_GetDefaultValueInt((SlangReflectionVariable*)this, value);
    }
 
    SlangResult getDefaultValueFloat(float* value)
    {
        return spReflectionVariable_GetDefaultValueFloat((SlangReflectionVariable*)this, value);
    }
 
    GenericReflection* getGenericContainer()
    {
        return (GenericReflection*)spReflectionVariable_GetGenericContainer(
            (SlangReflectionVariable*)this);
    }
 
    VariableReflection* applySpecializations(GenericReflection* generic)
    {
        return (VariableReflection*)spReflectionVariable_applySpecializations(
            (SlangReflectionVariable*)this,
            (SlangReflectionGeneric*)generic);
    }
};
 
struct VariableLayoutReflection
{
    VariableReflection* getVariable()
    {
        return (VariableReflection*)spReflectionVariableLayout_GetVariable(
            (SlangReflectionVariableLayout*)this);
    }
 
    char const* getName()
    {
        if (auto var = getVariable())
            return var->getName();
        return nullptr;
    }
 
    Modifier* findModifier(Modifier::ID id) { return getVariable()->findModifier(id); }
 
    TypeLayoutReflection* getTypeLayout()
    {
        return (TypeLayoutReflection*)spReflectionVariableLayout_GetTypeLayout(
            (SlangReflectionVariableLayout*)this);
    }
 
    ParameterCategory getCategory() { return getTypeLayout()->getParameterCategory(); }
 
    unsigned int getCategoryCount() { return getTypeLayout()->getCategoryCount(); }
 
    ParameterCategory getCategoryByIndex(unsigned int index)
    {
        return getTypeLayout()->getCategoryByIndex(index);
    }
 
 
    size_t getOffset(SlangParameterCategory category)
    {
        return spReflectionVariableLayout_GetOffset((SlangReflectionVariableLayout*)this, category);
    }
 
    size_t getOffset(slang::ParameterCategory category = slang::ParameterCategory::Uniform)
    {
        return spReflectionVariableLayout_GetOffset(
            (SlangReflectionVariableLayout*)this,
            (SlangParameterCategory)category);
    }
 
 
    TypeReflection* getType() { return getVariable()->getType(); }
 
    unsigned getBindingIndex()
    {
        return spReflectionParameter_GetBindingIndex((SlangReflectionVariableLayout*)this);
    }
 
    unsigned getBindingSpace()
    {
        return spReflectionParameter_GetBindingSpace((SlangReflectionVariableLayout*)this);
    }
 
    size_t getBindingSpace(SlangParameterCategory category)
    {
        return spReflectionVariableLayout_GetSpace((SlangReflectionVariableLayout*)this, category);
    }
 
    size_t getBindingSpace(slang::ParameterCategory category)
    {
        return spReflectionVariableLayout_GetSpace(
            (SlangReflectionVariableLayout*)this,
            (SlangParameterCategory)category);
    }
 
    SlangImageFormat getImageFormat()
    {
        return spReflectionVariableLayout_GetImageFormat((SlangReflectionVariableLayout*)this);
    }
 
    char const* getSemanticName()
    {
        return spReflectionVariableLayout_GetSemanticName((SlangReflectionVariableLayout*)this);
    }
 
    size_t getSemanticIndex()
    {
        return spReflectionVariableLayout_GetSemanticIndex((SlangReflectionVariableLayout*)this);
    }
 
    SlangStage getStage()
    {
        return spReflectionVariableLayout_getStage((SlangReflectionVariableLayout*)this);
    }
 
    // Pending Type Layout functionality has been removed
    [[deprecated]] VariableLayoutReflection* getPendingDataLayout() { return nullptr; }
};
 
struct FunctionReflection
{
    char const* getName() { return spReflectionFunction_GetName((SlangReflectionFunction*)this); }
 
    TypeReflection* getReturnType()
    {
        return (TypeReflection*)spReflectionFunction_GetResultType((SlangReflectionFunction*)this);
    }
 
    unsigned int getParameterCount()
    {
        return spReflectionFunction_GetParameterCount((SlangReflectionFunction*)this);
    }
 
    VariableReflection* getParameterByIndex(unsigned int index)
    {
        return (VariableReflection*)spReflectionFunction_GetParameter(
            (SlangReflectionFunction*)this,
            index);
    }
 
    unsigned int getUserAttributeCount()
    {
        return spReflectionFunction_GetUserAttributeCount((SlangReflectionFunction*)this);
    }
    Attribute* getUserAttributeByIndex(unsigned int index)
    {
        return (
            Attribute*)spReflectionFunction_GetUserAttribute((SlangReflectionFunction*)this, index);
    }
    Attribute* findAttributeByName(SlangSession* globalSession, char const* name)
    {
        return (Attribute*)spReflectionFunction_FindUserAttributeByName(
            (SlangReflectionFunction*)this,
            globalSession,
            name);
    }
    Attribute* findUserAttributeByName(SlangSession* globalSession, char const* name)
    {
        return findAttributeByName(globalSession, name);
    }
    Modifier* findModifier(Modifier::ID id)
    {
        return (Modifier*)spReflectionFunction_FindModifier(
            (SlangReflectionFunction*)this,
            (SlangModifierID)id);
    }
 
    GenericReflection* getGenericContainer()
    {
        return (GenericReflection*)spReflectionFunction_GetGenericContainer(
            (SlangReflectionFunction*)this);
    }
 
    FunctionReflection* applySpecializations(GenericReflection* generic)
    {
        return (FunctionReflection*)spReflectionFunction_applySpecializations(
            (SlangReflectionFunction*)this,
            (SlangReflectionGeneric*)generic);
    }
 
    FunctionReflection* specializeWithArgTypes(unsigned int argCount, TypeReflection* const* types)
    {
        return (FunctionReflection*)spReflectionFunction_specializeWithArgTypes(
            (SlangReflectionFunction*)this,
            argCount,
            (SlangReflectionType* const*)types);
    }
 
    bool isOverloaded()
    {
        return spReflectionFunction_isOverloaded((SlangReflectionFunction*)this);
    }
 
    unsigned int getOverloadCount()
    {
        return spReflectionFunction_getOverloadCount((SlangReflectionFunction*)this);
    }
 
    FunctionReflection* getOverload(unsigned int index)
    {
        return (FunctionReflection*)spReflectionFunction_getOverload(
            (SlangReflectionFunction*)this,
            index);
    }
};
 
struct GenericReflection
{
 
    DeclReflection* asDecl()
    {
        return (DeclReflection*)spReflectionGeneric_asDecl((SlangReflectionGeneric*)this);
    }
 
    char const* getName() { return spReflectionGeneric_GetName((SlangReflectionGeneric*)this); }
 
    unsigned int getTypeParameterCount()
    {
        return spReflectionGeneric_GetTypeParameterCount((SlangReflectionGeneric*)this);
    }
 
    VariableReflection* getTypeParameter(unsigned index)
    {
        return (VariableReflection*)spReflectionGeneric_GetTypeParameter(
            (SlangReflectionGeneric*)this,
            index);
    }
 
    unsigned int getValueParameterCount()
    {
        return spReflectionGeneric_GetValueParameterCount((SlangReflectionGeneric*)this);
    }
 
    VariableReflection* getValueParameter(unsigned index)
    {
        return (VariableReflection*)spReflectionGeneric_GetValueParameter(
            (SlangReflectionGeneric*)this,
            index);
    }
 
    unsigned int getTypeParameterConstraintCount(VariableReflection* typeParam)
    {
        return spReflectionGeneric_GetTypeParameterConstraintCount(
            (SlangReflectionGeneric*)this,
            (SlangReflectionVariable*)typeParam);
    }
 
    TypeReflection* getTypeParameterConstraintType(VariableReflection* typeParam, unsigned index)
    {
        return (TypeReflection*)spReflectionGeneric_GetTypeParameterConstraintType(
            (SlangReflectionGeneric*)this,
            (SlangReflectionVariable*)typeParam,
            index);
    }
 
    DeclReflection* getInnerDecl()
    {
        return (DeclReflection*)spReflectionGeneric_GetInnerDecl((SlangReflectionGeneric*)this);
    }
 
    SlangDeclKind getInnerKind()
    {
        return spReflectionGeneric_GetInnerKind((SlangReflectionGeneric*)this);
    }
 
    GenericReflection* getOuterGenericContainer()
    {
        return (GenericReflection*)spReflectionGeneric_GetOuterGenericContainer(
            (SlangReflectionGeneric*)this);
    }
 
    TypeReflection* getConcreteType(VariableReflection* typeParam)
    {
        return (TypeReflection*)spReflectionGeneric_GetConcreteType(
            (SlangReflectionGeneric*)this,
            (SlangReflectionVariable*)typeParam);
    }
 
    int64_t getConcreteIntVal(VariableReflection* valueParam)
    {
        return spReflectionGeneric_GetConcreteIntVal(
            (SlangReflectionGeneric*)this,
            (SlangReflectionVariable*)valueParam);
    }
 
    GenericReflection* applySpecializations(GenericReflection* generic)
    {
        return (GenericReflection*)spReflectionGeneric_applySpecializations(
            (SlangReflectionGeneric*)this,
            (SlangReflectionGeneric*)generic);
    }
};
 
struct EntryPointReflection
{
    char const* getName()
    {
        return spReflectionEntryPoint_getName((SlangReflectionEntryPoint*)this);
    }
 
    char const* getNameOverride()
    {
        return spReflectionEntryPoint_getNameOverride((SlangReflectionEntryPoint*)this);
    }
 
    unsigned getParameterCount()
    {
        return spReflectionEntryPoint_getParameterCount((SlangReflectionEntryPoint*)this);
    }
 
    FunctionReflection* getFunction()
    {
        return (FunctionReflection*)spReflectionEntryPoint_getFunction(
            (SlangReflectionEntryPoint*)this);
    }
 
    VariableLayoutReflection* getParameterByIndex(unsigned index)
    {
        return (VariableLayoutReflection*)spReflectionEntryPoint_getParameterByIndex(
            (SlangReflectionEntryPoint*)this,
            index);
    }
 
    SlangStage getStage()
    {
        return spReflectionEntryPoint_getStage((SlangReflectionEntryPoint*)this);
    }
 
    void getComputeThreadGroupSize(SlangUInt axisCount, SlangUInt* outSizeAlongAxis)
    {
        return spReflectionEntryPoint_getComputeThreadGroupSize(
            (SlangReflectionEntryPoint*)this,
            axisCount,
            outSizeAlongAxis);
    }
 
    void getComputeWaveSize(SlangUInt* outWaveSize)
    {
        return spReflectionEntryPoint_getComputeWaveSize(
            (SlangReflectionEntryPoint*)this,
            outWaveSize);
    }
 
    bool usesAnySampleRateInput()
    {
        return 0 != spReflectionEntryPoint_usesAnySampleRateInput((SlangReflectionEntryPoint*)this);
    }
 
    VariableLayoutReflection* getVarLayout()
    {
        return (VariableLayoutReflection*)spReflectionEntryPoint_getVarLayout(
            (SlangReflectionEntryPoint*)this);
    }
 
    TypeLayoutReflection* getTypeLayout() { return getVarLayout()->getTypeLayout(); }
 
    VariableLayoutReflection* getResultVarLayout()
    {
        return (VariableLayoutReflection*)spReflectionEntryPoint_getResultVarLayout(
            (SlangReflectionEntryPoint*)this);
    }
 
    bool hasDefaultConstantBuffer()
    {
        return spReflectionEntryPoint_hasDefaultConstantBuffer((SlangReflectionEntryPoint*)this) !=
               0;
    }
};
 
typedef EntryPointReflection EntryPointLayout;
 
struct TypeParameterReflection
{
    char const* getName()
    {
        return spReflectionTypeParameter_GetName((SlangReflectionTypeParameter*)this);
    }
    unsigned getIndex()
    {
        return spReflectionTypeParameter_GetIndex((SlangReflectionTypeParameter*)this);
    }
    unsigned getConstraintCount()
    {
        return spReflectionTypeParameter_GetConstraintCount((SlangReflectionTypeParameter*)this);
    }
    TypeReflection* getConstraintByIndex(int index)
    {
        return (TypeReflection*)spReflectionTypeParameter_GetConstraintByIndex(
            (SlangReflectionTypeParameter*)this,
            index);
    }
};
 
enum class LayoutRules : SlangLayoutRulesIntegral
{
    Default = SLANG_LAYOUT_RULES_DEFAULT,
    MetalArgumentBufferTier2 = SLANG_LAYOUT_RULES_METAL_ARGUMENT_BUFFER_TIER_2,
    DefaultStructuredBuffer = SLANG_LAYOUT_RULES_DEFAULT_STRUCTURED_BUFFER,
    DefaultConstantBuffer = SLANG_LAYOUT_RULES_DEFAULT_CONSTANT_BUFFER,
};
 
typedef struct ShaderReflection ProgramLayout;
typedef enum SlangReflectionGenericArgType GenericArgType;
 
struct ShaderReflection
{
    unsigned getParameterCount() { return spReflection_GetParameterCount((SlangReflection*)this); }
 
    unsigned getTypeParameterCount()
    {
        return spReflection_GetTypeParameterCount((SlangReflection*)this);
    }
 
    slang::ISession* getSession() { return spReflection_GetSession((SlangReflection*)this); }
 
    TypeParameterReflection* getTypeParameterByIndex(unsigned index)
    {
        return (TypeParameterReflection*)spReflection_GetTypeParameterByIndex(
            (SlangReflection*)this,
            index);
    }
 
    TypeParameterReflection* findTypeParameter(char const* name)
    {
        return (
            TypeParameterReflection*)spReflection_FindTypeParameter((SlangReflection*)this, name);
    }
 
    VariableLayoutReflection* getParameterByIndex(unsigned index)
    {
        return (VariableLayoutReflection*)spReflection_GetParameterByIndex(
            (SlangReflection*)this,
            index);
    }
 
    static ProgramLayout* get(SlangCompileRequest* request)
    {
        return (ProgramLayout*)spGetReflection(request);
    }
 
    SlangUInt getEntryPointCount()
    {
        return spReflection_getEntryPointCount((SlangReflection*)this);
    }
 
    EntryPointReflection* getEntryPointByIndex(SlangUInt index)
    {
        return (
            EntryPointReflection*)spReflection_getEntryPointByIndex((SlangReflection*)this, index);
    }
 
    SlangUInt getGlobalConstantBufferBinding()
    {
        return spReflection_getGlobalConstantBufferBinding((SlangReflection*)this);
    }
 
    size_t getGlobalConstantBufferSize()
    {
        return spReflection_getGlobalConstantBufferSize((SlangReflection*)this);
    }
 
    TypeReflection* findTypeByName(const char* name)
    {
        return (TypeReflection*)spReflection_FindTypeByName((SlangReflection*)this, name);
    }
 
    FunctionReflection* findFunctionByName(const char* name)
    {
        return (FunctionReflection*)spReflection_FindFunctionByName((SlangReflection*)this, name);
    }
 
    FunctionReflection* findFunctionByNameInType(TypeReflection* type, const char* name)
    {
        return (FunctionReflection*)spReflection_FindFunctionByNameInType(
            (SlangReflection*)this,
            (SlangReflectionType*)type,
            name);
    }
 
    SLANG_DEPRECATED FunctionReflection* tryResolveOverloadedFunction(
        uint32_t candidateCount,
        FunctionReflection** candidates)
    {
        return (FunctionReflection*)spReflection_TryResolveOverloadedFunction(
            (SlangReflection*)this,
            candidateCount,
            (SlangReflectionFunction**)candidates);
    }
 
    VariableReflection* findVarByNameInType(TypeReflection* type, const char* name)
    {
        return (VariableReflection*)spReflection_FindVarByNameInType(
            (SlangReflection*)this,
            (SlangReflectionType*)type,
            name);
    }
 
    TypeLayoutReflection* getTypeLayout(
        TypeReflection* type,
        LayoutRules rules = LayoutRules::Default)
    {
        return (TypeLayoutReflection*)spReflection_GetTypeLayout(
            (SlangReflection*)this,
            (SlangReflectionType*)type,
            SlangLayoutRules(rules));
    }
 
    EntryPointReflection* findEntryPointByName(const char* name)
    {
        return (
            EntryPointReflection*)spReflection_findEntryPointByName((SlangReflection*)this, name);
    }
 
    TypeReflection* specializeType(
        TypeReflection* type,
        SlangInt specializationArgCount,
        TypeReflection* const* specializationArgs,
        ISlangBlob** outDiagnostics)
    {
        return (TypeReflection*)spReflection_specializeType(
            (SlangReflection*)this,
            (SlangReflectionType*)type,
            specializationArgCount,
            (SlangReflectionType* const*)specializationArgs,
            outDiagnostics);
    }
 
    GenericReflection* specializeGeneric(
        GenericReflection* generic,
        SlangInt specializationArgCount,
        GenericArgType const* specializationArgTypes,
        GenericArgReflection const* specializationArgVals,
        ISlangBlob** outDiagnostics)
    {
        return (GenericReflection*)spReflection_specializeGeneric(
            (SlangReflection*)this,
            (SlangReflectionGeneric*)generic,
            specializationArgCount,
            (SlangReflectionGenericArgType const*)specializationArgTypes,
            (SlangReflectionGenericArg const*)specializationArgVals,
            outDiagnostics);
    }
 
    bool isSubType(TypeReflection* subType, TypeReflection* superType)
    {
        return spReflection_isSubType(
            (SlangReflection*)this,
            (SlangReflectionType*)subType,
            (SlangReflectionType*)superType);
    }
 
    SlangUInt getHashedStringCount() const
    {
        return spReflection_getHashedStringCount((SlangReflection*)this);
    }
 
    const char* getHashedString(SlangUInt index, size_t* outCount) const
    {
        return spReflection_getHashedString((SlangReflection*)this, index, outCount);
    }
 
    TypeLayoutReflection* getGlobalParamsTypeLayout()
    {
        return (TypeLayoutReflection*)spReflection_getGlobalParamsTypeLayout(
            (SlangReflection*)this);
    }
 
    VariableLayoutReflection* getGlobalParamsVarLayout()
    {
        return (VariableLayoutReflection*)spReflection_getGlobalParamsVarLayout(
            (SlangReflection*)this);
    }
 
    SlangResult toJson(ISlangBlob** outBlob)
    {
        return spReflection_ToJson((SlangReflection*)this, nullptr, outBlob);
    }
 
    SlangInt getBindlessSpaceIndex()
    {
        return spReflection_getBindlessSpaceIndex((SlangReflection*)this);
    }
};
 
 
struct DeclReflection
{
    enum class Kind
    {
        Unsupported = SLANG_DECL_KIND_UNSUPPORTED_FOR_REFLECTION,
        Struct = SLANG_DECL_KIND_STRUCT,
        Func = SLANG_DECL_KIND_FUNC,
        Module = SLANG_DECL_KIND_MODULE,
        Generic = SLANG_DECL_KIND_GENERIC,
        Variable = SLANG_DECL_KIND_VARIABLE,
        Namespace = SLANG_DECL_KIND_NAMESPACE,
        Enum = SLANG_DECL_KIND_ENUM,
    };
 
    char const* getName() { return spReflectionDecl_getName((SlangReflectionDecl*)this); }
 
    Kind getKind() { return (Kind)spReflectionDecl_getKind((SlangReflectionDecl*)this); }
 
    unsigned int getChildrenCount()
    {
        return spReflectionDecl_getChildrenCount((SlangReflectionDecl*)this);
    }
 
    DeclReflection* getChild(unsigned int index)
    {
        return (DeclReflection*)spReflectionDecl_getChild((SlangReflectionDecl*)this, index);
    }
 
    TypeReflection* getType()
    {
        return (TypeReflection*)spReflection_getTypeFromDecl((SlangReflectionDecl*)this);
    }
 
    VariableReflection* asVariable()
    {
        return (VariableReflection*)spReflectionDecl_castToVariable((SlangReflectionDecl*)this);
    }
 
    FunctionReflection* asFunction()
    {
        return (FunctionReflection*)spReflectionDecl_castToFunction((SlangReflectionDecl*)this);
    }
 
    GenericReflection* asGeneric()
    {
        return (GenericReflection*)spReflectionDecl_castToGeneric((SlangReflectionDecl*)this);
    }
 
    DeclReflection* getParent()
    {
        return (DeclReflection*)spReflectionDecl_getParent((SlangReflectionDecl*)this);
    }
 
    Modifier* findModifier(Modifier::ID id)
    {
        return (Modifier*)spReflectionDecl_findModifier(
            (SlangReflectionDecl*)this,
            (SlangModifierID)id);
    }
 
    template<Kind K>
    struct FilteredList
    {
        unsigned int count;
        DeclReflection* parent;
 
        struct FilteredIterator
        {
            DeclReflection* parent;
            unsigned int count;
            unsigned int index;
 
            DeclReflection* operator*() { return parent->getChild(index); }
            void operator++()
            {
                index++;
                while (index < count && !(parent->getChild(index)->getKind() == K))
                {
                    index++;
                }
            }
            bool operator!=(FilteredIterator const& other) { return index != other.index; }
        };
 
        // begin/end for range-based for that checks the kind
        FilteredIterator begin()
        {
            // Find the first child of the right kind
            unsigned int index = 0;
            while (index < count && !(parent->getChild(index)->getKind() == K))
            {
                index++;
            }
            return FilteredIterator{parent, count, index};
        }
 
        FilteredIterator end() { return FilteredIterator{parent, count, count}; }
    };
 
    template<Kind K>
    FilteredList<K> getChildrenOfKind()
    {
        return FilteredList<K>{getChildrenCount(), (DeclReflection*)this};
    }
 
    struct IteratedList
    {
        unsigned int count;
        DeclReflection* parent;
 
        struct Iterator
        {
            DeclReflection* parent;
            unsigned int count;
            unsigned int index;
 
            DeclReflection* operator*() { return parent->getChild(index); }
            void operator++() { index++; }
            bool operator!=(Iterator const& other) { return index != other.index; }
        };
 
        // begin/end for range-based for that checks the kind
        IteratedList::Iterator begin() { return IteratedList::Iterator{parent, count, 0}; }
        IteratedList::Iterator end() { return IteratedList::Iterator{parent, count, count}; }
    };
 
    IteratedList getChildren() { return IteratedList{getChildrenCount(), (DeclReflection*)this}; }
};
 
typedef uint32_t CompileCoreModuleFlags;
struct CompileCoreModuleFlag
{
    enum Enum : CompileCoreModuleFlags
    {
        WriteDocumentation = 0x1,
    };
};
 
typedef ISlangBlob IBlob;
 
struct IComponentType;
struct ITypeConformance;
struct IGlobalSession;
struct IModule;
 
struct SessionDesc;
struct SpecializationArg;
struct TargetDesc;
 
enum class BuiltinModuleName
{
    Core = 0,
    GLSL = 1,
};
 
struct IGlobalSession : public ISlangUnknown
{
    SLANG_COM_INTERFACE(0xc140b5fd, 0xc78, 0x452e, {0xba, 0x7c, 0x1a, 0x1e, 0x70, 0xc7, 0xf7, 0x1c})
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    createSession(SessionDesc const& desc, ISession** outSession) = 0;
 
    virtual SLANG_NO_THROW SlangProfileID SLANG_MCALL findProfile(char const* name) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL
    setDownstreamCompilerPath(SlangPassThrough passThrough, char const* path) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL
    setDownstreamCompilerPrelude(SlangPassThrough passThrough, const char* preludeText) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL
    getDownstreamCompilerPrelude(SlangPassThrough passThrough, ISlangBlob** outPrelude) = 0;
 
    virtual SLANG_NO_THROW const char* SLANG_MCALL getBuildTagString() = 0;
 
    /* For a given source language set the default compiler.
    If a default cannot be chosen (for example the target cannot be achieved by the default),
    the default will not be used.
 
    @param sourceLanguage the source language
    @param defaultCompiler the default compiler for that language
    @return
    */
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL setDefaultDownstreamCompiler(
        SlangSourceLanguage sourceLanguage,
        SlangPassThrough defaultCompiler) = 0;
 
    /* For a source type get the default compiler
 
    @param sourceLanguage the source language
    @return The downstream compiler for that source language */
    virtual SlangPassThrough SLANG_MCALL
    getDefaultDownstreamCompiler(SlangSourceLanguage sourceLanguage) = 0;
 
    /* Set the 'prelude' placed before generated code for a specific language type.
 
    @param sourceLanguage The language the prelude should be inserted on.
    @param preludeText The text added pre-pended verbatim before the generated source
 
    Note! That for pass-through usage, prelude is not pre-pended, preludes are for code generation
    only.
    */
    virtual SLANG_NO_THROW void SLANG_MCALL
    setLanguagePrelude(SlangSourceLanguage sourceLanguage, const char* preludeText) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL
    getLanguagePrelude(SlangSourceLanguage sourceLanguage, ISlangBlob** outPrelude) = 0;
 
    [[deprecated]] virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    createCompileRequest(slang::ICompileRequest** outCompileRequest) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL
    addBuiltins(char const* sourcePath, char const* sourceString) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL
    setSharedLibraryLoader(ISlangSharedLibraryLoader* loader) = 0;
 
    virtual SLANG_NO_THROW ISlangSharedLibraryLoader* SLANG_MCALL getSharedLibraryLoader() = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    checkCompileTargetSupport(SlangCompileTarget target) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    checkPassThroughSupport(SlangPassThrough passThrough) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    compileCoreModule(CompileCoreModuleFlags flags) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    loadCoreModule(const void* coreModule, size_t coreModuleSizeInBytes) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    saveCoreModule(SlangArchiveType archiveType, ISlangBlob** outBlob) = 0;
 
    virtual SLANG_NO_THROW SlangCapabilityID SLANG_MCALL findCapability(char const* name) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerForTransition(
        SlangCompileTarget source,
        SlangCompileTarget target,
        SlangPassThrough compiler) = 0;
 
    virtual SLANG_NO_THROW SlangPassThrough SLANG_MCALL
    getDownstreamCompilerForTransition(SlangCompileTarget source, SlangCompileTarget target) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL
    getCompilerElapsedTime(double* outTotalTime, double* outDownstreamTime) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL setSPIRVCoreGrammar(char const* jsonPath) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL parseCommandLineArguments(
        int argc,
        const char* const* argv,
        SessionDesc* outSessionDesc,
        ISlangUnknown** outAuxAllocation) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    getSessionDescDigest(SessionDesc* sessionDesc, ISlangBlob** outBlob) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    compileBuiltinModule(BuiltinModuleName module, CompileCoreModuleFlags flags) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    loadBuiltinModule(BuiltinModuleName module, const void* moduleData, size_t sizeInBytes) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveBuiltinModule(
        BuiltinModuleName module,
        SlangArchiveType archiveType,
        ISlangBlob** outBlob) = 0;
};
 
    #define SLANG_UUID_IGlobalSession IGlobalSession::getTypeGuid()
 
struct TargetDesc
{
    size_t structureSize = sizeof(TargetDesc);
 
    SlangCompileTarget format = SLANG_TARGET_UNKNOWN;
 
    SlangProfileID profile = SLANG_PROFILE_UNKNOWN;
 
    SlangTargetFlags flags = kDefaultTargetFlags;
 
    SlangFloatingPointMode floatingPointMode = SLANG_FLOATING_POINT_MODE_DEFAULT;
 
    SlangLineDirectiveMode lineDirectiveMode = SLANG_LINE_DIRECTIVE_MODE_DEFAULT;
 
    bool forceGLSLScalarBufferLayout = false;
 
    const CompilerOptionEntry* compilerOptionEntries = nullptr;
 
    uint32_t compilerOptionEntryCount = 0;
};
 
typedef uint32_t SessionFlags;
enum
{
    kSessionFlags_None = 0
};
 
struct PreprocessorMacroDesc
{
    const char* name;
    const char* value;
};
 
struct SessionDesc
{
    size_t structureSize = sizeof(SessionDesc);
 
    TargetDesc const* targets = nullptr;
    SlangInt targetCount = 0;
 
    SessionFlags flags = kSessionFlags_None;
 
    SlangMatrixLayoutMode defaultMatrixLayoutMode = SLANG_MATRIX_LAYOUT_ROW_MAJOR;
 
    char const* const* searchPaths = nullptr;
    SlangInt searchPathCount = 0;
 
    PreprocessorMacroDesc const* preprocessorMacros = nullptr;
    SlangInt preprocessorMacroCount = 0;
 
    ISlangFileSystem* fileSystem = nullptr;
 
    bool enableEffectAnnotations = false;
    bool allowGLSLSyntax = false;
 
    const CompilerOptionEntry* compilerOptionEntries = nullptr;
 
    uint32_t compilerOptionEntryCount = 0;
 
    bool skipSPIRVValidation = false;
};
 
enum class ContainerType
{
    None = 0,
    UnsizedArray = 1,
    StructuredBuffer = 2,
    ConstantBuffer = 3,
    ParameterBlock = 4,
};
 
struct SourceLocation
{
    const char* filePath = nullptr;
    SlangInt line = -1;
    SlangInt column = -1;
};
 
struct ISession : public ISlangUnknown
{
    SLANG_COM_INTERFACE(0x67618701, 0xd116, 0x468f, {0xab, 0x3b, 0x47, 0x4b, 0xed, 0xce, 0xe, 0x3d})
 
    virtual SLANG_NO_THROW IGlobalSession* SLANG_MCALL getGlobalSession() = 0;
 
    virtual SLANG_NO_THROW IModule* SLANG_MCALL
    loadModule(const char* moduleName, IBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW IModule* SLANG_MCALL loadModuleFromSource(
        const char* moduleName,
        const char* path,
        slang::IBlob* source,
        slang::IBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL createCompositeComponentType(
        IComponentType* const* componentTypes,
        SlangInt componentTypeCount,
        IComponentType** outCompositeComponentType,
        ISlangBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW TypeReflection* SLANG_MCALL specializeType(
        TypeReflection* type,
        SpecializationArg const* specializationArgs,
        SlangInt specializationArgCount,
        ISlangBlob** outDiagnostics = nullptr) = 0;
 
 
    virtual SLANG_NO_THROW TypeLayoutReflection* SLANG_MCALL getTypeLayout(
        TypeReflection* type,
        SlangInt targetIndex = 0,
        LayoutRules rules = LayoutRules::Default,
        ISlangBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW TypeReflection* SLANG_MCALL getContainerType(
        TypeReflection* elementType,
        ContainerType containerType,
        ISlangBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW TypeReflection* SLANG_MCALL getDynamicType() = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    getTypeRTTIMangledName(TypeReflection* type, ISlangBlob** outNameBlob) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTypeConformanceWitnessMangledName(
        TypeReflection* type,
        TypeReflection* interfaceType,
        ISlangBlob** outNameBlob) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTypeConformanceWitnessSequentialID(
        slang::TypeReflection* type,
        slang::TypeReflection* interfaceType,
        uint32_t* outId) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    createCompileRequest(SlangCompileRequest** outCompileRequest) = 0;
 
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL createTypeConformanceComponentType(
        slang::TypeReflection* type,
        slang::TypeReflection* interfaceType,
        ITypeConformance** outConformance,
        SlangInt conformanceIdOverride,
        ISlangBlob** outDiagnostics) = 0;
 
    virtual SLANG_NO_THROW IModule* SLANG_MCALL loadModuleFromIRBlob(
        const char* moduleName,
        const char* path,
        slang::IBlob* source,
        slang::IBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW SlangInt SLANG_MCALL getLoadedModuleCount() = 0;
    virtual SLANG_NO_THROW IModule* SLANG_MCALL getLoadedModule(SlangInt index) = 0;
 
    virtual SLANG_NO_THROW bool SLANG_MCALL
    isBinaryModuleUpToDate(const char* modulePath, slang::IBlob* binaryModuleBlob) = 0;
 
    virtual SLANG_NO_THROW IModule* SLANG_MCALL loadModuleFromSourceString(
        const char* moduleName,
        const char* path,
        const char* string,
        slang::IBlob** outDiagnostics = nullptr) = 0;
 
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getDynamicObjectRTTIBytes(
        slang::TypeReflection* type,
        slang::TypeReflection* interfaceType,
        uint32_t* outRTTIDataBuffer,
        uint32_t bufferSizeInBytes) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadModuleInfoFromIRBlob(
        slang::IBlob* source,
        SlangInt& outModuleVersion,
        const char*& outModuleCompilerVersion,
        const char*& outModuleName) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    getDeclSourceLocation(slang::DeclReflection* decl, slang::SourceLocation* outLocation) = 0;
};
 
    #define SLANG_UUID_ISession ISession::getTypeGuid()
 
struct IMetadata : public ISlangCastable
{
    SLANG_COM_INTERFACE(0x8044a8a3, 0xddc0, 0x4b7f, {0xaf, 0x8e, 0x2, 0x6e, 0x90, 0x5d, 0x73, 0x32})
 
    /*
    Returns whether a resource parameter at the specified binding location is actually being used
    in the compiled shader.
    */
    virtual SlangResult isParameterLocationUsed(
        SlangParameterCategory category, // is this a `t` register? `s` register?
        SlangUInt spaceIndex,            // `space` for D3D12, `set` for Vulkan
        SlangUInt registerIndex,         // `register` for D3D12, `binding` for Vulkan
        bool& outUsed) = 0;
 
    /*
    Returns the debug build identifier for a base and debug spirv pair.
    */
    virtual const char* SLANG_MCALL getDebugBuildIdentifier() = 0;
};
    #define SLANG_UUID_IMetadata IMetadata::getTypeGuid()
 
struct CoverageEntryInfo
{
    size_t structSize = sizeof(CoverageEntryInfo);
 
    const char* file = nullptr;
 
    uint32_t line = 0;
};
 
struct CoverageBufferInfo
{
    size_t structSize = sizeof(CoverageBufferInfo);
 
    int32_t space = -1;
 
    int32_t binding = -1;
};
 
struct ICoverageTracingMetadata : public ISlangCastable
{
    SLANG_COM_INTERFACE(
        0x7c9f1d50,
        0x1e4a,
        0x4b9c,
        {0x8e, 0x21, 0x3f, 0x7b, 0x82, 0xa3, 0xd9, 0x51})
 
    virtual SLANG_NO_THROW uint32_t SLANG_MCALL getCounterCount() = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    getEntryInfo(uint32_t index, CoverageEntryInfo* outInfo) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getBufferInfo(CoverageBufferInfo* outInfo) = 0;
};
    #define SLANG_UUID_ICoverageTracingMetadata ICoverageTracingMetadata::getTypeGuid()
 
enum class SyntheticResourceScope : uint32_t
{
    Global = 0,
 
    EntryPoint = 1,
};
 
enum class SyntheticResourceAccess : uint32_t
{
    Read = 0,
    Write = 1,
    ReadWrite = 2,
};
 
struct SyntheticResourceInfo
{
    size_t structSize = sizeof(SyntheticResourceInfo);
 
    uint32_t id = 0;
 
    BindingType bindingType = BindingType::Unknown;
 
    uint32_t arraySize = 1;
 
    SyntheticResourceScope scope = SyntheticResourceScope::Global;
 
    SyntheticResourceAccess access = SyntheticResourceAccess::Read;
 
    int32_t entryPointIndex = -1;
 
    int32_t space = -1;
    int32_t binding = -1;
 
    int32_t uniformOffset = -1;
 
    int32_t uniformStride = 0;
 
    const char* debugName = nullptr;
};
 
struct ISyntheticResourceMetadata : public ISlangCastable
{
    SLANG_COM_INTERFACE(
        0x47a33723,
        0x181b,
        0x4d2b,
        {0xb8, 0x9e, 0x21, 0x54, 0x95, 0xbb, 0x38, 0x8b})
 
    virtual SLANG_NO_THROW uint32_t SLANG_MCALL getResourceCount() = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    getResourceInfo(uint32_t index, SyntheticResourceInfo* outInfo) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    findResourceIndexByID(uint32_t id, uint32_t* outIndex) = 0;
};
    #define SLANG_UUID_ISyntheticResourceMetadata ISyntheticResourceMetadata::getTypeGuid()
 
struct CooperativeMatrixType
{
    // Component type `NONE` means this type is not valid.
    SlangScalarType componentType = SLANG_SCALAR_TYPE_NONE;
    SlangScope scope = SLANG_SCOPE_NONE;
 
    uint32_t rowCount = 0;
    uint32_t columnCount = 0;
 
    SlangCooperativeMatrixUse use = SLANG_COOPERATIVE_MATRIX_USE_A;
};
 
struct CooperativeMatrixCombination
{
    // Number of rows of matrix A and the result.
    uint32_t m = 0;
    // Number of columns of matrix B and the result.
    uint32_t n = 0;
    // Shared inner dimension: columns of A and rows of B.
    uint32_t k = 0;
 
    SlangScalarType componentTypeA = SLANG_SCALAR_TYPE_NONE;
    SlangScalarType componentTypeB = SLANG_SCALAR_TYPE_NONE;
    SlangScalarType componentTypeC = SLANG_SCALAR_TYPE_NONE;
    SlangScalarType componentTypeResult = SLANG_SCALAR_TYPE_NONE;
 
    SlangBool saturate = false;
    SlangScope scope = SLANG_SCOPE_NONE;
};
 
struct CooperativeVectorTypeUsageInfo
{
    SlangScalarType componentType = SLANG_SCALAR_TYPE_NONE;
 
    // Maximum element count used for this component type in cooperative
    // operations (e.g. MatMul).
    uint32_t maxSize = 0;
 
    // Whether this component type is used as an accumulation/storage type for
    // cooperative training operations (e.g. outer-product accumulation and
    // reduce-sum accumulation). This flag is independent of `maxSize`.
    SlangBool usedForTrainingOp = false;
};
 
struct CooperativeVectorCombination
{
    SlangScalarType inputType = SLANG_SCALAR_TYPE_NONE;
    SlangScalarType inputInterpretation = SLANG_SCALAR_TYPE_NONE;
    // Number of logical elements packed into each physical input element.
    // For example, this is 4 when four int8 values are packed into one uint32 input element.
    uint32_t inputPackingFactor = 1;
    SlangScalarType matrixInterpretation = SLANG_SCALAR_TYPE_NONE;
    // `NONE` means the operation has no bias operand/matrix.
    SlangScalarType biasInterpretation = SLANG_SCALAR_TYPE_NONE;
    SlangScalarType resultType = SLANG_SCALAR_TYPE_NONE;
    SlangBool transpose = false;
};
 
struct ICooperativeTypesMetadata : public ISlangCastable
{
    SLANG_COM_INTERFACE(
        0x64c4d536,
        0xd949,
        0x49c3,
        {0x9f, 0xde, 0x3f, 0x0f, 0x9c, 0x6f, 0x01, 0x31})
 
    virtual SLANG_NO_THROW SlangUInt SLANG_MCALL getCooperativeMatrixTypeCount() = 0;
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    getCooperativeMatrixTypeByIndex(SlangUInt index, CooperativeMatrixType* outType) = 0;
 
    virtual SLANG_NO_THROW SlangUInt SLANG_MCALL getCooperativeMatrixCombinationCount() = 0;
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getCooperativeMatrixCombinationByIndex(
        SlangUInt index,
        CooperativeMatrixCombination* outCombination) = 0;
 
    virtual SLANG_NO_THROW SlangUInt SLANG_MCALL getCooperativeVectorTypeCount() = 0;
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    getCooperativeVectorTypeByIndex(SlangUInt index, CooperativeVectorTypeUsageInfo* outType) = 0;
 
    virtual SLANG_NO_THROW SlangUInt SLANG_MCALL getCooperativeVectorCombinationCount() = 0;
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getCooperativeVectorCombinationByIndex(
        SlangUInt index,
        CooperativeVectorCombination* outCombination) = 0;
};
    #define SLANG_UUID_ICooperativeTypesMetadata ICooperativeTypesMetadata::getTypeGuid()
 
struct ICompileResult : public ISlangCastable
{
    SLANG_COM_INTERFACE(
        0x5fa9380e,
        0xb62f,
        0x41e5,
        {0x9f, 0x12, 0x4b, 0xad, 0x4d, 0x9e, 0xaa, 0xe4})
 
    virtual uint32_t SLANG_MCALL getItemCount() = 0;
    virtual SlangResult SLANG_MCALL getItemData(uint32_t index, IBlob** outblob) = 0;
    virtual SlangResult SLANG_MCALL getMetadata(IMetadata** outMetadata) = 0;
};
    #define SLANG_UUID_ICompileResult ICompileResult::getTypeGuid()
 
struct IComponentType : public ISlangUnknown
{
    SLANG_COM_INTERFACE(0x5bc42be8, 0x5c50, 0x4929, {0x9e, 0x5e, 0xd1, 0x5e, 0x7c, 0x24, 0x1, 0x5f})
 
    virtual SLANG_NO_THROW ISession* SLANG_MCALL getSession() = 0;
 
    virtual SLANG_NO_THROW ProgramLayout* SLANG_MCALL
    getLayout(SlangInt targetIndex = 0, IBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW SlangInt SLANG_MCALL getSpecializationParamCount() = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointCode(
        SlangInt entryPointIndex,
        SlangInt targetIndex,
        IBlob** outCode,
        IBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getResultAsFileSystem(
        SlangInt entryPointIndex,
        SlangInt targetIndex,
        ISlangMutableFileSystem** outFileSystem) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL
    getEntryPointHash(SlangInt entryPointIndex, SlangInt targetIndex, IBlob** outHash) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL specialize(
        SpecializationArg const* specializationArgs,
        SlangInt specializationArgCount,
        IComponentType** outSpecializedComponentType,
        ISlangBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    link(IComponentType** outLinkedComponentType, ISlangBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointHostCallable(
        int entryPointIndex,
        int targetIndex,
        ISlangSharedLibrary** outSharedLibrary,
        slang::IBlob** outDiagnostics = 0) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    renameEntryPoint(const char* newName, IComponentType** outEntryPoint) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL linkWithOptions(
        IComponentType** outLinkedComponentType,
        uint32_t compilerOptionEntryCount,
        CompilerOptionEntry const* compilerOptionEntries,
        ISlangBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    getTargetCode(SlangInt targetIndex, IBlob** outCode, IBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTargetMetadata(
        SlangInt targetIndex,
        IMetadata** outMetadata,
        IBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointMetadata(
        SlangInt entryPointIndex,
        SlangInt targetIndex,
        IMetadata** outMetadata,
        IBlob** outDiagnostics = nullptr) = 0;
};
    #define SLANG_UUID_IComponentType IComponentType::getTypeGuid()
 
struct IEntryPoint : public IComponentType
{
    SLANG_COM_INTERFACE(0x8f241361, 0xf5bd, 0x4ca0, {0xa3, 0xac, 0x2, 0xf7, 0xfa, 0x24, 0x2, 0xb8})
 
    virtual SLANG_NO_THROW FunctionReflection* SLANG_MCALL getFunctionReflection() = 0;
};
 
    #define SLANG_UUID_IEntryPoint IEntryPoint::getTypeGuid()
 
struct ITypeConformance : public IComponentType
{
    SLANG_COM_INTERFACE(0x73eb3147, 0xe544, 0x41b5, {0xb8, 0xf0, 0xa2, 0x44, 0xdf, 0x21, 0x94, 0xb})
};
    #define SLANG_UUID_ITypeConformance ITypeConformance::getTypeGuid()
 
struct IComponentType2 : public ISlangUnknown
{
    SLANG_COM_INTERFACE(
        0x9c2a4b3d,
        0x7f68,
        0x4e91,
        {0xa5, 0x2c, 0x8b, 0x19, 0x3e, 0x45, 0x7a, 0x9f})
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTargetCompileResult(
        SlangInt targetIndex,
        ICompileResult** outCompileResult,
        IBlob** outDiagnostics = nullptr) = 0;
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointCompileResult(
        SlangInt entryPointIndex,
        SlangInt targetIndex,
        ICompileResult** outCompileResult,
        IBlob** outDiagnostics = nullptr) = 0;
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTargetHostCallable(
        int targetIndex,
        ISlangSharedLibrary** outSharedLibrary,
        slang::IBlob** outDiagnostics = 0) = 0;
};
    #define SLANG_UUID_IComponentType2 IComponentType2::getTypeGuid()
 
struct IModule : public IComponentType
{
    SLANG_COM_INTERFACE(0xc720e64, 0x8722, 0x4d31, {0x89, 0x90, 0x63, 0x8a, 0x98, 0xb1, 0xc2, 0x79})
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    findEntryPointByName(char const* name, IEntryPoint** outEntryPoint) = 0;
 
    virtual SLANG_NO_THROW SlangInt32 SLANG_MCALL getDefinedEntryPointCount() = 0;
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    getDefinedEntryPoint(SlangInt32 index, IEntryPoint** outEntryPoint) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL serialize(ISlangBlob** outSerializedBlob) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL writeToFile(char const* fileName) = 0;
 
    virtual SLANG_NO_THROW const char* SLANG_MCALL getName() = 0;
 
    virtual SLANG_NO_THROW const char* SLANG_MCALL getFilePath() = 0;
 
    virtual SLANG_NO_THROW const char* SLANG_MCALL getUniqueIdentity() = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL findAndCheckEntryPoint(
        char const* name,
        SlangStage stage,
        IEntryPoint** outEntryPoint,
        ISlangBlob** outDiagnostics) = 0;
 
    virtual SLANG_NO_THROW SlangInt32 SLANG_MCALL getDependencyFileCount() = 0;
 
    virtual SLANG_NO_THROW char const* SLANG_MCALL getDependencyFilePath(SlangInt32 index) = 0;
 
    virtual SLANG_NO_THROW DeclReflection* SLANG_MCALL getModuleReflection() = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    disassemble(slang::IBlob** outDisassembledBlob) = 0;
};
 
    #define SLANG_UUID_IModule IModule::getTypeGuid()
 
/* Experimental interface for doing target precompilation of slang modules */
struct IModulePrecompileService_Experimental : public ISlangUnknown
{
    // uuidgen output:     8e12e8e3 -  5fcd -  433e -    afcb -      13a088bc5ee5
    SLANG_COM_INTERFACE(
        0x8e12e8e3,
        0x5fcd,
        0x433e,
        {0xaf, 0xcb, 0x13, 0xa0, 0x88, 0xbc, 0x5e, 0xe5})
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    precompileForTarget(SlangCompileTarget target, ISlangBlob** outDiagnostics) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getPrecompiledTargetCode(
        SlangCompileTarget target,
        IBlob** outCode,
        IBlob** outDiagnostics = nullptr) = 0;
 
    virtual SLANG_NO_THROW SlangInt SLANG_MCALL getModuleDependencyCount() = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL getModuleDependency(
        SlangInt dependencyIndex,
        IModule** outModule,
        IBlob** outDiagnostics = nullptr) = 0;
};
 
    #define SLANG_UUID_IModulePrecompileService_Experimental \
        IModulePrecompileService_Experimental::getTypeGuid()
 
struct SpecializationArg
{
    enum class Kind : int32_t
    {
        Unknown = 0, 
        Type = 1,    
        Expr = 2,    
    };
 
    Kind kind;
    union
    {
        TypeReflection* type;
        const char* expr;
    };
 
    static SpecializationArg fromType(TypeReflection* inType)
    {
        SpecializationArg rs;
        rs.kind = Kind::Type;
        rs.type = inType;
        return rs;
    }
 
    static SpecializationArg fromExpr(const char* inExpr)
    {
        SpecializationArg rs;
        rs.kind = Kind::Expr;
        rs.expr = inExpr;
        return rs;
    }
};
} // namespace slang
 
    // Passed into functions to create globalSession to identify the API version client code is
    // using.
    #define SLANG_API_VERSION 0
 
enum SlangLanguageVersion
{
    SLANG_LANGUAGE_VERSION_UNKNOWN = 0,
    SLANG_LANGUAGE_VERSION_LEGACY = 2018,
    SLANG_LANGUAGE_VERSION_2025 = 2025,
    SLANG_LANGUAGE_VERSION_2026 = 2026,
    /* Deprecated: retained for source compatibility; prefer SLANG_LANGUAGE_VERSION_DEFAULT. */
    SLANG_LANGAUGE_VERSION_DEFAULT = SLANG_LANGUAGE_VERSION_LEGACY,
    SLANG_LANGUAGE_VERSION_DEFAULT = SLANG_LANGUAGE_VERSION_LEGACY,
    SLANG_LANGUAGE_VERSION_LATEST = SLANG_LANGUAGE_VERSION_2026,
};
 
 
/* Description of a Slang global session.
 */
struct SlangGlobalSessionDesc
{
    uint32_t structureSize = sizeof(SlangGlobalSessionDesc);
 
    uint32_t apiVersion = SLANG_API_VERSION;
 
    uint32_t minLanguageVersion = SLANG_LANGUAGE_VERSION_2025;
 
    bool enableGLSL = false;
 
    uint32_t reserved[16] = {};
};
 
/* Create a blob from binary data.
 *
 * @param data Pointer to the binary data to store in the blob. Must not be null.
 * @param size Size of the data in bytes. Must be greater than 0.
 * @return The created blob on success, or nullptr on failure.
 */
SLANG_EXTERN_C SLANG_API ISlangBlob* slang_createBlob(const void* data, size_t size);
 
/* Serialize coverage metadata into the canonical
 * `.coverage-mapping.json` shape. Same bytes that `slangc` writes
 * alongside compiled output when `-trace-coverage` is on, available
 * in-process for hosts compiling via the C++ API.
 *
 * The returned JSON is consumable by
 * `tools/shader-coverage/slang-coverage-to-lcov.py` and any tool
 * expecting the version-1 manifest format. If `metadata` is the
 * artifact metadata object returned by Slang, it also supports
 * `ISyntheticResourceMetadata`, and the serializer includes the
 * coverage buffer's descriptor-facing binding fields when available.
 *
 * @param metadata The coverage metadata, obtained via
 *                 `castAs<ICoverageTracingMetadata>` on the artifact's
 *                 `IMetadata`. Must not be null.
 * @param outBlob (out) The JSON bytes. Caller releases when done.
 * @return `SLANG_OK` on success, `SLANG_E_INVALID_ARG` for null
 *         arguments.
 */
SLANG_EXTERN_C SLANG_API SlangResult
slang_writeCoverageManifestJson(slang::ICoverageTracingMetadata* metadata, ISlangBlob** outBlob);
 
/* Load a module from source code with size specification.
 *
 * @param session The session to load the module into.
 * @param moduleName The name of the module.
 * @param path The path for the module.
 * @param source Pointer to the source code data.
 * @param sourceSize Size of the source code data in bytes.
 * @param outDiagnostics (out, optional) Diagnostics output.
 * @return The loaded module on success, or nullptr on failure.
 */
SLANG_EXTERN_C SLANG_API slang::IModule* slang_loadModuleFromSource(
    slang::ISession* session,
    const char* moduleName,
    const char* path,
    const char* source,
    size_t sourceSize,
    ISlangBlob** outDiagnostics = nullptr);
 
SLANG_EXTERN_C SLANG_API slang::IModule* slang_loadModuleFromIRBlob(
    slang::ISession* session,
    const char* moduleName,
    const char* path,
    const void* source,
    size_t sourceSize,
    ISlangBlob** outDiagnostics = nullptr);
 
SLANG_EXTERN_C SLANG_API SlangResult slang_loadModuleInfoFromIRBlob(
    slang::ISession* session,
    const void* source,
    size_t sourceSize,
    SlangInt& outModuleVersion,
    const char*& outModuleCompilerVersion,
    const char*& outModuleName);
 
/* Create a global session, with the built-in core module.
 
@param apiVersion Pass in SLANG_API_VERSION
@param outGlobalSession (out)The created global session.
*/
SLANG_EXTERN_C SLANG_API SlangResult
slang_createGlobalSession(SlangInt apiVersion, slang::IGlobalSession** outGlobalSession);
 
 
/* Create a global session, with the built-in core module.
 
@param desc Description of the global session.
@param outGlobalSession (out)The created global session.
*/
SLANG_EXTERN_C SLANG_API SlangResult slang_createGlobalSession2(
    const SlangGlobalSessionDesc* desc,
    slang::IGlobalSession** outGlobalSession);
 
/* Create a global session, but do not set up the core module. The core module can
then be loaded via loadCoreModule or compileCoreModule
 
@param apiVersion Pass in SLANG_API_VERSION
@param outGlobalSession (out)The created global session that doesn't have a core module setup.
 
NOTE! API is experimental and not ready for production code
*/
SLANG_EXTERN_C SLANG_API SlangResult slang_createGlobalSessionWithoutCoreModule(
    SlangInt apiVersion,
    slang::IGlobalSession** outGlobalSession);
 
/* Returns a blob that contains the serialized core module.
Returns nullptr if there isn't an embedded core module.
 
NOTE! API is experimental and not ready for production code
*/
SLANG_API ISlangBlob* slang_getEmbeddedCoreModule();
 
 
/* Cleanup all global allocations used by Slang, to prevent memory leak detectors from
 reporting them as leaks. This function should only be called after all Slang objects
 have been released. No other Slang functions such as `createGlobalSession`
 should be called after this function.
 */
SLANG_EXTERN_C SLANG_API void slang_shutdown();
 
/* Enable or disable the record layer for API call recording.
   When enabled, API calls are captured for later replay.
   The record layer can also be enabled by setting the SLANG_RECORD_LAYER=1 environment variable.
 
   Environment variables:
   - SLANG_RECORD_LAYER=1: Enable recording on startup
   - SLANG_RECORD_PATH=<path>: Use the exact path specified for recording output
     instead of generating a timestamped folder under .slang-replays/
 */
SLANG_EXTERN_C SLANG_API void slang_enableRecordLayer(bool enable);
 
/* Check if the record layer is currently enabled.
 */
SLANG_EXTERN_C SLANG_API bool slang_isRecordLayerEnabled();
 
/* Set the base directory for replay files (default: ".slang-replays").
   Must be called before enabling recording.
   @param path Path to the replay directory.
 */
SLANG_EXTERN_C SLANG_API void slang_setReplayDirectory(const char* path);
 
/* Get the current replay base directory.
   @return Path to the replay directory.
 */
SLANG_EXTERN_C SLANG_API const char* slang_getReplayDirectory();
 
/* Get the path to the current recording session folder.
   @return Path to the current replay folder, or nullptr if not recording.
 */
SLANG_EXTERN_C SLANG_API const char* slang_getCurrentReplayPath();
 
/* Load a replay from a folder path (reads stream.bin).
   Switches to playback mode on success.
   @param folderPath Path to the replay folder.
   @return SLANG_OK on success, SLANG_E_NOT_FOUND if stream.bin doesn't exist.
 */
SLANG_EXTERN_C SLANG_API SlangResult slang_loadReplay(const char* folderPath);
 
/* Load the most recent replay from the replay directory.
   Switches to playback mode on success.
   @return SLANG_OK on success, SLANG_E_NOT_FOUND if no replays exist.
 */
SLANG_EXTERN_C SLANG_API SlangResult slang_loadLatestReplay();
 
/* Insert a labeled marker into the replay stream.
   Useful for debugging replay streams. Marks a point with a human-readable label.
   No-op if the record layer is not active.
   @param label The marker label string.
 */
SLANG_EXTERN_C SLANG_API void slang_replayMarker(const char* label);
 
/* Return the last signaled internal error message.
 */
SLANG_EXTERN_C SLANG_API const char* slang_getLastInternalErrorMessage();
 
// Slang VM
namespace slang
{
 
enum class OperandDataType
{
    General = 0, // General data type, can be any type.
    Int32 = 1,   // 32-bit integer.
    Int64 = 2,   // 64-bit integer.
    Float32 = 3, // 32-bit floating-point number.
    Float64 = 4, // 64-bit floating-point number.
    String = 5,  // String data type, represented as a pointer to a null-terminated string.
};
 
struct VMExecOperand
{
    uint8_t** section; // Pointer to the section start pointer.
    #if SLANG_PTR_IS_32
    uint32_t padding;
    #endif
    uint32_t type : 8; // type of the operand data.
    uint32_t size : 24;
    uint32_t offset;
    void* getPtr() const { return *section + offset; }
    OperandDataType getType() const { return (OperandDataType)type; }
};
 
struct VMExecInstHeader;
class IByteCodeRunner;
 
typedef void (*VMExtFunction)(IByteCodeRunner* context, VMExecInstHeader* inst, void* userData);
typedef void (*VMPrintFunc)(const char* message, void* userData);
 
struct VMExecInstHeader
{
    VMExtFunction functionPtr; // Pointer to the function that executes this instruction.
    #if SLANG_PTR_IS_32
    uint32_t padding;
    #endif
    uint32_t opcodeExtension;
    uint32_t operandCount;
    VMExecInstHeader* getNextInst()
    {
        return (VMExecInstHeader*)((VMExecOperand*)(this + 1) + operandCount);
    }
    VMExecOperand& getOperand(SlangInt index) const
    {
        return *((VMExecOperand*)(this + 1) + index);
    }
};
 
struct ByteCodeFuncInfo
{
    uint32_t parameterCount;
    uint32_t returnValueSize;
};
 
struct ByteCodeRunnerDesc
{
    size_t structSize = sizeof(ByteCodeRunnerDesc);
};
 
class IByteCodeRunner : public ISlangUnknown
{
public:
    // {AFDAB195-361F-42CB-9513-9006261DD8CD}
    SLANG_COM_INTERFACE(0xafdab195, 0x361f, 0x42cb, {0x95, 0x13, 0x90, 0x6, 0x26, 0x1d, 0xd8, 0xcd})
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadModule(IBlob* moduleBlob) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    selectFunctionByIndex(uint32_t functionIndex) = 0;
 
    virtual SLANG_NO_THROW int SLANG_MCALL findFunctionByName(const char* name) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    getFunctionInfo(uint32_t index, ByteCodeFuncInfo* outInfo) = 0;
 
    virtual SLANG_NO_THROW void* SLANG_MCALL getCurrentWorkingSet() = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    execute(void* argumentData, size_t argumentSize) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL getErrorString(IBlob** outBlob) = 0;
 
    virtual SLANG_NO_THROW void* SLANG_MCALL getReturnValue(size_t* outValueSize) = 0;
 
    virtual SLANG_NO_THROW void SLANG_MCALL setExtInstHandlerUserData(void* userData) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    registerExtCall(const char* name, VMExtFunction functionPtr) = 0;
 
    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
    setPrintCallback(VMPrintFunc callback, void* userData) = 0;
};
 
} // namespace slang
 
SLANG_EXTERN_C SLANG_API SlangResult slang_createByteCodeRunner(
    const slang::ByteCodeRunnerDesc* desc,
    slang::IByteCodeRunner** outByteCodeRunner);
 
SLANG_EXTERN_C SLANG_API SlangResult
slang_disassembleByteCode(slang::IBlob* moduleBlob, slang::IBlob** outDisassemblyBlob);
 
namespace slang
{
inline SlangResult createGlobalSession(slang::IGlobalSession** outGlobalSession)
{
    SlangGlobalSessionDesc defaultDesc = {};
    return slang_createGlobalSession2(&defaultDesc, outGlobalSession);
}
inline SlangResult createGlobalSession(
    const SlangGlobalSessionDesc* desc,
    slang::IGlobalSession** outGlobalSession)
{
    return slang_createGlobalSession2(desc, outGlobalSession);
}
inline void shutdown()
{
    slang_shutdown();
}
inline const char* getLastInternalErrorMessage()
{
    return slang_getLastInternalErrorMessage();
}
} // namespace slang
 
#endif // C++ helpers
 
#define SLANG_ERROR_INSUFFICIENT_BUFFER SLANG_E_BUFFER_TOO_SMALL
#define SLANG_ERROR_INVALID_PARAMETER SLANG_E_INVALID_ARG
 
#endif