Initial import of code.

1 files changed, 897 insertions, 0 deletions

diff --git a/slang.h b/slang.h
new file mode 100644
index 000000000..a4fef24ba
--- /dev/null
+++ b/slang.h
@@ -0,0 +1,897 @@
+#ifndef SLANG_H
+#define SLANG_H
+
+#ifdef _MSC_VER
+#ifdef SLANG_COMPILING_DLL
+#define SLANG_API __declspec(dllexport)
+#else
+#ifdef SLANG_DYNAMIC
+#define SLANG_API __declspec(dllimport)
+#else
+#define SLANG_API
+#endif
+#endif
+#else
+#define SLANG_API
+#endif
+
+#ifndef  SLANG_NO_INTTYPES
+#include <inttypes.h>
+#endif // ! SLANG_NO_INTTYPES
+
+
+#ifdef __cplusplus  
+extern "C"
+{
+#endif
+    /*!
+    @mainpage Introduction
+
+    API Reference: slang.h
+
+    @file slang.h
+    */
+
+    typedef uint32_t    SlangUInt32;
+    typedef intptr_t    SlangInt;
+    typedef uintptr_t   SlangUInt;
+
+    /*!
+    @brief Severity of a diagnostic generated by the compiler.
+    Values come from the enum below, with higher values representing more severe
+    conditions, and all values >= SLANG_SEVERITY_ERROR indicating compilation
+    failure.
+    */
+    typedef int SlangSeverity;
+    enum
+    {
+        SLANG_SEVERITY_NOTE = 0,    /**< An informative message. */
+        SLANG_SEVERITY_WARNING,     /**< A warning, which indicates a possible proble. */
+        SLANG_SEVERITY_ERROR,       /**< An error, indicating that compilation failed. */
+        SLANG_SEVERITY_FATAL,       /**< An unrecoverable error, which forced compilation to abort. */
+        SLANG_SEVERITY_INTERNAL,    /**< An internal error, indicating a logic error in the compiler. */
+    };
+
+    typedef int SlangBindableResourceType;
+    enum
+    {
+        SLANG_NON_BINDABLE = 0,
+        SLANG_TEXTURE,
+        SLANG_SAMPLER,
+        SLANG_UNIFORM_BUFFER,
+        SLANG_STORAGE_BUFFER,
+    };
+
+    typedef int SlangCompileTarget;
+    enum
+    {
+        SLANG_TARGET_UNKNOWN,
+        SLANG_GLSL,
+        SLANG_GLSL_VULKAN,
+        SLANG_GLSL_VULKAN_ONE_DESC,
+        SLANG_HLSL,
+        SLANG_SPIRV,
+        SLANG_SPIRV_ASM,
+        SLANG_DXBC,
+        SLANG_DXBC_ASM,
+        SLANG_REFLECTION_JSON,
+    };
+
+    typedef int SlangPassThrough;
+    enum
+    {
+        SLANG_PASS_THROUGH_NONE,
+        SLANG_PASS_THROUGH_FXC,
+        SLANG_PASS_THROUGH_DXC,
+        SLANG_PASS_THROUGH_GLSLANG,
+    };
+
+    /*!
+    Flags to control compilation behavior.
+    */
+    typedef unsigned int SlangCompileFlags;
+    enum
+    {
+        SLANG_COMPILE_FLAG_NO_CHECKING = 1 << 0, /**< Disable semantic checking as much as possible. */
+    };
+
+    typedef int SlangSourceLanguage;
+    enum
+    {
+        SLANG_SOURCE_LANGUAGE_UNKNOWN,
+        SLANG_SOURCE_LANGUAGE_SLANG,
+        SLANG_SOURCE_LANGUAGE_HLSL,
+        SLANG_SOURCE_LANGUAGE_GLSL,
+    };
+
+    typedef unsigned int SlangProfileID;
+    enum
+    {
+        SLANG_PROFILE_UNKNOWN,
+    };
+
+//#define SLANG_LAYOUT_UNIFORM 0
+//#define SLANG_LAYOUT_PACKED 1
+//#define SLANG_LAYOUT_STORAGE 2
+
+#define SLANG_ERROR_INSUFFICIENT_BUFFER -1
+#define SLANG_ERROR_INVALID_PARAMETER -2
+
+    /*!
+    @brief An instance of the Slang library.
+    */
+    typedef struct SlangSession SlangSession;
+
+    /*!
+    @bref A request for one or more compilation actions to be performed.
+    */
+    typedef struct SlangCompileRequest SlangCompileRequest;
+
+    /*!
+    @brief Initialize an instance of the Slang library.
+    @param cacheDir The directory used to store cached compilation results. Pass NULL to disable caching.
+    */
+    SLANG_API SlangSession* spCreateSession(const char * cacheDir);
+
+    /*!
+    @brief Clean up after an instance of the Slang library.
+    */
+    SLANG_API void spDestroySession(
+        SlangSession*   session);
+
+
+    /*!
+    @brief Add new builtin declarations to be used in subsequent compiles.
+    */
+    SLANG_API void spAddBuiltins(
+        SlangSession*   session,
+        char const*     sourcePath,
+        char const*     sourceString);
+
+    /*!
+    @brief Create a compile request.
+    */
+    SLANG_API SlangCompileRequest* spCreateCompileRequest(
+        SlangSession* session);
+
+    /*!
+    @brief Destroy a compile request.
+    */
+    SLANG_API void spDestroyCompileRequest(
+        SlangCompileRequest*    request);
+
+
+    /*!
+    @brief Set flags to be used for compilation.
+    */
+    SLANG_API void spSetCompileFlags(
+        SlangCompileRequest*    request,
+        SlangCompileFlags       flags);
+
+    /*!
+    @brief Sets the target for code generation.
+    @param ctx The compilation context.
+    @param target The code generation target. Possible values are:
+    - SLANG_GLSL. Generates GLSL code.
+    - SLANG_HLSL. Generates HLSL code.
+    - SLANG_SPIRV. Generates SPIR-V code.
+    */
+    SLANG_API void spSetCodeGenTarget(
+        SlangCompileRequest*    request,
+        int target);
+
+    SLANG_API void spSetPassThrough(
+        SlangCompileRequest*    request,
+        SlangPassThrough        passThrough);
+
+    typedef void(*SlangDiagnosticCallback)(
+        char const* message,
+        void*       userData);
+
+    SLANG_API void spSetDiagnosticCallback(
+        SlangCompileRequest*    request,
+        SlangDiagnosticCallback callback,
+        void const*             userData);
+
+    /*!
+    @brief Add a path in which source files are being search. When the programmer specifies @code using <file_name> @endcode in code, the compiler searches the file
+    in all search pathes in order.
+    @param ctx The compilation context.
+    @param searchDir The additional search directory.
+    */
+    SLANG_API void spAddSearchPath(
+        SlangCompileRequest*    request,
+        const char*             searchDir);
+
+    /*!
+    @brief Add a macro definition to be used during preprocessing.
+    @param key The name of the macro to define.
+    @param value The value of the macro to define.
+    */
+    SLANG_API void spAddPreprocessorDefine(
+        SlangCompileRequest*    request,
+        const char*             key,
+        const char*             value);
+
+
+    /** Add a distinct translation unit to the compilation request
+
+    `name` is optional.
+    Returns the zero-based index of the translation unit created.
+    */
+    SLANG_API int spAddTranslationUnit(
+        SlangCompileRequest*    request,
+        SlangSourceLanguage     language,
+        char const*             name);
+
+    /** Add a source file to the given translation unit
+    */
+    SLANG_API void spAddTranslationUnitSourceFile(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        char const*             path);
+
+    /** Add a source string to the given translation unit
+
+    The `path` will be used in any diagnostic output.
+    */
+    SLANG_API void spAddTranslationUnitSourceString(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        char const*             path,
+        char const*             source);
+
+    /** Look up a compilation profile by name.
+
+    For example, one could look up the string `"ps_5_0"` to find the corresponding target ID.
+    */
+    SLANG_API SlangProfileID spFindProfile(
+        SlangSession*   session,
+        char const*     name);
+
+    /** Add an entry point in a particular translation unit
+    */
+    SLANG_API int spAddTranslationUnitEntryPoint(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        char const*             name,
+        SlangProfileID          profile);
+
+    /** Execute the compilation request.
+
+    Returns zero on success, non-zero on failure.
+    */
+    SLANG_API int spCompile(
+        SlangCompileRequest*    request);
+
+
+    /** Get any diagnostic messages reported by the compiler.
+    */
+    SLANG_API char const* spGetDiagnosticOutput(
+        SlangCompileRequest*    request);
+
+    /** Get the number of files that this compilation depended on.
+    
+    This includes both the explicit source files, as well as any
+    additional files that were transitively referenced (e.g., via
+    a `#include` directive).
+    */
+    SLANG_API int
+    spGetDependencyFileCount(
+        SlangCompileRequest*    request);
+
+    /** Get the path to a file this compilation dependend on.
+    */
+    SLANG_API char const*
+    spGetDependencyFilePath(
+        SlangCompileRequest*    request,
+        int                     index);
+
+    /** Get the number of tranlsation units associated with the compilation request
+    */
+    SLANG_API int
+    spGetTranslationUnitCount(
+        SlangCompileRequest*    request);
+
+    /** Get the output code associated with a specific translation unit
+
+    The lifetime of the output pointer is the same as `request`.
+    */
+    SLANG_API char const* spGetTranslationUnitSource(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex);
+
+    /** Get the output code associated with a specific entry point.
+
+    The lifetime of the output pointer is the same as `request`.
+    */
+    SLANG_API char const* spGetEntryPointSource(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        int                     entryPointIndex);
+
+
+    /* Note(tfoley): working on new reflection interface...
+    */
+
+    typedef struct SlangReflection                  SlangReflection;
+    typedef struct SlangReflectionEntryPoint        SlangReflectionEntryPoint;
+    typedef struct SlangReflectionType              SlangReflectionType;
+    typedef struct SlangReflectionTypeLayout        SlangReflectionTypeLayout;
+    typedef struct SlangReflectionVariable          SlangReflectionVariable;
+    typedef struct SlangReflectionVariableLayout    SlangReflectionVariableLayout;
+
+    // get reflection data from a compilation request
+    SLANG_API SlangReflection* spGetReflection(
+        SlangCompileRequest*    request);
+
+    // type reflection
+
+    typedef unsigned int SlangTypeKind;
+    enum
+    {
+        SLANG_TYPE_KIND_NONE,
+        SLANG_TYPE_KIND_STRUCT,
+        SLANG_TYPE_KIND_ARRAY,
+        SLANG_TYPE_KIND_MATRIX,
+        SLANG_TYPE_KIND_VECTOR,
+        SLANG_TYPE_KIND_SCALAR,
+        SLANG_TYPE_KIND_CONSTANT_BUFFER,
+        SLANG_TYPE_KIND_RESOURCE,
+        SLANG_TYPE_KIND_SAMPLER_STATE,
+    
+        SLANG_TYPE_KIND_COUNT,
+    };
+
+    typedef unsigned int SlangScalarType;
+    enum
+    {
+        SLANG_SCALAR_TYPE_NONE,
+        SLANG_SCALAR_TYPE_VOID,
+        SLANG_SCALAR_TYPE_BOOL,
+        SLANG_SCALAR_TYPE_INT32,
+        SLANG_SCALAR_TYPE_UINT32,
+        SLANG_SCALAR_TYPE_INT64,
+        SLANG_SCALAR_TYPE_UINT64,
+        SLANG_SCALAR_TYPE_FLOAT16,
+        SLANG_SCALAR_TYPE_FLOAT32,
+        SLANG_SCALAR_TYPE_FLOAT64,
+    };
+
+    typedef unsigned int SlangResourceShape;
+    enum
+    {
+        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_RESOURCE_EXT_SHAPE_MASK       = 0xF0,
+        SLANG_TEXTURE_ARRAY_FLAG            = 0x40,
+        SLANG_TEXTURE_MULTISAMPLE_FLAG      = 0x80,
+
+        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,
+    };
+
+    typedef unsigned int SlangResourceAccess;
+    enum
+    {
+        SLANG_RESOURCE_ACCESS_NONE,
+        SLANG_RESOURCE_ACCESS_READ,
+        SLANG_RESOURCE_ACCESS_READ_WRITE,
+        SLANG_RESOURCE_ACCESS_RASTER_ORDERED,
+        SLANG_RESOURCE_ACCESS_APPEND,
+        SLANG_RESOURCE_ACCESS_CONSUME,
+    };
+
+    typedef unsigned int SlangParameterCategory;
+    enum
+    {
+        SLANG_PARAMETER_CATEGORY_NONE,
+        SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
+        SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE,
+        SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS,
+        SLANG_PARAMETER_CATEGORY_VERTEX_INPUT,
+        SLANG_PARAMETER_CATEGORY_FRAGMENT_OUTPUT,
+        SLANG_PARAMETER_CATEGORY_SAMPLER_STATE,
+        SLANG_PARAMETER_CATEGORY_UNIFORM,
+        SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT,
+        SLANG_PARAMETER_CATEGORY_SPECIALIZTION_CONSTANT,
+        SLANG_PARAMETER_CATEGORY_MIXED,
+    };
+
+    typedef SlangUInt32 SlangStage;
+    enum
+    {
+        SLANG_STAGE_NONE,
+        SLANG_STAGE_VERTEX,
+        SLANG_STAGE_HULL,
+        SLANG_STAGE_DOMAIN,
+        SLANG_STAGE_GEOMETRY,
+        SLANG_STAGE_FRAGMENT,
+        SLANG_STAGE_COMPUTE,
+
+        SLANG_STAGE_PIXEL = SLANG_STAGE_FRAGMENT,
+    };
+
+    // Type Reflection
+
+    SLANG_API SlangTypeKind spReflectionType_GetKind(SlangReflectionType* type);
+    SLANG_API unsigned int spReflectionType_GetFieldCount(SlangReflectionType* type);
+    SLANG_API SlangReflectionVariable* spReflectionType_GetFieldByIndex(SlangReflectionType* type, unsigned index);
+
+    SLANG_API size_t spReflectionType_GetElementCount(SlangReflectionType* type);
+    SLANG_API SlangReflectionType* spReflectionType_GetElementType(SlangReflectionType* type);
+
+    SLANG_API unsigned int spReflectionType_GetRowCount(SlangReflectionType* type);
+    SLANG_API unsigned int spReflectionType_GetColumnCount(SlangReflectionType* type);
+    SLANG_API SlangScalarType spReflectionType_GetScalarType(SlangReflectionType* type);
+
+    SLANG_API SlangResourceShape spReflectionType_GetResourceShape(SlangReflectionType* type);
+    SLANG_API SlangResourceAccess spReflectionType_GetResourceAccess(SlangReflectionType* type);
+    SLANG_API SlangReflectionType* spReflectionType_GetResourceResultType(SlangReflectionType* type);
+
+    // Type Layout Reflection
+
+    SLANG_API SlangReflectionType* spReflectionTypeLayout_GetType(SlangReflectionTypeLayout* type);
+    SLANG_API size_t spReflectionTypeLayout_GetSize(SlangReflectionTypeLayout* type, SlangParameterCategory category);
+
+    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_GetFieldByIndex(SlangReflectionTypeLayout* type, unsigned index);
+
+    SLANG_API size_t spReflectionTypeLayout_GetElementStride(SlangReflectionTypeLayout* type, SlangParameterCategory category);
+    SLANG_API SlangReflectionTypeLayout* spReflectionTypeLayout_GetElementTypeLayout(SlangReflectionTypeLayout* type);
+
+    SLANG_API SlangParameterCategory spReflectionTypeLayout_GetParameterCategory(SlangReflectionTypeLayout* type);
+
+    SLANG_API unsigned spReflectionTypeLayout_GetCategoryCount(SlangReflectionTypeLayout* type);
+    SLANG_API SlangParameterCategory spReflectionTypeLayout_GetCategoryByIndex(SlangReflectionTypeLayout* type, unsigned index);
+
+    // Variable Reflection
+
+    SLANG_API char const* spReflectionVariable_GetName(SlangReflectionVariable* var);
+    SLANG_API SlangReflectionType* spReflectionVariable_GetType(SlangReflectionVariable* var);
+
+    // Variable Layout Reflection
+
+    SLANG_API SlangReflectionVariable* spReflectionVariableLayout_GetVariable(SlangReflectionVariableLayout* var);
+
+    SLANG_API SlangReflectionTypeLayout* spReflectionVariableLayout_GetTypeLayout(SlangReflectionVariableLayout* var);
+
+    SLANG_API size_t spReflectionVariableLayout_GetOffset(SlangReflectionVariableLayout* var, SlangParameterCategory category);
+    SLANG_API size_t spReflectionVariableLayout_GetSpace(SlangReflectionVariableLayout* var, SlangParameterCategory category);
+
+    // Shader Parameter Reflection
+
+    typedef SlangReflectionVariableLayout SlangReflectionParameter;
+
+    SLANG_API unsigned spReflectionParameter_GetBindingIndex(SlangReflectionParameter* parameter);
+    SLANG_API unsigned spReflectionParameter_GetBindingSpace(SlangReflectionParameter* parameter);
+
+    // Entry Point Reflection
+
+    SLANG_API SlangStage spReflectionEntryPoint_getStage(SlangReflectionEntryPoint* entryPoint);
+
+    SLANG_API void spReflectionEntryPoint_getComputeThreadGroupSize(
+        SlangReflectionEntryPoint*  entryPoint,
+        SlangUInt                   axisCount,
+        SlangUInt*                  outSizeAlongAxis);
+
+    // Shader Reflection
+
+    SLANG_API unsigned spReflection_GetParameterCount(SlangReflection* reflection);
+    SLANG_API SlangReflectionParameter* spReflection_GetParameterByIndex(SlangReflection* reflection, unsigned index);
+
+
+    SLANG_API SlangUInt spReflection_getEntryPointCount(SlangReflection* reflection);
+
+    SLANG_API SlangReflectionEntryPoint* spReflection_getEntryPointByIndex(SlangReflection* reflection, SlangUInt index);
+
+#ifdef __cplusplus  
+}
+
+/* Helper interfaces for C++ users */
+namespace slang
+{
+#define SLANG_SAFE_BOOL(expr) \
+    operator bool() const { return expr; }
+
+    struct BufferReflection;
+    struct TypeLayoutReflection;
+    struct TypeReflection;
+    struct VariableLayoutReflection;
+    struct VariableReflection;
+
+    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,
+        };
+
+        enum ScalarType : SlangScalarType
+        {
+            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,
+        };
+
+        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;
+        }
+
+        // only useful if `getKind() == Kind::Array`
+        size_t getElementCount()
+        {
+            return spReflectionType_GetElementCount((SlangReflectionType*) this);
+        }
+
+        size_t getTotalArrayElementCount()
+        {
+            if(!isArray()) return 0;
+            size_t result = 1;
+            TypeReflection* type = this;
+            for(;;)
+            {
+                if(!type->isArray())
+                    return result;
+
+                result *= type->getElementCount();
+                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);
+        }
+    };
+
+    enum ParameterCategory : SlangParameterCategory
+    {
+        // TODO: these aren't scoped...
+        None = SLANG_PARAMETER_CATEGORY_NONE,
+        ConstantBuffer = SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
+        ShaderResource = SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE,
+        UnorderedAccess = SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS,
+        VertexInput = SLANG_PARAMETER_CATEGORY_VERTEX_INPUT,
+        FragmentOutput = SLANG_PARAMETER_CATEGORY_FRAGMENT_OUTPUT,
+        SamplerState = SLANG_PARAMETER_CATEGORY_SAMPLER_STATE,
+        Uniform = SLANG_PARAMETER_CATEGORY_UNIFORM,
+        DescriptorTableSlot = SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT,
+        SpecializationConstant = SLANG_PARAMETER_CATEGORY_SPECIALIZTION_CONSTANT,
+        Mixed = SLANG_PARAMETER_CATEGORY_MIXED,
+    };
+
+    struct TypeLayoutReflection
+    {
+        TypeReflection* getType()
+        {
+            return (TypeReflection*) spReflectionTypeLayout_GetType((SlangReflectionTypeLayout*) this);
+        }
+
+        TypeReflection::Kind getKind() { return getType()->getKind(); }
+
+        size_t getSize(SlangParameterCategory category = SLANG_PARAMETER_CATEGORY_UNIFORM)
+        {
+            return spReflectionTypeLayout_GetSize((SlangReflectionTypeLayout*) this, category);
+        }
+
+        unsigned int getFieldCount()
+        {
+            return getType()->getFieldCount();
+        }
+
+        VariableLayoutReflection* getFieldByIndex(unsigned int index)
+        {
+            return (VariableLayoutReflection*) spReflectionTypeLayout_GetFieldByIndex((SlangReflectionTypeLayout*) this, index);
+        }
+
+        bool isArray() { return getType()->isArray(); }
+
+        TypeLayoutReflection* unwrapArray()
+        {
+            TypeLayoutReflection* typeLayout = this;
+            while( typeLayout->isArray() )
+            {
+                typeLayout = typeLayout->getElementTypeLayout();
+            }
+            return typeLayout;
+        }
+
+        // only useful if `getKind() == Kind::Array`
+        size_t getElementCount()
+        {
+            return getType()->getElementCount();
+        }
+
+        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);
+        }
+
+        // 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();
+        }
+
+    };
+
+    struct VariableReflection
+    {
+        char const* getName()
+        {
+            return spReflectionVariable_GetName((SlangReflectionVariable*) this);
+        }
+
+        TypeReflection* getType()
+        {
+            return (TypeReflection*) spReflectionVariable_GetType((SlangReflectionVariable*) this);
+        }
+    };
+
+    struct VariableLayoutReflection
+    {
+        VariableReflection* getVariable()
+        {
+            return (VariableReflection*) spReflectionVariableLayout_GetVariable((SlangReflectionVariableLayout*) this);
+        }
+
+        char const* getName()
+        {
+            return getVariable()->getName();
+        }
+
+        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 = SLANG_PARAMETER_CATEGORY_UNIFORM)
+        {
+            return spReflectionVariableLayout_GetOffset((SlangReflectionVariableLayout*) this, 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);
+        }
+    };
+
+    struct EntryPointReflection
+    {
+        SlangStage getStage()
+        {
+            return spReflectionEntryPoint_getStage((SlangReflectionEntryPoint*) this);
+        }
+
+        void getComputeThreadGroupSize(
+            SlangUInt   axisCount,
+            SlangUInt*  outSizeAlongAxis)
+        {
+            return spReflectionEntryPoint_getComputeThreadGroupSize((SlangReflectionEntryPoint*) this, axisCount, outSizeAlongAxis);
+        }
+    };
+
+    struct ShaderReflection
+    {
+        unsigned getParameterCount()
+        {
+            return spReflection_GetParameterCount((SlangReflection*) this);
+        }
+
+        VariableLayoutReflection* getParameterByIndex(unsigned index)
+        {
+            return (VariableLayoutReflection*) spReflection_GetParameterByIndex((SlangReflection*) this, index);
+        }
+
+        static ShaderReflection* get(SlangCompileRequest* request)
+        {
+            return (ShaderReflection*) spGetReflection(request);
+        }
+
+        SlangUInt getEntryPointCount()
+        {
+            return spReflection_getEntryPointCount((SlangReflection*) this);
+        }
+
+        EntryPointReflection* getEntryPointByIndex(SlangUInt index)
+        {
+            return (EntryPointReflection*) spReflection_getEntryPointByIndex((SlangReflection*) this, index);
+        }
+    };
+}
+
+#endif
+
+#ifdef SLANG_INCLUDE_IMPLEMENTATION
+
+#include "source/core/slang-io.cpp"
+#include "source/core/slang-math.cpp"
+#include "source/core/slang-string.cpp"
+#include "source/core/stream.cpp"
+#include "source/core/text-io.cpp"
+#include "source/slang/diagnostics.cpp"
+#include "source/slang/emit.cpp"
+#include "source/slang/lexer.cpp"
+#include "source/slang/parameter-binding.cpp"
+#include "source/slang/parser.cpp"
+#include "source/slang/preprocessor.cpp"
+#include "source/slang/lookup.cpp"
+#include "source/slang/check.cpp"
+#include "source/slang/compiler.cpp"
+#include "source/slang/slang-stdlib.cpp"
+#include "source/slang/syntax.cpp"
+#include "source/slang/token.cpp"
+#include "source/slang/type-layout.cpp"
+#include "source/slang/reflection.cpp"
+#include "source/slang/slang.cpp"
+
+
+#endif
+
+#endif