format

* format

* Minor test fixes

* enable checking cpp format in ci

1 files changed, 737 insertions, 325 deletions

diff --git a/prelude/slang-cpp-types.h b/prelude/slang-cpp-types.h
index 3f805a8b7..010ab8d6c 100644
--- a/prelude/slang-cpp-types.h
+++ b/prelude/slang-cpp-types.h
@@ -2,11 +2,12 @@
 #define SLANG_PRELUDE_CPP_TYPES_H
 
 #ifdef SLANG_PRELUDE_NAMESPACE
-namespace SLANG_PRELUDE_NAMESPACE {
+namespace SLANG_PRELUDE_NAMESPACE
+{
 #endif
 
 #ifndef SLANG_FORCE_INLINE
-#    define SLANG_FORCE_INLINE inline
+#define SLANG_FORCE_INLINE inline
 #endif
 
 #include "slang-cpp-types-core.h"
@@ -23,8 +24,8 @@ typedef Vector<uint32_t, 2> uint2;
 typedef Vector<uint32_t, 3> uint3;
 typedef Vector<uint32_t, 4> uint4;
 
-// We can just map `NonUniformResourceIndex` type directly to the index type on CPU, as CPU does not require
-// any special handling around such accesses.
+// We can just map `NonUniformResourceIndex` type directly to the index type on CPU, as CPU does not
+// require any special handling around such accesses.
 typedef size_t NonUniformResourceIndex;
 
 // ----------------------------- ResourceType -----------------------------------------
@@ -32,47 +33,87 @@ typedef size_t NonUniformResourceIndex;
 // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-object-structuredbuffer-getdimensions
 // Missing  Load(_In_  int  Location, _Out_ uint Status);
 
-template <typename T>
+template<typename T>
 struct RWStructuredBuffer
 {
-    SLANG_FORCE_INLINE T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
-    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }  
-    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride) { *outNumStructs = uint32_t(count); *outStride = uint32_t(sizeof(T)); }
-  
+    SLANG_FORCE_INLINE T& operator[](size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    const T& Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride)
+    {
+        *outNumStructs = uint32_t(count);
+        *outStride = uint32_t(sizeof(T));
+    }
+
     T* data;
     size_t count;
 };
 
-template <typename T>
+template<typename T>
 struct StructuredBuffer
 {
-    SLANG_FORCE_INLINE const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
-    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
-    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride) { *outNumStructs = uint32_t(count); *outStride = uint32_t(sizeof(T)); }
-    
+    SLANG_FORCE_INLINE const T& operator[](size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    const T& Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride)
+    {
+        *outNumStructs = uint32_t(count);
+        *outStride = uint32_t(sizeof(T));
+    }
+
     T* data;
     size_t count;
 };
 
 
-template <typename T>
+template<typename T>
 struct RWBuffer
 {
-    SLANG_FORCE_INLINE T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
-    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    SLANG_FORCE_INLINE T& operator[](size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    const T& Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
     void GetDimensions(uint32_t* outCount) { *outCount = uint32_t(count); }
-    
+
     T* data;
     size_t count;
 };
 
-template <typename T>
+template<typename T>
 struct Buffer
 {
-    SLANG_FORCE_INLINE const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
-    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    SLANG_FORCE_INLINE const T& operator[](size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
+    const T& Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK(index, count);
+        return data[index];
+    }
     void GetDimensions(uint32_t* outCount) { *outCount = uint32_t(count); }
-    
+
     T* data;
     size_t count;
 };
@@ -81,28 +122,28 @@ struct Buffer
 struct ByteAddressBuffer
 {
     void GetDimensions(uint32_t* outDim) const { *outDim = uint32_t(sizeInBytes); }
-    uint32_t Load(size_t index) const 
-    { 
+    uint32_t Load(size_t index) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
-        return data[index >> 2]; 
+        return data[index >> 2];
     }
-    uint2 Load2(size_t index) const 
-    { 
+    uint2 Load2(size_t index) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
-        const size_t dataIdx = index >> 2; 
-        return uint2{data[dataIdx], data[dataIdx + 1]}; 
+        const size_t dataIdx = index >> 2;
+        return uint2{data[dataIdx], data[dataIdx + 1]};
     }
-    uint3 Load3(size_t index) const 
-    { 
+    uint3 Load3(size_t index) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
-        const size_t dataIdx = index >> 2; 
-        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]}; 
+        const size_t dataIdx = index >> 2;
+        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]};
     }
-    uint4 Load4(size_t index) const 
-    { 
+    uint4 Load4(size_t index) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
-        const size_t dataIdx = index >> 2; 
-        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]}; 
+        const size_t dataIdx = index >> 2;
+        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]};
     }
     template<typename T>
     T Load(size_t index) const
@@ -110,40 +151,40 @@ struct ByteAddressBuffer
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
         return *(const T*)(((const char*)data) + index);
     }
-    
+
     const uint32_t* data;
-    size_t sizeInBytes;  //< Must be multiple of 4
+    size_t sizeInBytes; //< Must be multiple of 4
 };
 
 // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-object-rwbyteaddressbuffer
-// Missing support for Atomic operations 
+// Missing support for Atomic operations
 // Missing support for Load with status
 struct RWByteAddressBuffer
 {
     void GetDimensions(uint32_t* outDim) const { *outDim = uint32_t(sizeInBytes); }
-    
-    uint32_t Load(size_t index) const 
-    { 
+
+    uint32_t Load(size_t index) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
-        return data[index >> 2]; 
+        return data[index >> 2];
     }
-    uint2 Load2(size_t index) const 
-    { 
+    uint2 Load2(size_t index) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
-        const size_t dataIdx = index >> 2; 
-        return uint2{data[dataIdx], data[dataIdx + 1]}; 
+        const size_t dataIdx = index >> 2;
+        return uint2{data[dataIdx], data[dataIdx + 1]};
     }
-    uint3 Load3(size_t index) const 
-    { 
+    uint3 Load3(size_t index) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
-        const size_t dataIdx = index >> 2; 
-        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]}; 
+        const size_t dataIdx = index >> 2;
+        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]};
     }
-    uint4 Load4(size_t index) const 
-    { 
+    uint4 Load4(size_t index) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
-        const size_t dataIdx = index >> 2; 
-        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]}; 
+        const size_t dataIdx = index >> 2;
+        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]};
     }
     template<typename T>
     T Load(size_t index) const
@@ -152,30 +193,30 @@ struct RWByteAddressBuffer
         return *(const T*)(((const char*)data) + index);
     }
 
-    void Store(size_t index, uint32_t v) const 
-    { 
+    void Store(size_t index, uint32_t v) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
-        data[index >> 2] = v; 
+        data[index >> 2] = v;
     }
-    void Store2(size_t index, uint2 v) const 
-    { 
+    void Store2(size_t index, uint2 v) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
-        const size_t dataIdx = index >> 2; 
+        const size_t dataIdx = index >> 2;
         data[dataIdx + 0] = v.x;
         data[dataIdx + 1] = v.y;
     }
-    void Store3(size_t index, uint3 v) const 
-    {  
+    void Store3(size_t index, uint3 v) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
-        const size_t dataIdx = index >> 2; 
+        const size_t dataIdx = index >> 2;
         data[dataIdx + 0] = v.x;
         data[dataIdx + 1] = v.y;
         data[dataIdx + 2] = v.z;
     }
-    void Store4(size_t index, uint4 v) const 
-    { 
+    void Store4(size_t index, uint4 v) const
+    {
         SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
-        const size_t dataIdx = index >> 2; 
+        const size_t dataIdx = index >> 2;
         data[dataIdx + 0] = v.x;
         data[dataIdx + 1] = v.y;
         data[dataIdx + 2] = v.z;
@@ -189,7 +230,7 @@ struct RWByteAddressBuffer
     }
 
     uint32_t* data;
-    size_t sizeInBytes; //< Must be multiple of 4 
+    size_t sizeInBytes; //< Must be multiple of 4
 };
 
 struct ISamplerState;
@@ -206,7 +247,7 @@ struct SamplerComparisonState
 };
 
 #ifndef SLANG_RESOURCE_SHAPE
-#    define SLANG_RESOURCE_SHAPE
+#define SLANG_RESOURCE_SHAPE
 typedef unsigned int SlangResourceShape;
 enum
 {
@@ -243,7 +284,7 @@ enum
 };
 #endif
 
-// 
+//
 struct TextureDimensions
 {
     void reset()
@@ -259,25 +300,25 @@ struct TextureDimensions
         int count = 0;
         switch (baseShape)
         {
-            case SLANG_TEXTURE_1D:
+        case SLANG_TEXTURE_1D:
             {
                 outDims[count++] = width;
                 break;
             }
-            case SLANG_TEXTURE_2D:
+        case SLANG_TEXTURE_2D:
             {
                 outDims[count++] = width;
                 outDims[count++] = height;
                 break;
             }
-            case SLANG_TEXTURE_3D:
+        case SLANG_TEXTURE_3D:
             {
                 outDims[count++] = width;
                 outDims[count++] = height;
                 outDims[count++] = depth;
                 break;
             }
-            case SLANG_TEXTURE_CUBE:
+        case SLANG_TEXTURE_CUBE:
             {
                 outDims[count++] = width;
                 outDims[count++] = height;
@@ -298,19 +339,19 @@ struct TextureDimensions
         int count = 0;
         switch (baseShape)
         {
-            case SLANG_TEXTURE_1D:
+        case SLANG_TEXTURE_1D:
             {
                 outDims[count++] = width;
                 break;
             }
-            case SLANG_TEXTURE_CUBE:
-            case SLANG_TEXTURE_2D:
+        case SLANG_TEXTURE_CUBE:
+        case SLANG_TEXTURE_2D:
             {
                 outDims[count++] = width;
                 outDims[count++] = height;
                 break;
             }
-            case SLANG_TEXTURE_3D:
+        case SLANG_TEXTURE_3D:
             {
                 outDims[count++] = width;
                 outDims[count++] = height;
@@ -345,97 +386,146 @@ struct TextureDimensions
     uint32_t shape;
     uint32_t width, height, depth;
     uint32_t numberOfLevels;
-    uint32_t arrayElementCount;                  ///< For array types, 0 otherwise
+    uint32_t arrayElementCount; ///< For array types, 0 otherwise
 };
 
 
-
-
-
 // Texture
 
 struct ITexture
 {
     virtual TextureDimensions GetDimensions(int mipLevel = -1) = 0;
     virtual void Load(const int32_t* v, void* outData, size_t dataSize) = 0;
-    virtual void Sample(SamplerState samplerState, const float* loc, void* outData, size_t dataSize) = 0;
-    virtual void SampleLevel(SamplerState samplerState, const float* loc, float level, void* outData, size_t dataSize) = 0;
+    virtual void Sample(
+        SamplerState samplerState,
+        const float* loc,
+        void* outData,
+        size_t dataSize) = 0;
+    virtual void SampleLevel(
+        SamplerState samplerState,
+        const float* loc,
+        float level,
+        void* outData,
+        size_t dataSize) = 0;
 };
 
-template <typename T>
+template<typename T>
 struct Texture1D
 {
     void GetDimensions(uint32_t* outWidth) { *outWidth = texture->GetDimensions().width; }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outNumberOfLevels) 
-    { 
-        auto dims = texture->GetDimensions(mipLevel); 
-        *outWidth = dims.width; 
-        *outNumberOfLevels = dims.numberOfLevels; 
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outNumberOfLevels = dims.numberOfLevels;
     }
-    
+
     void GetDimensions(float* outWidth) { *outWidth = texture->GetDimensions().width; }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outNumberOfLevels) 
-    { 
-        auto dims = texture->GetDimensions(mipLevel); 
-        *outWidth = dims.width; 
-        *outNumberOfLevels = dims.numberOfLevels; 
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+
+    T Load(const int2& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
     }
-    
-    T Load(const int2& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
-    T Sample(SamplerState samplerState, float loc) const { T out; texture->Sample(samplerState, &loc, &out, sizeof(out)); return out; }
-    T SampleLevel(SamplerState samplerState, float loc, float level) { T out; texture->SampleLevel(samplerState, &loc, level, &out, sizeof(out)); return out; }
-    
-    ITexture* texture;              
+    T Sample(SamplerState samplerState, float loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, float loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc, level, &out, sizeof(out));
+        return out;
+    }
+
+    ITexture* texture;
 };
 
-template <typename T>
+template<typename T>
 struct Texture2D
 {
-    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
-    { 
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight)
+    {
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outHeight = dims.height;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    void GetDimensions(float* outWidth, float* outHeight) 
-    { 
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+    void GetDimensions(float* outWidth, float* outHeight)
+    {
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outHeight = dims.height;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
-    T Sample(SamplerState samplerState, const float2& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
-    T SampleLevel(SamplerState samplerState, const float2& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
-    
-    ITexture* texture;              
+
+    T Load(const int3& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
+    T Sample(SamplerState samplerState, const float2& loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float2& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
+
+    ITexture* texture;
 };
 
-template <typename T>
+template<typename T>
 struct Texture3D
 {
     void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth)
     {
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
         *outDepth = dims.depth;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outDepth,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -445,12 +535,17 @@ struct Texture3D
     }
     void GetDimensions(float* outWidth, float* outHeight, float* outDepth)
     {
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
         *outDepth = dims.depth;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outDepth, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outDepth,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -458,78 +553,144 @@ struct Texture3D
         *outDepth = dims.depth;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    T Load(const int4& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
-    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
-    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
-    
-    ITexture* texture;              
+
+    T Load(const int4& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
+    T Sample(SamplerState samplerState, const float3& loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float3& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
+
+    ITexture* texture;
 };
 
-template <typename T>
+template<typename T>
 struct TextureCube
 {
-    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
-    { 
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight)
+    {
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outHeight = dims.height;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    void GetDimensions(float* outWidth, float* outHeight) 
-    { 
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+    void GetDimensions(float* outWidth, float* outHeight)
+    {
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outHeight = dims.height;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
-    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
-    
-    ITexture* texture;              
+
+    T Sample(SamplerState samplerState, const float3& loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float3& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
+
+    ITexture* texture;
 };
 
-template <typename T>
+template<typename T>
 struct Texture1DArray
 {
-    void GetDimensions(uint32_t* outWidth, uint32_t* outElements) { auto dims = texture->GetDimensions(); *outWidth = dims.width; *outElements = dims.arrayElementCount; }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outElements, uint32_t* outNumberOfLevels) 
+    void GetDimensions(uint32_t* outWidth, uint32_t* outElements)
     {
-        auto dims = texture->GetDimensions(mipLevel); 
-        *outWidth = dims.width; 
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outElements = dims.arrayElementCount;
+    }
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
         *outNumberOfLevels = dims.numberOfLevels;
-        *outElements = dims.arrayElementCount; 
-    }        
-    void GetDimensions(float* outWidth, float* outElements) { auto dims = texture->GetDimensions(); *outWidth = dims.width; *outElements = dims.arrayElementCount; }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outElements, float* outNumberOfLevels) 
+        *outElements = dims.arrayElementCount;
+    }
+    void GetDimensions(float* outWidth, float* outElements)
     {
-        auto dims = texture->GetDimensions(mipLevel); 
-        *outWidth = dims.width; 
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outElements = dims.arrayElementCount;
+    }
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outElements,
+        float* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
         *outNumberOfLevels = dims.numberOfLevels;
-        *outElements = dims.arrayElementCount; 
+        *outElements = dims.arrayElementCount;
+    }
+
+    T Load(const int3& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
+    T Sample(SamplerState samplerState, const float2& loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float2& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
     }
-    
-    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
-    T Sample(SamplerState samplerState, const float2& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
-    T SampleLevel(SamplerState samplerState, const float2& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
-    
-    ITexture* texture;              
+
+    ITexture* texture;
 };
 
-template <typename T>
+template<typename T>
 struct Texture2DArray
 {
     void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
@@ -539,7 +700,12 @@ struct Texture2DArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -547,7 +713,7 @@ struct Texture2DArray
         *outElements = dims.arrayElementCount;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
+
     void GetDimensions(uint32_t* outWidth, float* outHeight, float* outElements)
     {
         auto dims = texture->GetDimensions();
@@ -555,7 +721,12 @@ struct Texture2DArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -563,15 +734,30 @@ struct Texture2DArray
         *outElements = dims.arrayElementCount;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    T Load(const int4& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
-    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
-    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
-    
-    ITexture* texture;              
+
+    T Load(const int4& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
+    T Sample(SamplerState samplerState, const float3& loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float3& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
+
+    ITexture* texture;
 };
 
-template <typename T>
+template<typename T>
 struct TextureCubeArray
 {
     void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
@@ -581,7 +767,12 @@ struct TextureCubeArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -589,7 +780,7 @@ struct TextureCubeArray
         *outElements = dims.arrayElementCount;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
+
     void GetDimensions(uint32_t* outWidth, float* outHeight, float* outElements)
     {
         auto dims = texture->GetDimensions();
@@ -597,7 +788,12 @@ struct TextureCubeArray
         *outHeight = dims.height;
         *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -605,81 +801,124 @@ struct TextureCubeArray
         *outElements = dims.arrayElementCount;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    T Sample(SamplerState samplerState, const float4& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
-    T SampleLevel(SamplerState samplerState, const float4& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
-    
-    ITexture* texture;              
+
+    T Sample(SamplerState samplerState, const float4& loc) const
+    {
+        T out;
+        texture->Sample(samplerState, &loc.x, &out, sizeof(out));
+        return out;
+    }
+    T SampleLevel(SamplerState samplerState, const float4& loc, float level)
+    {
+        T out;
+        texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out));
+        return out;
+    }
+
+    ITexture* texture;
 };
 
 /* !!!!!!!!!!!!!!!!!!!!!!!!!!! RWTexture !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
 
 struct IRWTexture : ITexture
 {
-        /// Get the reference to the element at loc. 
+    /// Get the reference to the element at loc.
     virtual void* refAt(const uint32_t* loc) = 0;
 };
 
-template <typename T>
+template<typename T>
 struct RWTexture1D
 {
     void GetDimensions(uint32_t* outWidth) { *outWidth = texture->GetDimensions().width; }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outNumberOfLevels) { auto dims = texture->GetDimensions(mipLevel); *outWidth = dims.width; *outNumberOfLevels = dims.numberOfLevels; }
-    
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+
     void GetDimensions(float* outWidth) { *outWidth = texture->GetDimensions().width; }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outNumberOfLevels) { auto dims = texture->GetDimensions(mipLevel); *outWidth = dims.width; *outNumberOfLevels = dims.numberOfLevels; }
-    
-    T Load(int32_t loc) const { T out; texture->Load(&loc, &out, sizeof(out)); return out; }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+
+    T Load(int32_t loc) const
+    {
+        T out;
+        texture->Load(&loc, &out, sizeof(out));
+        return out;
+    }
     T& operator[](uint32_t loc) { return *(T*)texture->refAt(&loc); }
-    IRWTexture* texture;              
+    IRWTexture* texture;
 };
 
-template <typename T>
+template<typename T>
 struct RWTexture2D
 {
-    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
-    { 
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight)
+    {
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outHeight = dims.height;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    void GetDimensions(float* outWidth, float* outHeight) 
-    { 
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+    void GetDimensions(float* outWidth, float* outHeight)
+    {
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outHeight = dims.height;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    T Load(const int2& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+
+    T Load(const int2& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
     T& operator[](const uint2& loc) { return *(T*)texture->refAt(&loc.x); }
     IRWTexture* texture;
 };
 
-template <typename T>
+template<typename T>
 struct RWTexture3D
 {
     void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth)
     {
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
         *outDepth = dims.depth;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outDepth,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -689,12 +928,17 @@ struct RWTexture3D
     }
     void GetDimensions(float* outWidth, float* outHeight, float* outDepth)
     {
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
         *outDepth = dims.depth;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outDepth, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outDepth,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -702,60 +946,83 @@ struct RWTexture3D
         *outDepth = dims.depth;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+
+    T Load(const int3& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
     T& operator[](const uint3& loc) { return *(T*)texture->refAt(&loc.x); }
     IRWTexture* texture;
 };
 
 
-template <typename T>
+template<typename T>
 struct RWTexture1DArray
 {
-    void GetDimensions(uint32_t* outWidth, uint32_t* outElements) 
-    { 
-        auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outElements = dims.arrayElementCount; 
+    void GetDimensions(uint32_t* outWidth, uint32_t* outElements)
+    {
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outElements = dims.arrayElementCount;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    void GetDimensions(float* outWidth, float* outElements) 
-    { 
-        auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outElements = dims.arrayElementCount; 
+    void GetDimensions(float* outWidth, float* outElements)
+    {
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outElements, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outElements = dims.arrayElementCount;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    T Load(int2 loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+
+    T Load(int2 loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
     T& operator[](uint2 loc) { return *(T*)texture->refAt(&loc.x); }
 
     IRWTexture* texture;
 };
 
-template <typename T>
+template<typename T>
 struct RWTexture2DArray
 {
     void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
     {
-        auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
         *outHeight = dims.height;
-        *outElements = dims.arrayElementCount; 
+        *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -765,12 +1032,17 @@ struct RWTexture2DArray
     }
     void GetDimensions(float* outWidth, float* outHeight, float* outElements)
     {
-        auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
         *outHeight = dims.height;
-        *outElements = dims.arrayElementCount; 
+        *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -778,8 +1050,13 @@ struct RWTexture2DArray
         *outElements = dims.arrayElementCount;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+
+    T Load(const int3& loc) const
+    {
+        T out;
+        texture->Load(&loc.x, &out, sizeof(out));
+        return out;
+    }
     T& operator[](const uint3& loc) { return *(T*)texture->refAt(&loc.x); }
 
     IRWTexture* texture;
@@ -787,91 +1064,167 @@ struct RWTexture2DArray
 
 // FeedbackTexture
 
-struct FeedbackType {};
-struct SAMPLER_FEEDBACK_MIN_MIP : FeedbackType {};
-struct SAMPLER_FEEDBACK_MIP_REGION_USED : FeedbackType {};
+struct FeedbackType
+{
+};
+struct SAMPLER_FEEDBACK_MIN_MIP : FeedbackType
+{
+};
+struct SAMPLER_FEEDBACK_MIP_REGION_USED : FeedbackType
+{
+};
 
 struct IFeedbackTexture
 {
     virtual TextureDimensions GetDimensions(int mipLevel = -1) = 0;
 
-    // Note here we pass the optional clamp parameter as a pointer. Passing nullptr means no clamp. 
-    // This was preferred over having two function definitions, and having to differentiate their names
-    virtual void WriteSamplerFeedback(ITexture* tex, SamplerState samp, const float* location, const float* clamp = nullptr) = 0;
-    virtual void WriteSamplerFeedbackBias(ITexture* tex, SamplerState samp, const float* location, float bias, const float* clamp = nullptr) = 0;
-    virtual void WriteSamplerFeedbackGrad(ITexture* tex, SamplerState samp, const float* location, const float* ddx, const float* ddy, const float* clamp = nullptr) = 0;
-    
-    virtual void WriteSamplerFeedbackLevel(ITexture* tex, SamplerState samp, const float* location, float lod) = 0;
+    // Note here we pass the optional clamp parameter as a pointer. Passing nullptr means no clamp.
+    // This was preferred over having two function definitions, and having to differentiate their
+    // names
+    virtual void WriteSamplerFeedback(
+        ITexture* tex,
+        SamplerState samp,
+        const float* location,
+        const float* clamp = nullptr) = 0;
+    virtual void WriteSamplerFeedbackBias(
+        ITexture* tex,
+        SamplerState samp,
+        const float* location,
+        float bias,
+        const float* clamp = nullptr) = 0;
+    virtual void WriteSamplerFeedbackGrad(
+        ITexture* tex,
+        SamplerState samp,
+        const float* location,
+        const float* ddx,
+        const float* ddy,
+        const float* clamp = nullptr) = 0;
+
+    virtual void WriteSamplerFeedbackLevel(
+        ITexture* tex,
+        SamplerState samp,
+        const float* location,
+        float lod) = 0;
 };
 
-template <typename T>
+template<typename T>
 struct FeedbackTexture2D
 {
-    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
-    { 
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight)
+    {
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outHeight = dims.height;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    void GetDimensions(float* outWidth, float* outHeight) 
-    { 
-        const auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
-        *outHeight = dims.height; 
+    void GetDimensions(float* outWidth, float* outHeight)
+    {
+        const auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
         *outHeight = dims.height;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    template <typename S>
-    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location, float clamp) { texture->WriteSamplerFeedback(tex.texture, samp, &location.x, &clamp); } 
 
-    template <typename S>
-    void WriteSamplerFeedbackBias(Texture2D<S> tex, SamplerState samp, float2 location, float bias, float clamp) { texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias, &clamp); }
+    template<typename S>
+    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location, float clamp)
+    {
+        texture->WriteSamplerFeedback(tex.texture, samp, &location.x, &clamp);
+    }
 
-    template <typename S>
-    void WriteSamplerFeedbackGrad(Texture2D<S> tex, SamplerState samp, float2 location, float2 ddx, float2 ddy, float clamp) { texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp); }
+    template<typename S>
+    void WriteSamplerFeedbackBias(
+        Texture2D<S> tex,
+        SamplerState samp,
+        float2 location,
+        float bias,
+        float clamp)
+    {
+        texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias, &clamp);
+    }
+
+    template<typename S>
+    void WriteSamplerFeedbackGrad(
+        Texture2D<S> tex,
+        SamplerState samp,
+        float2 location,
+        float2 ddx,
+        float2 ddy,
+        float clamp)
+    {
+        texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp);
+    }
 
     // Level
 
-    template <typename S> 
-    void WriteSamplerFeedbackLevel(Texture2D<S> tex, SamplerState samp, float2 location, float lod) { texture->WriteSamplerFeedbackLevel(tex.texture, samp, &location.x, lod); }
-    
+    template<typename S>
+    void WriteSamplerFeedbackLevel(Texture2D<S> tex, SamplerState samp, float2 location, float lod)
+    {
+        texture->WriteSamplerFeedbackLevel(tex.texture, samp, &location.x, lod);
+    }
+
     // Without Clamp
-    template <typename S> 
-    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location) { texture->WriteSamplerFeedback(tex.texture, samp, &location.x); }
+    template<typename S>
+    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location)
+    {
+        texture->WriteSamplerFeedback(tex.texture, samp, &location.x);
+    }
+
+    template<typename S>
+    void WriteSamplerFeedbackBias(Texture2D<S> tex, SamplerState samp, float2 location, float bias)
+    {
+        texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias);
+    }
 
-    template <typename S> 
-    void WriteSamplerFeedbackBias(Texture2D<S> tex, SamplerState samp, float2 location, float bias) { texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias); }
+    template<typename S>
+    void WriteSamplerFeedbackGrad(
+        Texture2D<S> tex,
+        SamplerState samp,
+        float2 location,
+        float2 ddx,
+        float2 ddy)
+    {
+        texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x);
+    }
 
-    template <typename S> 
-    void WriteSamplerFeedbackGrad(Texture2D<S> tex, SamplerState samp, float2 location, float2 ddx, float2 ddy) { texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x); }
-    
     IFeedbackTexture* texture;
 };
 
-template <typename T>
+template<typename T>
 struct FeedbackTexture2DArray
 {
     void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
     {
-        auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
         *outHeight = dims.height;
-        *outElements = dims.arrayElementCount; 
+        *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        uint32_t* outWidth,
+        uint32_t* outHeight,
+        uint32_t* outElements,
+        uint32_t* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -881,12 +1234,17 @@ struct FeedbackTexture2DArray
     }
     void GetDimensions(float* outWidth, float* outHeight, float* outElements)
     {
-        auto dims = texture->GetDimensions(); 
-        *outWidth = dims.width; 
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
         *outHeight = dims.height;
-        *outElements = dims.arrayElementCount; 
+        *outElements = dims.arrayElementCount;
     }
-    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    void GetDimensions(
+        uint32_t mipLevel,
+        float* outWidth,
+        float* outHeight,
+        float* outElements,
+        float* outNumberOfLevels)
     {
         const auto dims = texture->GetDimensions(mipLevel);
         *outWidth = dims.width;
@@ -894,31 +1252,81 @@ struct FeedbackTexture2DArray
         *outElements = dims.arrayElementCount;
         *outNumberOfLevels = dims.numberOfLevels;
     }
-    
-    template <typename S>
-    void WriteSamplerFeedback(Texture2DArray<S> texArray, SamplerState samp, float3 location, float clamp) { texture->WriteSamplerFeedback(texArray.texture, samp, &location.x, &clamp); }
 
-    template <typename S>
-    void WriteSamplerFeedbackBias(Texture2DArray<S> texArray, SamplerState samp, float3 location, float bias, float clamp) { texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias, &clamp); }
+    template<typename S>
+    void WriteSamplerFeedback(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float clamp)
+    {
+        texture->WriteSamplerFeedback(texArray.texture, samp, &location.x, &clamp);
+    }
+
+    template<typename S>
+    void WriteSamplerFeedbackBias(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float bias,
+        float clamp)
+    {
+        texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias, &clamp);
+    }
 
-    template <typename S>
-    void WriteSamplerFeedbackGrad(Texture2DArray<S> texArray, SamplerState samp, float3 location, float3 ddx, float3 ddy, float clamp) { texture->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp); }
+    template<typename S>
+    void WriteSamplerFeedbackGrad(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float3 ddx,
+        float3 ddy,
+        float clamp)
+    {
+        texture
+            ->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp);
+    }
 
     // Level
-    template <typename S>
-    void WriteSamplerFeedbackLevel(Texture2DArray<S> texArray, SamplerState samp, float3 location, float lod) { texture->WriteSamplerFeedbackLevel(texArray.texture, samp, &location.x, lod); }
+    template<typename S>
+    void WriteSamplerFeedbackLevel(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float lod)
+    {
+        texture->WriteSamplerFeedbackLevel(texArray.texture, samp, &location.x, lod);
+    }
 
     // Without Clamp
 
-    template <typename S>
-    void WriteSamplerFeedback(Texture2DArray<S> texArray, SamplerState samp, float3 location) { texture->WriteSamplerFeedback(texArray.texture, samp, &location.x); }
+    template<typename S>
+    void WriteSamplerFeedback(Texture2DArray<S> texArray, SamplerState samp, float3 location)
+    {
+        texture->WriteSamplerFeedback(texArray.texture, samp, &location.x);
+    }
 
-    template <typename S>
-    void WriteSamplerFeedbackBias(Texture2DArray<S> texArray, SamplerState samp, float3 location, float bias) { texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias); }
+    template<typename S>
+    void WriteSamplerFeedbackBias(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float bias)
+    {
+        texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias);
+    }
+
+    template<typename S>
+    void WriteSamplerFeedbackGrad(
+        Texture2DArray<S> texArray,
+        SamplerState samp,
+        float3 location,
+        float3 ddx,
+        float3 ddy)
+    {
+        texture->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x);
+    }
 
-    template <typename S>
-    void WriteSamplerFeedbackGrad(Texture2DArray<S> texArray, SamplerState samp, float3 location, float3 ddx, float3 ddy) { texture->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x); }
-    
     IFeedbackTexture* texture;
 };
 
@@ -933,20 +1341,24 @@ struct ComputeThreadVaryingInput
 
 struct ComputeVaryingInput
 {
-    uint3 startGroupID;     ///< start groupID
-    uint3 endGroupID;       ///< Non inclusive end groupID
+    uint3 startGroupID; ///< start groupID
+    uint3 endGroupID;   ///< Non inclusive end groupID
 };
 
-// The uniformEntryPointParams and uniformState must be set to structures that match layout that the kernel expects.
-// This can be determined via reflection for example.
+// The uniformEntryPointParams and uniformState must be set to structures that match layout that the
+// kernel expects. This can be determined via reflection for example.
 
-typedef void(*ComputeThreadFunc)(ComputeThreadVaryingInput* varyingInput, void* uniformEntryPointParams, void* uniformState);
-typedef void(*ComputeFunc)(ComputeVaryingInput* varyingInput, void* uniformEntryPointParams, void* uniformState);
+typedef void (*ComputeThreadFunc)(
+    ComputeThreadVaryingInput* varyingInput,
+    void* uniformEntryPointParams,
+    void* uniformState);
+typedef void (*ComputeFunc)(
+    ComputeVaryingInput* varyingInput,
+    void* uniformEntryPointParams,
+    void* uniformState);
 
 #ifdef SLANG_PRELUDE_NAMESPACE
 }
 #endif
 
 #endif
-
-