format

* format

* Minor test fixes

* enable checking cpp format in ci

3 files changed, 439 insertions, 489 deletions

diff --git a/tools/gfx/d3d/d3d-swapchain.h b/tools/gfx/d3d/d3d-swapchain.h
index c9e0de82a..49a4f1c99 100644
--- a/tools/gfx/d3d/d3d-swapchain.h
+++ b/tools/gfx/d3d/d3d-swapchain.h
@@ -1,16 +1,15 @@
 #pragma once
 
-#include "slang-gfx.h"
-#include "core/slang-basic.h"
-#include <dxgi1_4.h>
 #include "../renderer-shared.h"
+#include "core/slang-basic.h"
 #include "d3d-util.h"
+#include "slang-gfx.h"
+
+#include <dxgi1_4.h>
 
 namespace gfx
 {
-class D3DSwapchainBase
-    : public ISwapchain
-    , public Slang::ComObject
+class D3DSwapchainBase : public ISwapchain, public Slang::ComObject
 {
 public:
     SLANG_COM_OBJECT_IUNKNOWN_ALL
@@ -27,10 +26,8 @@ public:
         // Return fail on non-supported platforms.
         switch (window.type)
         {
-        case WindowHandle::Type::Win32Handle:
-            break;
-        default:
-            return SLANG_FAIL;
+        case WindowHandle::Type::Win32Handle: break;
+        default:                              return SLANG_FAIL;
         }
 
         m_desc = desc;
@@ -60,9 +57,12 @@ public:
         {
             ComPtr<IDXGISwapChain> swapChain;
             SLANG_RETURN_ON_FAIL(getDXGIFactory()->CreateSwapChain(
-                getOwningDevice(), &swapChainDesc, swapChain.writeRef()));
+                getOwningDevice(),
+                &swapChainDesc,
+                swapChain.writeRef()));
             SLANG_RETURN_ON_FAIL(getDXGIFactory()->MakeWindowAssociation(
-                (HWND)window.handleValues[0], DXGI_MWA_NO_ALT_ENTER));
+                (HWND)window.handleValues[0],
+                DXGI_MWA_NO_ALT_ENTER));
             SLANG_RETURN_ON_FAIL(swapChain->QueryInterface(m_swapChain.writeRef()));
         }
         else
@@ -92,7 +92,7 @@ public:
     }
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override { return m_desc; }
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getImage(GfxIndex index, ITextureResource** outResource) override
+    getImage(GfxIndex index, ITextureResource** outResource) override
     {
         returnComPtr(outResource, m_images[index]);
         return SLANG_OK;
@@ -126,17 +126,17 @@ public:
     {
         if (width == m_desc.width && height == m_desc.height)
             return SLANG_OK;
-        
+
         m_desc.width = width;
         m_desc.height = height;
         for (auto& image : m_images)
             image = nullptr;
         m_images.clear();
         auto result = m_swapChain->ResizeBuffers(
-                m_desc.imageCount,
-                width,
-                height,
-                D3DUtil::getMapFormat(m_desc.format),
+            m_desc.imageCount,
+            width,
+            height,
+            D3DUtil::getMapFormat(m_desc.format),
             m_desc.enableVSync ? 0 : DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT);
         if (result != 0)
             return SLANG_FAIL;
@@ -153,4 +153,4 @@ public:
     Slang::ShortList<Slang::RefPtr<TextureResource>> m_images;
 };
 
-}
+} // namespace gfx
diff --git a/tools/gfx/d3d/d3d-util.cpp b/tools/gfx/d3d/d3d-util.cpp
index 8d76c74b3..9d32f8532 100644
--- a/tools/gfx/d3d/d3d-util.cpp
+++ b/tools/gfx/d3d/d3d-util.cpp
@@ -9,37 +9,32 @@
 #endif
 
 // We will use the C standard library just for printing error messages.
-#include <stdio.h>
-
 #include "core/slang-basic.h"
 #include "core/slang-platform.h"
 
-#ifdef GFX_NV_AFTERMATH
-#   include "GFSDK_Aftermath.h"
-#   include "GFSDK_Aftermath_Defines.h"
-#   include "GFSDK_Aftermath_GpuCrashDump.h"
+#include <stdio.h>
 
-#   include "core/slang-process.h"
+#ifdef GFX_NV_AFTERMATH
+#include "GFSDK_Aftermath.h"
+#include "GFSDK_Aftermath_Defines.h"
+#include "GFSDK_Aftermath_GpuCrashDump.h"
+#include "core/slang-process.h"
 #endif
 
-namespace gfx {
+namespace gfx
+{
 using namespace Slang;
 
-/* static */D3D_PRIMITIVE_TOPOLOGY D3DUtil::getPrimitiveTopology(PrimitiveTopology topology)
+/* static */ D3D_PRIMITIVE_TOPOLOGY D3DUtil::getPrimitiveTopology(PrimitiveTopology topology)
 {
     switch (topology)
     {
-        case PrimitiveTopology::TriangleList:
-            return D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
-        case PrimitiveTopology::TriangleStrip:
-            return D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
-        case PrimitiveTopology::LineList:
-            return D3D_PRIMITIVE_TOPOLOGY_LINELIST;
-        case PrimitiveTopology::LineStrip:
-            return D3D_PRIMITIVE_TOPOLOGY_LINESTRIP;
-        case PrimitiveTopology::PointList:
-            return D3D_PRIMITIVE_TOPOLOGY_POINTLIST;
-        default: break;
+    case PrimitiveTopology::TriangleList:  return D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
+    case PrimitiveTopology::TriangleStrip: return D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
+    case PrimitiveTopology::LineList:      return D3D_PRIMITIVE_TOPOLOGY_LINELIST;
+    case PrimitiveTopology::LineStrip:     return D3D_PRIMITIVE_TOPOLOGY_LINESTRIP;
+    case PrimitiveTopology::PointList:     return D3D_PRIMITIVE_TOPOLOGY_POINTLIST;
+    default:                               break;
     }
     return D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
 }
@@ -49,15 +44,11 @@ D3D12_PRIMITIVE_TOPOLOGY_TYPE D3DUtil::getPrimitiveType(PrimitiveTopology topolo
     switch (topology)
     {
     case PrimitiveTopology::TriangleList:
-    case PrimitiveTopology::TriangleStrip:
-        return D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
+    case PrimitiveTopology::TriangleStrip: return D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
     case PrimitiveTopology::LineList:
-    case PrimitiveTopology::LineStrip:
-        return D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE;
-    case PrimitiveTopology::PointList:
-        return D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT;
-    default:
-        break;
+    case PrimitiveTopology::LineStrip:     return D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE;
+    case PrimitiveTopology::PointList:     return D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT;
+    default:                               break;
     }
     return D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED;
 }
@@ -66,16 +57,11 @@ D3D12_PRIMITIVE_TOPOLOGY_TYPE D3DUtil::getPrimitiveType(PrimitiveType type)
 {
     switch (type)
     {
-    case PrimitiveType::Point:
-        return D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT;
-    case PrimitiveType::Line:
-        return D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE;
-    case PrimitiveType::Triangle:
-        return D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
-    case PrimitiveType::Patch:
-        return D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH;
-    default:
-        break;
+    case PrimitiveType::Point:    return D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT;
+    case PrimitiveType::Line:     return D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE;
+    case PrimitiveType::Triangle: return D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
+    case PrimitiveType::Patch:    return D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH;
+    default:                      break;
     }
     return D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED;
 }
@@ -84,24 +70,15 @@ D3D12_COMPARISON_FUNC D3DUtil::getComparisonFunc(ComparisonFunc func)
 {
     switch (func)
     {
-    case gfx::ComparisonFunc::Never:
-        return D3D12_COMPARISON_FUNC_NEVER;
-    case gfx::ComparisonFunc::Less:
-        return D3D12_COMPARISON_FUNC_LESS;
-    case gfx::ComparisonFunc::Equal:
-        return D3D12_COMPARISON_FUNC_EQUAL;
-    case gfx::ComparisonFunc::LessEqual:
-        return D3D12_COMPARISON_FUNC_LESS_EQUAL;
-    case gfx::ComparisonFunc::Greater:
-        return D3D12_COMPARISON_FUNC_GREATER;
-    case gfx::ComparisonFunc::NotEqual:
-        return D3D12_COMPARISON_FUNC_NOT_EQUAL;
-    case gfx::ComparisonFunc::GreaterEqual:
-        return D3D12_COMPARISON_FUNC_GREATER_EQUAL;
-    case gfx::ComparisonFunc::Always:
-        return D3D12_COMPARISON_FUNC_ALWAYS;
-    default:
-        return D3D12_COMPARISON_FUNC_NEVER;
+    case gfx::ComparisonFunc::Never:        return D3D12_COMPARISON_FUNC_NEVER;
+    case gfx::ComparisonFunc::Less:         return D3D12_COMPARISON_FUNC_LESS;
+    case gfx::ComparisonFunc::Equal:        return D3D12_COMPARISON_FUNC_EQUAL;
+    case gfx::ComparisonFunc::LessEqual:    return D3D12_COMPARISON_FUNC_LESS_EQUAL;
+    case gfx::ComparisonFunc::Greater:      return D3D12_COMPARISON_FUNC_GREATER;
+    case gfx::ComparisonFunc::NotEqual:     return D3D12_COMPARISON_FUNC_NOT_EQUAL;
+    case gfx::ComparisonFunc::GreaterEqual: return D3D12_COMPARISON_FUNC_GREATER_EQUAL;
+    case gfx::ComparisonFunc::Always:       return D3D12_COMPARISON_FUNC_ALWAYS;
+    default:                                return D3D12_COMPARISON_FUNC_NEVER;
     }
 }
 
@@ -109,24 +86,15 @@ static D3D12_STENCIL_OP translateStencilOp(StencilOp op)
 {
     switch (op)
     {
-    case gfx::StencilOp::Keep:
-        return D3D12_STENCIL_OP_KEEP;
-    case gfx::StencilOp::Zero:
-        return D3D12_STENCIL_OP_ZERO;
-    case gfx::StencilOp::Replace:
-        return D3D12_STENCIL_OP_REPLACE;
-    case gfx::StencilOp::IncrementSaturate:
-        return D3D12_STENCIL_OP_INCR_SAT;
-    case gfx::StencilOp::DecrementSaturate:
-        return D3D12_STENCIL_OP_DECR_SAT;
-    case gfx::StencilOp::Invert:
-        return D3D12_STENCIL_OP_INVERT;
-    case gfx::StencilOp::IncrementWrap:
-        return D3D12_STENCIL_OP_INCR;
-    case gfx::StencilOp::DecrementWrap:
-        return D3D12_STENCIL_OP_DECR;
-    default:
-        return D3D12_STENCIL_OP_KEEP;
+    case gfx::StencilOp::Keep:              return D3D12_STENCIL_OP_KEEP;
+    case gfx::StencilOp::Zero:              return D3D12_STENCIL_OP_ZERO;
+    case gfx::StencilOp::Replace:           return D3D12_STENCIL_OP_REPLACE;
+    case gfx::StencilOp::IncrementSaturate: return D3D12_STENCIL_OP_INCR_SAT;
+    case gfx::StencilOp::DecrementSaturate: return D3D12_STENCIL_OP_DECR_SAT;
+    case gfx::StencilOp::Invert:            return D3D12_STENCIL_OP_INVERT;
+    case gfx::StencilOp::IncrementWrap:     return D3D12_STENCIL_OP_INCR;
+    case gfx::StencilOp::DecrementWrap:     return D3D12_STENCIL_OP_DECR;
+    default:                                return D3D12_STENCIL_OP_KEEP;
     }
 }
 
@@ -140,188 +108,189 @@ D3D12_DEPTH_STENCILOP_DESC D3DUtil::translateStencilOpDesc(DepthStencilOpDesc de
     return rs;
 }
 
-/* static */DXGI_FORMAT D3DUtil::getMapFormat(Format format)
+/* static */ DXGI_FORMAT D3DUtil::getMapFormat(Format format)
 {
     switch (format)
     {
-        case Format::R32G32B32A32_TYPELESS:     return DXGI_FORMAT_R32G32B32A32_TYPELESS;
-        case Format::R32G32B32_TYPELESS:        return DXGI_FORMAT_R32G32B32_TYPELESS;
-        case Format::R32G32_TYPELESS:           return DXGI_FORMAT_R32G32_TYPELESS;
-        case Format::R32_TYPELESS:              return DXGI_FORMAT_R32_TYPELESS;
-
-        case Format::R16G16B16A16_TYPELESS:     return DXGI_FORMAT_R16G16B16A16_TYPELESS;
-        case Format::R16G16_TYPELESS:           return DXGI_FORMAT_R16G16_TYPELESS;
-        case Format::R16_TYPELESS:              return DXGI_FORMAT_R16_TYPELESS;
-
-        case Format::R8G8B8A8_TYPELESS:         return DXGI_FORMAT_R8G8B8A8_TYPELESS;
-        case Format::R8G8_TYPELESS:             return DXGI_FORMAT_R8G8_TYPELESS;
-        case Format::R8_TYPELESS:               return DXGI_FORMAT_R8_TYPELESS;
-        case Format::B8G8R8A8_TYPELESS:         return DXGI_FORMAT_B8G8R8A8_TYPELESS;
-
-        case Format::R32G32B32A32_FLOAT:        return DXGI_FORMAT_R32G32B32A32_FLOAT;
-        case Format::R32G32B32_FLOAT:           return DXGI_FORMAT_R32G32B32_FLOAT;
-        case Format::R32G32_FLOAT:              return DXGI_FORMAT_R32G32_FLOAT;
-        case Format::R32_FLOAT:                 return DXGI_FORMAT_R32_FLOAT;
-
-        case Format::R16G16B16A16_FLOAT:        return DXGI_FORMAT_R16G16B16A16_FLOAT;
-        case Format::R16G16_FLOAT:              return DXGI_FORMAT_R16G16_FLOAT;
-        case Format::R16_FLOAT:                 return DXGI_FORMAT_R16_FLOAT;
-
-        case Format::R64_UINT:                  return DXGI_FORMAT_R32G32_UINT;
-
-        case Format::R32G32B32A32_UINT:         return DXGI_FORMAT_R32G32B32A32_UINT;
-        case Format::R32G32B32_UINT:            return DXGI_FORMAT_R32G32B32_UINT;
-        case Format::R32G32_UINT:               return DXGI_FORMAT_R32G32_UINT;
-        case Format::R32_UINT:                  return DXGI_FORMAT_R32_UINT;
-
-        case Format::R16G16B16A16_UINT:         return DXGI_FORMAT_R16G16B16A16_UINT;
-        case Format::R16G16_UINT:               return DXGI_FORMAT_R16G16_UINT;
-        case Format::R16_UINT:                  return DXGI_FORMAT_R16_UINT;
-
-        case Format::R8G8B8A8_UINT:             return DXGI_FORMAT_R8G8B8A8_UINT;
-        case Format::R8G8_UINT:                 return DXGI_FORMAT_R8G8_UINT;
-        case Format::R8_UINT:                   return DXGI_FORMAT_R8_UINT;
-
-        case Format::R64_SINT:                  return DXGI_FORMAT_R32G32_SINT;
-
-        case Format::R32G32B32A32_SINT:         return DXGI_FORMAT_R32G32B32A32_SINT;
-        case Format::R32G32B32_SINT:            return DXGI_FORMAT_R32G32B32_SINT;
-        case Format::R32G32_SINT:               return DXGI_FORMAT_R32G32_SINT;
-        case Format::R32_SINT:                  return DXGI_FORMAT_R32_SINT;
-
-        case Format::R16G16B16A16_SINT:         return DXGI_FORMAT_R16G16B16A16_SINT;
-        case Format::R16G16_SINT:               return DXGI_FORMAT_R16G16_SINT;
-        case Format::R16_SINT:                  return DXGI_FORMAT_R16_SINT;
-
-        case Format::R8G8B8A8_SINT:             return DXGI_FORMAT_R8G8B8A8_SINT;
-        case Format::R8G8_SINT:                 return DXGI_FORMAT_R8G8_SINT;
-        case Format::R8_SINT:                   return DXGI_FORMAT_R8_SINT;
-
-        case Format::R16G16B16A16_UNORM:        return DXGI_FORMAT_R16G16B16A16_UNORM;
-        case Format::R16G16_UNORM:              return DXGI_FORMAT_R16G16_UNORM;
-        case Format::R16_UNORM:                 return DXGI_FORMAT_R16_UNORM;
-
-        case Format::R8G8B8A8_UNORM:            return DXGI_FORMAT_R8G8B8A8_UNORM;
-        case Format::R8G8B8A8_UNORM_SRGB:       return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
-        case Format::R8G8_UNORM:                return DXGI_FORMAT_R8G8_UNORM;
-        case Format::R8_UNORM:                  return DXGI_FORMAT_R8_UNORM;
-        case Format::B8G8R8A8_UNORM:            return DXGI_FORMAT_B8G8R8A8_UNORM;
-        case Format::B8G8R8X8_UNORM:            return DXGI_FORMAT_B8G8R8X8_UNORM;
-        case Format::B8G8R8A8_UNORM_SRGB:       return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
-        case Format::B8G8R8X8_UNORM_SRGB:       return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
-
-        case Format::R16G16B16A16_SNORM:        return DXGI_FORMAT_R16G16B16A16_SNORM;
-        case Format::R16G16_SNORM:              return DXGI_FORMAT_R16G16_SNORM;
-        case Format::R16_SNORM:                 return DXGI_FORMAT_R16_SNORM;
-
-        case Format::R8G8B8A8_SNORM:            return DXGI_FORMAT_R8G8B8A8_SNORM;
-        case Format::R8G8_SNORM:                return DXGI_FORMAT_R8G8_SNORM;
-        case Format::R8_SNORM:                  return DXGI_FORMAT_R8_SNORM;
-
-        case Format::D32_FLOAT:                 return DXGI_FORMAT_D32_FLOAT;
-        case Format::D16_UNORM:                 return DXGI_FORMAT_D16_UNORM;
-        case Format::D32_FLOAT_S8_UINT:         return DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
-        case Format::R32_FLOAT_X32_TYPELESS:    return DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS;
-
-        case Format::B4G4R4A4_UNORM:            return DXGI_FORMAT_B4G4R4A4_UNORM;
-        case Format::B5G6R5_UNORM:              return DXGI_FORMAT_B5G6R5_UNORM;
-        case Format::B5G5R5A1_UNORM:            return DXGI_FORMAT_B5G5R5A1_UNORM;
-
-        case Format::R9G9B9E5_SHAREDEXP:        return DXGI_FORMAT_R9G9B9E5_SHAREDEXP;
-        case Format::R10G10B10A2_TYPELESS:      return DXGI_FORMAT_R10G10B10A2_TYPELESS;
-        case Format::R10G10B10A2_UINT:          return DXGI_FORMAT_R10G10B10A2_UINT;
-        case Format::R10G10B10A2_UNORM:         return DXGI_FORMAT_R10G10B10A2_UNORM;
-        case Format::R11G11B10_FLOAT:           return DXGI_FORMAT_R11G11B10_FLOAT;
-
-        case Format::BC1_UNORM:                 return DXGI_FORMAT_BC1_UNORM;
-        case Format::BC1_UNORM_SRGB:            return DXGI_FORMAT_BC1_UNORM_SRGB;
-        case Format::BC2_UNORM:                 return DXGI_FORMAT_BC2_UNORM;
-        case Format::BC2_UNORM_SRGB:            return DXGI_FORMAT_BC2_UNORM_SRGB;
-        case Format::BC3_UNORM:                 return DXGI_FORMAT_BC3_UNORM;
-        case Format::BC3_UNORM_SRGB:            return DXGI_FORMAT_BC3_UNORM_SRGB;
-        case Format::BC4_UNORM:                 return DXGI_FORMAT_BC4_UNORM;
-        case Format::BC4_SNORM:                 return DXGI_FORMAT_BC4_SNORM;
-        case Format::BC5_UNORM:                 return DXGI_FORMAT_BC5_UNORM;
-        case Format::BC5_SNORM:                 return DXGI_FORMAT_BC5_SNORM;
-        case Format::BC6H_UF16:                 return DXGI_FORMAT_BC6H_UF16;
-        case Format::BC6H_SF16:                 return DXGI_FORMAT_BC6H_SF16;
-        case Format::BC7_UNORM:                 return DXGI_FORMAT_BC7_UNORM;
-        case Format::BC7_UNORM_SRGB:            return DXGI_FORMAT_BC7_UNORM_SRGB;
-
-        default:                                return DXGI_FORMAT_UNKNOWN;
-    }
-}
-
-/* static */DXGI_FORMAT D3DUtil::calcResourceFormat(UsageType usage, Int usageFlags, DXGI_FORMAT format)
+    case Format::R32G32B32A32_TYPELESS: return DXGI_FORMAT_R32G32B32A32_TYPELESS;
+    case Format::R32G32B32_TYPELESS:    return DXGI_FORMAT_R32G32B32_TYPELESS;
+    case Format::R32G32_TYPELESS:       return DXGI_FORMAT_R32G32_TYPELESS;
+    case Format::R32_TYPELESS:          return DXGI_FORMAT_R32_TYPELESS;
+
+    case Format::R16G16B16A16_TYPELESS: return DXGI_FORMAT_R16G16B16A16_TYPELESS;
+    case Format::R16G16_TYPELESS:       return DXGI_FORMAT_R16G16_TYPELESS;
+    case Format::R16_TYPELESS:          return DXGI_FORMAT_R16_TYPELESS;
+
+    case Format::R8G8B8A8_TYPELESS: return DXGI_FORMAT_R8G8B8A8_TYPELESS;
+    case Format::R8G8_TYPELESS:     return DXGI_FORMAT_R8G8_TYPELESS;
+    case Format::R8_TYPELESS:       return DXGI_FORMAT_R8_TYPELESS;
+    case Format::B8G8R8A8_TYPELESS: return DXGI_FORMAT_B8G8R8A8_TYPELESS;
+
+    case Format::R32G32B32A32_FLOAT: return DXGI_FORMAT_R32G32B32A32_FLOAT;
+    case Format::R32G32B32_FLOAT:    return DXGI_FORMAT_R32G32B32_FLOAT;
+    case Format::R32G32_FLOAT:       return DXGI_FORMAT_R32G32_FLOAT;
+    case Format::R32_FLOAT:          return DXGI_FORMAT_R32_FLOAT;
+
+    case Format::R16G16B16A16_FLOAT: return DXGI_FORMAT_R16G16B16A16_FLOAT;
+    case Format::R16G16_FLOAT:       return DXGI_FORMAT_R16G16_FLOAT;
+    case Format::R16_FLOAT:          return DXGI_FORMAT_R16_FLOAT;
+
+    case Format::R64_UINT: return DXGI_FORMAT_R32G32_UINT;
+
+    case Format::R32G32B32A32_UINT: return DXGI_FORMAT_R32G32B32A32_UINT;
+    case Format::R32G32B32_UINT:    return DXGI_FORMAT_R32G32B32_UINT;
+    case Format::R32G32_UINT:       return DXGI_FORMAT_R32G32_UINT;
+    case Format::R32_UINT:          return DXGI_FORMAT_R32_UINT;
+
+    case Format::R16G16B16A16_UINT: return DXGI_FORMAT_R16G16B16A16_UINT;
+    case Format::R16G16_UINT:       return DXGI_FORMAT_R16G16_UINT;
+    case Format::R16_UINT:          return DXGI_FORMAT_R16_UINT;
+
+    case Format::R8G8B8A8_UINT: return DXGI_FORMAT_R8G8B8A8_UINT;
+    case Format::R8G8_UINT:     return DXGI_FORMAT_R8G8_UINT;
+    case Format::R8_UINT:       return DXGI_FORMAT_R8_UINT;
+
+    case Format::R64_SINT: return DXGI_FORMAT_R32G32_SINT;
+
+    case Format::R32G32B32A32_SINT: return DXGI_FORMAT_R32G32B32A32_SINT;
+    case Format::R32G32B32_SINT:    return DXGI_FORMAT_R32G32B32_SINT;
+    case Format::R32G32_SINT:       return DXGI_FORMAT_R32G32_SINT;
+    case Format::R32_SINT:          return DXGI_FORMAT_R32_SINT;
+
+    case Format::R16G16B16A16_SINT: return DXGI_FORMAT_R16G16B16A16_SINT;
+    case Format::R16G16_SINT:       return DXGI_FORMAT_R16G16_SINT;
+    case Format::R16_SINT:          return DXGI_FORMAT_R16_SINT;
+
+    case Format::R8G8B8A8_SINT: return DXGI_FORMAT_R8G8B8A8_SINT;
+    case Format::R8G8_SINT:     return DXGI_FORMAT_R8G8_SINT;
+    case Format::R8_SINT:       return DXGI_FORMAT_R8_SINT;
+
+    case Format::R16G16B16A16_UNORM: return DXGI_FORMAT_R16G16B16A16_UNORM;
+    case Format::R16G16_UNORM:       return DXGI_FORMAT_R16G16_UNORM;
+    case Format::R16_UNORM:          return DXGI_FORMAT_R16_UNORM;
+
+    case Format::R8G8B8A8_UNORM:      return DXGI_FORMAT_R8G8B8A8_UNORM;
+    case Format::R8G8B8A8_UNORM_SRGB: return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
+    case Format::R8G8_UNORM:          return DXGI_FORMAT_R8G8_UNORM;
+    case Format::R8_UNORM:            return DXGI_FORMAT_R8_UNORM;
+    case Format::B8G8R8A8_UNORM:      return DXGI_FORMAT_B8G8R8A8_UNORM;
+    case Format::B8G8R8X8_UNORM:      return DXGI_FORMAT_B8G8R8X8_UNORM;
+    case Format::B8G8R8A8_UNORM_SRGB: return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
+    case Format::B8G8R8X8_UNORM_SRGB: return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
+
+    case Format::R16G16B16A16_SNORM: return DXGI_FORMAT_R16G16B16A16_SNORM;
+    case Format::R16G16_SNORM:       return DXGI_FORMAT_R16G16_SNORM;
+    case Format::R16_SNORM:          return DXGI_FORMAT_R16_SNORM;
+
+    case Format::R8G8B8A8_SNORM: return DXGI_FORMAT_R8G8B8A8_SNORM;
+    case Format::R8G8_SNORM:     return DXGI_FORMAT_R8G8_SNORM;
+    case Format::R8_SNORM:       return DXGI_FORMAT_R8_SNORM;
+
+    case Format::D32_FLOAT:              return DXGI_FORMAT_D32_FLOAT;
+    case Format::D16_UNORM:              return DXGI_FORMAT_D16_UNORM;
+    case Format::D32_FLOAT_S8_UINT:      return DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
+    case Format::R32_FLOAT_X32_TYPELESS: return DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS;
+
+    case Format::B4G4R4A4_UNORM: return DXGI_FORMAT_B4G4R4A4_UNORM;
+    case Format::B5G6R5_UNORM:   return DXGI_FORMAT_B5G6R5_UNORM;
+    case Format::B5G5R5A1_UNORM: return DXGI_FORMAT_B5G5R5A1_UNORM;
+
+    case Format::R9G9B9E5_SHAREDEXP:   return DXGI_FORMAT_R9G9B9E5_SHAREDEXP;
+    case Format::R10G10B10A2_TYPELESS: return DXGI_FORMAT_R10G10B10A2_TYPELESS;
+    case Format::R10G10B10A2_UINT:     return DXGI_FORMAT_R10G10B10A2_UINT;
+    case Format::R10G10B10A2_UNORM:    return DXGI_FORMAT_R10G10B10A2_UNORM;
+    case Format::R11G11B10_FLOAT:      return DXGI_FORMAT_R11G11B10_FLOAT;
+
+    case Format::BC1_UNORM:      return DXGI_FORMAT_BC1_UNORM;
+    case Format::BC1_UNORM_SRGB: return DXGI_FORMAT_BC1_UNORM_SRGB;
+    case Format::BC2_UNORM:      return DXGI_FORMAT_BC2_UNORM;
+    case Format::BC2_UNORM_SRGB: return DXGI_FORMAT_BC2_UNORM_SRGB;
+    case Format::BC3_UNORM:      return DXGI_FORMAT_BC3_UNORM;
+    case Format::BC3_UNORM_SRGB: return DXGI_FORMAT_BC3_UNORM_SRGB;
+    case Format::BC4_UNORM:      return DXGI_FORMAT_BC4_UNORM;
+    case Format::BC4_SNORM:      return DXGI_FORMAT_BC4_SNORM;
+    case Format::BC5_UNORM:      return DXGI_FORMAT_BC5_UNORM;
+    case Format::BC5_SNORM:      return DXGI_FORMAT_BC5_SNORM;
+    case Format::BC6H_UF16:      return DXGI_FORMAT_BC6H_UF16;
+    case Format::BC6H_SF16:      return DXGI_FORMAT_BC6H_SF16;
+    case Format::BC7_UNORM:      return DXGI_FORMAT_BC7_UNORM;
+    case Format::BC7_UNORM_SRGB: return DXGI_FORMAT_BC7_UNORM_SRGB;
+
+    default: return DXGI_FORMAT_UNKNOWN;
+    }
+}
+
+/* static */ DXGI_FORMAT
+D3DUtil::calcResourceFormat(UsageType usage, Int usageFlags, DXGI_FORMAT format)
 {
     SLANG_UNUSED(usage);
     if (usageFlags)
     {
         switch (format)
         {
-            case DXGI_FORMAT_R32_FLOAT:     /* fallthru */
-            case DXGI_FORMAT_R32_UINT:
-            case DXGI_FORMAT_D32_FLOAT:
+        case DXGI_FORMAT_R32_FLOAT: /* fallthru */
+        case DXGI_FORMAT_R32_UINT:
+        case DXGI_FORMAT_D32_FLOAT:
             {
                 return DXGI_FORMAT_R32_TYPELESS;
             }
-            case DXGI_FORMAT_D24_UNORM_S8_UINT:    return DXGI_FORMAT_R24G8_TYPELESS;
-            default: break;
+        case DXGI_FORMAT_D24_UNORM_S8_UINT: return DXGI_FORMAT_R24G8_TYPELESS;
+        default:                            break;
         }
         return format;
     }
     return format;
 }
 
-/* static */DXGI_FORMAT D3DUtil::calcFormat(UsageType usage, DXGI_FORMAT format)
+/* static */ DXGI_FORMAT D3DUtil::calcFormat(UsageType usage, DXGI_FORMAT format)
 {
     switch (usage)
     {
-        case USAGE_COUNT_OF:
-        case USAGE_UNKNOWN:
+    case USAGE_COUNT_OF:
+    case USAGE_UNKNOWN:
         {
             return DXGI_FORMAT_UNKNOWN;
         }
-        case USAGE_DEPTH_STENCIL:
+    case USAGE_DEPTH_STENCIL:
         {
             switch (format)
             {
-                case DXGI_FORMAT_D32_FLOAT:     /* fallthru */
-                case DXGI_FORMAT_R32_TYPELESS:
+            case DXGI_FORMAT_D32_FLOAT: /* fallthru */
+            case DXGI_FORMAT_R32_TYPELESS:
                 {
                     return DXGI_FORMAT_D32_FLOAT;
                 }
-                case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:    return DXGI_FORMAT_D24_UNORM_S8_UINT;
-                case DXGI_FORMAT_R24G8_TYPELESS:        return DXGI_FORMAT_D24_UNORM_S8_UINT;
-                default: break;
+            case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: return DXGI_FORMAT_D24_UNORM_S8_UINT;
+            case DXGI_FORMAT_R24G8_TYPELESS:        return DXGI_FORMAT_D24_UNORM_S8_UINT;
+            default:                                break;
             }
             return format;
         }
-        case USAGE_TARGET:
+    case USAGE_TARGET:
         {
             switch (format)
             {
-                case DXGI_FORMAT_D32_FLOAT:     /* fallthru */
-                case DXGI_FORMAT_D24_UNORM_S8_UINT:
+            case DXGI_FORMAT_D32_FLOAT: /* fallthru */
+            case DXGI_FORMAT_D24_UNORM_S8_UINT:
                 {
                     return DXGI_FORMAT_UNKNOWN;
                 }
-                case DXGI_FORMAT_R32_TYPELESS:        return DXGI_FORMAT_R32_FLOAT;
-                default: break;
+            case DXGI_FORMAT_R32_TYPELESS: return DXGI_FORMAT_R32_FLOAT;
+            default:                       break;
             }
             return format;
         }
-        case USAGE_SRV:
+    case USAGE_SRV:
         {
             switch (format)
             {
-                case DXGI_FORMAT_D32_FLOAT:     /* fallthru */
-                case DXGI_FORMAT_R32_TYPELESS:
+            case DXGI_FORMAT_D32_FLOAT: /* fallthru */
+            case DXGI_FORMAT_R32_TYPELESS:
                 {
                     return DXGI_FORMAT_R32_FLOAT;
                 }
-                case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:    return DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
-                default: break;
+            case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: return DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
+            default:                                break;
             }
 
             return format;
@@ -336,101 +305,105 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
 {
     switch (format)
     {
-        case DXGI_FORMAT_R32G32B32A32_TYPELESS:
-        case DXGI_FORMAT_R32G32B32_TYPELESS:
-        case DXGI_FORMAT_R16G16B16A16_TYPELESS:
-        case DXGI_FORMAT_R32G32_TYPELESS:
-        case DXGI_FORMAT_R32G8X24_TYPELESS:
-        case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
-        case DXGI_FORMAT_R10G10B10A2_TYPELESS:
-        case DXGI_FORMAT_R8G8B8A8_TYPELESS:
-        case DXGI_FORMAT_R16G16_TYPELESS:
-        case DXGI_FORMAT_R32_TYPELESS:
-        case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
-        case DXGI_FORMAT_R24G8_TYPELESS:
-        case DXGI_FORMAT_R8G8_TYPELESS:
-        case DXGI_FORMAT_R16_TYPELESS:
-        case DXGI_FORMAT_R8_TYPELESS:
-        case DXGI_FORMAT_BC1_TYPELESS:
-        case DXGI_FORMAT_BC2_TYPELESS:
-        case DXGI_FORMAT_BC3_TYPELESS:
-        case DXGI_FORMAT_BC4_TYPELESS:
-        case DXGI_FORMAT_BC5_TYPELESS:
-        case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-        case DXGI_FORMAT_BC6H_TYPELESS:
-        case DXGI_FORMAT_BC7_TYPELESS:
+    case DXGI_FORMAT_R32G32B32A32_TYPELESS:
+    case DXGI_FORMAT_R32G32B32_TYPELESS:
+    case DXGI_FORMAT_R16G16B16A16_TYPELESS:
+    case DXGI_FORMAT_R32G32_TYPELESS:
+    case DXGI_FORMAT_R32G8X24_TYPELESS:
+    case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
+    case DXGI_FORMAT_R10G10B10A2_TYPELESS:
+    case DXGI_FORMAT_R8G8B8A8_TYPELESS:
+    case DXGI_FORMAT_R16G16_TYPELESS:
+    case DXGI_FORMAT_R32_TYPELESS:
+    case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
+    case DXGI_FORMAT_R24G8_TYPELESS:
+    case DXGI_FORMAT_R8G8_TYPELESS:
+    case DXGI_FORMAT_R16_TYPELESS:
+    case DXGI_FORMAT_R8_TYPELESS:
+    case DXGI_FORMAT_BC1_TYPELESS:
+    case DXGI_FORMAT_BC2_TYPELESS:
+    case DXGI_FORMAT_BC3_TYPELESS:
+    case DXGI_FORMAT_BC4_TYPELESS:
+    case DXGI_FORMAT_BC5_TYPELESS:
+    case DXGI_FORMAT_B8G8R8A8_TYPELESS:
+    case DXGI_FORMAT_BC6H_TYPELESS:
+    case DXGI_FORMAT_BC7_TYPELESS:
         {
             return true;
         }
-        default: break;
+    default: break;
     }
     return false;
 }
 
-/* static */Int D3DUtil::getNumColorChannelBits(DXGI_FORMAT fmt)
+/* static */ Int D3DUtil::getNumColorChannelBits(DXGI_FORMAT fmt)
 {
     switch (fmt)
     {
-        case DXGI_FORMAT_R32G32B32A32_TYPELESS:
-        case DXGI_FORMAT_R32G32B32A32_FLOAT:
-        case DXGI_FORMAT_R32G32B32A32_UINT:
-        case DXGI_FORMAT_R32G32B32A32_SINT:
-        case DXGI_FORMAT_R32G32B32_TYPELESS:
-        case DXGI_FORMAT_R32G32B32_FLOAT:
-        case DXGI_FORMAT_R32G32B32_UINT:
-        case DXGI_FORMAT_R32G32B32_SINT:
+    case DXGI_FORMAT_R32G32B32A32_TYPELESS:
+    case DXGI_FORMAT_R32G32B32A32_FLOAT:
+    case DXGI_FORMAT_R32G32B32A32_UINT:
+    case DXGI_FORMAT_R32G32B32A32_SINT:
+    case DXGI_FORMAT_R32G32B32_TYPELESS:
+    case DXGI_FORMAT_R32G32B32_FLOAT:
+    case DXGI_FORMAT_R32G32B32_UINT:
+    case DXGI_FORMAT_R32G32B32_SINT:
         {
             return 32;
         }
-        case DXGI_FORMAT_R16G16B16A16_TYPELESS:
-        case DXGI_FORMAT_R16G16B16A16_FLOAT:
-        case DXGI_FORMAT_R16G16B16A16_UNORM:
-        case DXGI_FORMAT_R16G16B16A16_UINT:
-        case DXGI_FORMAT_R16G16B16A16_SNORM:
-        case DXGI_FORMAT_R16G16B16A16_SINT:
+    case DXGI_FORMAT_R16G16B16A16_TYPELESS:
+    case DXGI_FORMAT_R16G16B16A16_FLOAT:
+    case DXGI_FORMAT_R16G16B16A16_UNORM:
+    case DXGI_FORMAT_R16G16B16A16_UINT:
+    case DXGI_FORMAT_R16G16B16A16_SNORM:
+    case DXGI_FORMAT_R16G16B16A16_SINT:
         {
             return 16;
         }
-        case DXGI_FORMAT_R10G10B10A2_TYPELESS:
-        case DXGI_FORMAT_R10G10B10A2_UNORM:
-        case DXGI_FORMAT_R10G10B10A2_UINT:
-        case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
+    case DXGI_FORMAT_R10G10B10A2_TYPELESS:
+    case DXGI_FORMAT_R10G10B10A2_UNORM:
+    case DXGI_FORMAT_R10G10B10A2_UINT:
+    case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
         {
             return 10;
         }
-        case DXGI_FORMAT_R8G8B8A8_TYPELESS:
-        case DXGI_FORMAT_R8G8B8A8_UNORM:
-        case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
-        case DXGI_FORMAT_R8G8B8A8_UINT:
-        case DXGI_FORMAT_R8G8B8A8_SNORM:
-        case DXGI_FORMAT_R8G8B8A8_SINT:
-        case DXGI_FORMAT_B8G8R8A8_UNORM:
-        case DXGI_FORMAT_B8G8R8X8_UNORM:
-        case DXGI_FORMAT_B8G8R8A8_TYPELESS:
-        case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
-        case DXGI_FORMAT_B8G8R8X8_TYPELESS:
-        case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
+    case DXGI_FORMAT_R8G8B8A8_TYPELESS:
+    case DXGI_FORMAT_R8G8B8A8_UNORM:
+    case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+    case DXGI_FORMAT_R8G8B8A8_UINT:
+    case DXGI_FORMAT_R8G8B8A8_SNORM:
+    case DXGI_FORMAT_R8G8B8A8_SINT:
+    case DXGI_FORMAT_B8G8R8A8_UNORM:
+    case DXGI_FORMAT_B8G8R8X8_UNORM:
+    case DXGI_FORMAT_B8G8R8A8_TYPELESS:
+    case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
+    case DXGI_FORMAT_B8G8R8X8_TYPELESS:
+    case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
         {
             return 8;
         }
-        case DXGI_FORMAT_B5G6R5_UNORM:
-        case DXGI_FORMAT_B5G5R5A1_UNORM:
+    case DXGI_FORMAT_B5G6R5_UNORM:
+    case DXGI_FORMAT_B5G5R5A1_UNORM:
         {
             return 5;
         }
-        case DXGI_FORMAT_B4G4R4A4_UNORM:
-            return 4;
+    case DXGI_FORMAT_B4G4R4A4_UNORM: return 4;
 
-        default:
-            return 0;
+    default: return 0;
     }
 }
 
 // Note: this subroutine is now only used by D3D11 for generating bytecode to go into input layouts.
 //
-// TODO: we can probably remove that code completely by switching to a PSO-like model across all APIs.
+// TODO: we can probably remove that code completely by switching to a PSO-like model across all
+// APIs.
 //
-/* static */Result D3DUtil::compileHLSLShader(char const* sourcePath, char const* source, char const* entryPointName, char const* dxProfileName, ComPtr<ID3DBlob>& shaderBlobOut)
+/* static */ Result D3DUtil::compileHLSLShader(
+    char const* sourcePath,
+    char const* source,
+    char const* entryPointName,
+    char const* dxProfileName,
+    ComPtr<ID3DBlob>& shaderBlobOut)
 {
 #if !SLANG_ENABLE_DXBC_SUPPORT
     return SLANG_E_NOT_IMPLEMENTED;
@@ -458,7 +431,8 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
             return SLANG_FAIL;
         }
 
-        compileFunc = (pD3DCompile)SharedLibrary::findSymbolAddressByName(compilerModule, "D3DCompile");
+        compileFunc =
+            (pD3DCompile)SharedLibrary::findSymbolAddressByName(compilerModule, "D3DCompile");
         if (!compileFunc)
         {
             fprintf(stderr, "error: failed load symbol 'D3DCompile'\n");
@@ -476,8 +450,8 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
     // We will always define `__HLSL__` when compiling here, so that
     // input code can react differently to being compiled as pure HLSL.
     D3D_SHADER_MACRO defines[] = {
-        { "__HLSL__", "1" },
-        { nullptr, nullptr },
+        {"__HLSL__", "1"},
+        {nullptr, nullptr},
     };
 
     // The `D3DCompile` entry point takes a bunch of parameters, but we
@@ -485,8 +459,18 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
     ComPtr<ID3DBlob> shaderBlob;
     ComPtr<ID3DBlob> errorBlob;
 
-    HRESULT hr = compileFunc(source, strlen(source), sourcePath, &defines[0], nullptr, entryPointName, dxProfileName, flags, 0,
-        shaderBlob.writeRef(), errorBlob.writeRef());
+    HRESULT hr = compileFunc(
+        source,
+        strlen(source),
+        sourcePath,
+        &defines[0],
+        nullptr,
+        entryPointName,
+        dxProfileName,
+        flags,
+        0,
+        shaderBlob.writeRef(),
+        errorBlob.writeRef());
 
     // If the HLSL-to-bytecode compilation produced any diagnostic messages
     // then we will print them out (whether or not the compilation failed).
@@ -505,11 +489,12 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
 #endif // SLANG_ENABLE_DXBC_SUPPORT
 }
 
-/* static */SharedLibrary::Handle D3DUtil::getDxgiModule()
+/* static */ SharedLibrary::Handle D3DUtil::getDxgiModule()
 {
     const char* const libName = SLANG_ENABLE_DXVK ? "dxvk_dxgi" : "dxgi";
 
-    static SharedLibrary::Handle s_dxgiModule = [&](){
+    static SharedLibrary::Handle s_dxgiModule = [&]()
+    {
         SharedLibrary::Handle h = nullptr;
         SharedLibrary::load(libName, h);
         if (!h)
@@ -521,19 +506,23 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
     return s_dxgiModule;
 }
 
-/* static */SlangResult D3DUtil::createFactory(DeviceCheckFlags flags, ComPtr<IDXGIFactory>& outFactory)
+/* static */ SlangResult D3DUtil::createFactory(
+    DeviceCheckFlags flags,
+    ComPtr<IDXGIFactory>& outFactory)
 {
-    auto dxgiModule =  getDxgiModule();
+    auto dxgiModule = getDxgiModule();
     if (!dxgiModule)
     {
         return SLANG_FAIL;
     }
 
-    typedef HRESULT(WINAPI *PFN_DXGI_CREATE_FACTORY)(REFIID riid, void   **ppFactory);
-    typedef HRESULT(WINAPI *PFN_DXGI_CREATE_FACTORY_2)(UINT Flags, REFIID riid, void **ppFactory);
+    typedef HRESULT(WINAPI * PFN_DXGI_CREATE_FACTORY)(REFIID riid, void** ppFactory);
+    typedef HRESULT(WINAPI * PFN_DXGI_CREATE_FACTORY_2)(UINT Flags, REFIID riid, void** ppFactory);
 
     {
-        auto createFactory2 = (PFN_DXGI_CREATE_FACTORY_2)SharedLibrary::findSymbolAddressByName(dxgiModule, "CreateDXGIFactory2");
+        auto createFactory2 = (PFN_DXGI_CREATE_FACTORY_2)SharedLibrary::findSymbolAddressByName(
+            dxgiModule,
+            "CreateDXGIFactory2");
         if (createFactory2)
         {
             UINT dxgiFlags = 0;
@@ -552,7 +541,9 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
     }
 
     {
-        auto createFactory = (PFN_DXGI_CREATE_FACTORY)SharedLibrary::findSymbolAddressByName(dxgiModule, "CreateDXGIFactory");
+        auto createFactory = (PFN_DXGI_CREATE_FACTORY)SharedLibrary::findSymbolAddressByName(
+            dxgiModule,
+            "CreateDXGIFactory");
         if (!createFactory)
         {
             fprintf(stderr, "error: failed load symbol '%s'\n", "CreateDXGIFactory");
@@ -562,7 +553,10 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
     }
 }
 
-/* static */SlangResult D3DUtil::findAdapters(DeviceCheckFlags flags, const AdapterLUID* adapterLUID, List<ComPtr<IDXGIAdapter>>& outDxgiAdapters)
+/* static */ SlangResult D3DUtil::findAdapters(
+    DeviceCheckFlags flags,
+    const AdapterLUID* adapterLUID,
+    List<ComPtr<IDXGIAdapter>>& outDxgiAdapters)
 {
     ComPtr<IDXGIFactory> factory;
     SLANG_RETURN_ON_FAIL(createFactory(flags, factory));
@@ -579,7 +573,7 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
     return luid;
 }
 
-/* static */bool D3DUtil::isWarp(IDXGIFactory* dxgiFactory, IDXGIAdapter* adapterIn)
+/* static */ bool D3DUtil::isWarp(IDXGIFactory* dxgiFactory, IDXGIAdapter* adapterIn)
 {
     ComPtr<IDXGIFactory4> dxgiFactory4;
     if (SLANG_SUCCEEDED(dxgiFactory->QueryInterface(IID_PPV_ARGS(dxgiFactory4.writeRef()))))
@@ -599,10 +593,8 @@ bool D3DUtil::isUAVBinding(slang::BindingType bindingType)
     {
     case slang::BindingType::MutableRawBuffer:
     case slang::BindingType::MutableTexture:
-    case slang::BindingType::MutableTypedBuffer:
-        return true;
-    default:
-        return false;
+    case slang::BindingType::MutableTypedBuffer: return true;
+    default:                                     return false;
     }
 }
 
@@ -636,10 +628,8 @@ uint32_t D3DUtil::getPlaneSliceCount(DXGI_FORMAT format)
     switch (format)
     {
     case DXGI_FORMAT_D24_UNORM_S8_UINT:
-    case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
-        return 2;
-    default:
-        return 1;
+    case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: return 2;
+    default:                               return 1;
     }
 }
 
@@ -648,28 +638,19 @@ uint32_t D3DUtil::getPlaneSlice(DXGI_FORMAT format, TextureAspect aspect)
     switch (aspect)
     {
     case TextureAspect::Default:
-    case TextureAspect::Color:
-        return 0;
-    case TextureAspect::Depth:
-        return 0;
+    case TextureAspect::Color:   return 0;
+    case TextureAspect::Depth:   return 0;
     case TextureAspect::Stencil:
         switch (format)
         {
         case DXGI_FORMAT_D24_UNORM_S8_UINT:
-        case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
-            return 1;
-        default:
-            return 0;
+        case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: return 1;
+        default:                               return 0;
         }
-    case TextureAspect::Plane0:
-        return 0;
-    case TextureAspect::Plane1:
-        return 1;
-    case TextureAspect::Plane2:
-        return 2;
-    default:
-        SLANG_ASSERT_FAILURE("Unknown texture aspect.");
-        return 0;
+    case TextureAspect::Plane0: return 0;
+    case TextureAspect::Plane1: return 1;
+    case TextureAspect::Plane2: return 2;
+    default:                    SLANG_ASSERT_FAILURE("Unknown texture aspect."); return 0;
     }
 }
 
@@ -677,10 +658,8 @@ D3D12_INPUT_CLASSIFICATION D3DUtil::getInputSlotClass(InputSlotClass slotClass)
 {
     switch (slotClass)
     {
-    case InputSlotClass::PerVertex:
-        return D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
-    case InputSlotClass::PerInstance:
-        return D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
+    case InputSlotClass::PerVertex:   return D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
+    case InputSlotClass::PerInstance: return D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
     default:
         SLANG_ASSERT_FAILURE("Unknown input slot class.");
         return D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
@@ -691,13 +670,9 @@ D3D12_FILL_MODE D3DUtil::getFillMode(FillMode mode)
 {
     switch (mode)
     {
-    case FillMode::Solid:
-        return D3D12_FILL_MODE_SOLID;
-    case FillMode::Wireframe:
-        return D3D12_FILL_MODE_WIREFRAME;
-    default:
-        SLANG_ASSERT_FAILURE("Unknown fill mode.");
-        return D3D12_FILL_MODE_SOLID;
+    case FillMode::Solid:     return D3D12_FILL_MODE_SOLID;
+    case FillMode::Wireframe: return D3D12_FILL_MODE_WIREFRAME;
+    default:                  SLANG_ASSERT_FAILURE("Unknown fill mode."); return D3D12_FILL_MODE_SOLID;
     }
 }
 
@@ -705,15 +680,10 @@ D3D12_CULL_MODE D3DUtil::getCullMode(CullMode mode)
 {
     switch (mode)
     {
-    case CullMode::None:
-        return D3D12_CULL_MODE_NONE;
-    case CullMode::Front:
-        return D3D12_CULL_MODE_FRONT;
-    case CullMode::Back:
-        return D3D12_CULL_MODE_BACK;
-    default:
-        SLANG_ASSERT_FAILURE("Unknown cull mode.");
-        return D3D12_CULL_MODE_NONE;
+    case CullMode::None:  return D3D12_CULL_MODE_NONE;
+    case CullMode::Front: return D3D12_CULL_MODE_FRONT;
+    case CullMode::Back:  return D3D12_CULL_MODE_BACK;
+    default:              SLANG_ASSERT_FAILURE("Unknown cull mode."); return D3D12_CULL_MODE_NONE;
     }
 }
 
@@ -721,19 +691,12 @@ D3D12_BLEND_OP D3DUtil::getBlendOp(BlendOp op)
 {
     switch (op)
     {
-    case BlendOp::Add:
-        return D3D12_BLEND_OP_ADD;
-    case BlendOp::Subtract:
-        return D3D12_BLEND_OP_SUBTRACT;
-    case BlendOp::ReverseSubtract:
-        return D3D12_BLEND_OP_REV_SUBTRACT;
-    case BlendOp::Min:
-        return D3D12_BLEND_OP_MIN;
-    case BlendOp::Max:
-        return D3D12_BLEND_OP_MAX;
-    default:
-        SLANG_ASSERT_FAILURE("Unknown blend op.");
-        return D3D12_BLEND_OP_ADD;
+    case BlendOp::Add:             return D3D12_BLEND_OP_ADD;
+    case BlendOp::Subtract:        return D3D12_BLEND_OP_SUBTRACT;
+    case BlendOp::ReverseSubtract: return D3D12_BLEND_OP_REV_SUBTRACT;
+    case BlendOp::Min:             return D3D12_BLEND_OP_MIN;
+    case BlendOp::Max:             return D3D12_BLEND_OP_MAX;
+    default:                       SLANG_ASSERT_FAILURE("Unknown blend op."); return D3D12_BLEND_OP_ADD;
     }
 }
 
@@ -741,43 +704,24 @@ D3D12_BLEND D3DUtil::getBlendFactor(BlendFactor factor)
 {
     switch (factor)
     {
-    case BlendFactor::Zero:
-        return D3D12_BLEND_ZERO;
-    case BlendFactor::One:
-        return D3D12_BLEND_ONE;
-    case BlendFactor::SrcColor:
-        return D3D12_BLEND_SRC_COLOR;
-    case BlendFactor::InvSrcColor:
-        return D3D12_BLEND_INV_SRC_COLOR;
-    case BlendFactor::SrcAlpha:
-        return D3D12_BLEND_SRC_ALPHA;
-    case BlendFactor::InvSrcAlpha:
-        return D3D12_BLEND_INV_SRC_ALPHA;
-    case BlendFactor::DestAlpha:
-        return D3D12_BLEND_DEST_ALPHA;
-    case BlendFactor::InvDestAlpha:
-        return D3D12_BLEND_INV_DEST_ALPHA;
-    case BlendFactor::DestColor:
-        return D3D12_BLEND_DEST_COLOR;
-    case BlendFactor::InvDestColor:
-        return D3D12_BLEND_INV_DEST_COLOR;
-    case BlendFactor::SrcAlphaSaturate:
-        return D3D12_BLEND_SRC_ALPHA_SAT;
-    case BlendFactor::BlendColor:
-        return D3D12_BLEND_BLEND_FACTOR;
-    case BlendFactor::InvBlendColor:
-        return D3D12_BLEND_INV_BLEND_FACTOR;
-    case BlendFactor::SecondarySrcColor:
-        return D3D12_BLEND_SRC1_COLOR;
-    case BlendFactor::InvSecondarySrcColor:
-        return D3D12_BLEND_INV_SRC1_COLOR;
-    case BlendFactor::SecondarySrcAlpha:
-        return D3D12_BLEND_SRC1_ALPHA;
-    case BlendFactor::InvSecondarySrcAlpha:
-        return D3D12_BLEND_INV_SRC1_ALPHA;
-    default:
-        SLANG_ASSERT_FAILURE("Unknown blend factor.");
-        return D3D12_BLEND_ZERO;
+    case BlendFactor::Zero:                 return D3D12_BLEND_ZERO;
+    case BlendFactor::One:                  return D3D12_BLEND_ONE;
+    case BlendFactor::SrcColor:             return D3D12_BLEND_SRC_COLOR;
+    case BlendFactor::InvSrcColor:          return D3D12_BLEND_INV_SRC_COLOR;
+    case BlendFactor::SrcAlpha:             return D3D12_BLEND_SRC_ALPHA;
+    case BlendFactor::InvSrcAlpha:          return D3D12_BLEND_INV_SRC_ALPHA;
+    case BlendFactor::DestAlpha:            return D3D12_BLEND_DEST_ALPHA;
+    case BlendFactor::InvDestAlpha:         return D3D12_BLEND_INV_DEST_ALPHA;
+    case BlendFactor::DestColor:            return D3D12_BLEND_DEST_COLOR;
+    case BlendFactor::InvDestColor:         return D3D12_BLEND_INV_DEST_COLOR;
+    case BlendFactor::SrcAlphaSaturate:     return D3D12_BLEND_SRC_ALPHA_SAT;
+    case BlendFactor::BlendColor:           return D3D12_BLEND_BLEND_FACTOR;
+    case BlendFactor::InvBlendColor:        return D3D12_BLEND_INV_BLEND_FACTOR;
+    case BlendFactor::SecondarySrcColor:    return D3D12_BLEND_SRC1_COLOR;
+    case BlendFactor::InvSecondarySrcColor: return D3D12_BLEND_INV_SRC1_COLOR;
+    case BlendFactor::SecondarySrcAlpha:    return D3D12_BLEND_SRC1_ALPHA;
+    case BlendFactor::InvSecondarySrcAlpha: return D3D12_BLEND_INV_SRC1_ALPHA;
+    default:                                SLANG_ASSERT_FAILURE("Unknown blend factor."); return D3D12_BLEND_ZERO;
     }
 }
 
@@ -800,55 +744,37 @@ D3D12_RESOURCE_STATES D3DUtil::getResourceState(ResourceState state)
 {
     switch (state)
     {
-    case ResourceState::Undefined:
-        return D3D12_RESOURCE_STATE_COMMON;
-    case ResourceState::General:
-        return D3D12_RESOURCE_STATE_COMMON;
-    case ResourceState::PreInitialized:
-        return D3D12_RESOURCE_STATE_COMMON;
-    case ResourceState::VertexBuffer:
-        return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
-    case ResourceState::IndexBuffer:
-        return D3D12_RESOURCE_STATE_INDEX_BUFFER;
-    case ResourceState::ConstantBuffer:
-        return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
-    case ResourceState::StreamOutput:
-        return D3D12_RESOURCE_STATE_STREAM_OUT;
+    case ResourceState::Undefined:      return D3D12_RESOURCE_STATE_COMMON;
+    case ResourceState::General:        return D3D12_RESOURCE_STATE_COMMON;
+    case ResourceState::PreInitialized: return D3D12_RESOURCE_STATE_COMMON;
+    case ResourceState::VertexBuffer:   return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
+    case ResourceState::IndexBuffer:    return D3D12_RESOURCE_STATE_INDEX_BUFFER;
+    case ResourceState::ConstantBuffer: return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
+    case ResourceState::StreamOutput:   return D3D12_RESOURCE_STATE_STREAM_OUT;
     case ResourceState::ShaderResource:
     case ResourceState::AccelerationStructureBuildInput:
-        return D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
-    case ResourceState::PixelShaderResource:
-        return D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
+        return D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE |
+               D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
+    case ResourceState::PixelShaderResource: return D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
     case ResourceState::NonPixelShaderResource:
         return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
-    case ResourceState::UnorderedAccess:
-        return D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
-    case ResourceState::RenderTarget:
-        return D3D12_RESOURCE_STATE_RENDER_TARGET;
-    case ResourceState::DepthRead:
-        return D3D12_RESOURCE_STATE_DEPTH_READ;
-    case ResourceState::DepthWrite:;
-        return D3D12_RESOURCE_STATE_DEPTH_WRITE;
-    case ResourceState::Present:
-        return D3D12_RESOURCE_STATE_PRESENT;
-    case ResourceState::IndirectArgument:
-        return D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT;
-    case ResourceState::CopySource:
-        return D3D12_RESOURCE_STATE_COPY_SOURCE;
-    case ResourceState::CopyDestination:
-        return D3D12_RESOURCE_STATE_COPY_DEST;
-    case ResourceState::ResolveSource:
-        return D3D12_RESOURCE_STATE_RESOLVE_SOURCE;
-    case ResourceState::ResolveDestination:
-        return D3D12_RESOURCE_STATE_RESOLVE_DEST;
+    case ResourceState::UnorderedAccess:    return D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
+    case ResourceState::RenderTarget:       return D3D12_RESOURCE_STATE_RENDER_TARGET;
+    case ResourceState::DepthRead:          return D3D12_RESOURCE_STATE_DEPTH_READ;
+    case ResourceState::DepthWrite:         ; return D3D12_RESOURCE_STATE_DEPTH_WRITE;
+    case ResourceState::Present:            return D3D12_RESOURCE_STATE_PRESENT;
+    case ResourceState::IndirectArgument:   return D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT;
+    case ResourceState::CopySource:         return D3D12_RESOURCE_STATE_COPY_SOURCE;
+    case ResourceState::CopyDestination:    return D3D12_RESOURCE_STATE_COPY_DEST;
+    case ResourceState::ResolveSource:      return D3D12_RESOURCE_STATE_RESOLVE_SOURCE;
+    case ResourceState::ResolveDestination: return D3D12_RESOURCE_STATE_RESOLVE_DEST;
     case ResourceState::AccelerationStructure:
         return D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE;
-    default:
-        return D3D12_RESOURCE_STATE_COMMON;
+    default: return D3D12_RESOURCE_STATE_COMMON;
     }
 }
 
-/* static */SlangResult D3DUtil::reportLiveObjects()
+/* static */ SlangResult D3DUtil::reportLiveObjects()
 {
     static IDXGIDebug* dxgiDebug = nullptr;
 
@@ -858,7 +784,8 @@ D3D12_RESOURCE_STATES D3DUtil::getResourceState(ResourceState state)
         HMODULE debugModule = LoadLibraryA("dxgidebug.dll");
         if (debugModule != INVALID_HANDLE_VALUE)
         {
-            auto fun = reinterpret_cast<decltype(&DXGIGetDebugInterface)>(GetProcAddress(debugModule, "DXGIGetDebugInterface"));
+            auto fun = reinterpret_cast<decltype(&DXGIGetDebugInterface)>(
+                GetProcAddress(debugModule, "DXGIGetDebugInterface"));
             if (fun)
             {
                 fun(__uuidof(IDXGIDebug), (void**)&dxgiDebug);
@@ -869,7 +796,8 @@ D3D12_RESOURCE_STATES D3DUtil::getResourceState(ResourceState state)
 
     if (dxgiDebug)
     {
-        const GUID DXGI_DEBUG_ALL_ = { 0xe48ae283, 0xda80, 0x490b, { 0x87, 0xe6,  0x43,  0xe9,  0xa9,  0xcf,  0xda,  0x8 } };
+        const GUID DXGI_DEBUG_ALL_ =
+            {0xe48ae283, 0xda80, 0x490b, {0x87, 0xe6, 0x43, 0xe9, 0xa9, 0xcf, 0xda, 0x8}};
         dxgiDebug->ReportLiveObjects(DXGI_DEBUG_ALL_, DXGI_DEBUG_RLO_ALL);
         return SLANG_OK;
     }
@@ -883,7 +811,7 @@ Result SLANG_MCALL reportD3DLiveObjects()
 }
 
 
-/* static */SlangResult D3DUtil::waitForCrashDumpCompletion(HRESULT res)
+/* static */ SlangResult D3DUtil::waitForCrashDumpCompletion(HRESULT res)
 {
     // If it's not a device remove/reset then theres nothing to wait for
     if (!(res == DXGI_ERROR_DEVICE_REMOVED || res == DXGI_ERROR_DEVICE_RESET))
@@ -909,8 +837,8 @@ Result SLANG_MCALL reportD3DLiveObjects()
         // Loop while Aftermath crash dump data collection has not finished or
         // the application is still processing the crash dump data.
         while (status != GFSDK_Aftermath_CrashDump_Status_CollectingDataFailed &&
-            status != GFSDK_Aftermath_CrashDump_Status_Finished &&
-            Process::getClockTick() - startTick < timeOutTicks)
+               status != GFSDK_Aftermath_CrashDump_Status_Finished &&
+               Process::getClockTick() - startTick < timeOutTicks)
         {
             // Sleep a couple of milliseconds and poll the status again.
             Process::sleepCurrentThread(50);
@@ -934,7 +862,11 @@ Result SLANG_MCALL reportD3DLiveObjects()
     return SLANG_OK;
 }
 
-/* static */SlangResult D3DUtil::findAdapters(DeviceCheckFlags flags, const AdapterLUID* adapterLUID, IDXGIFactory* dxgiFactory, List<ComPtr<IDXGIAdapter>>& outDxgiAdapters)
+/* static */ SlangResult D3DUtil::findAdapters(
+    DeviceCheckFlags flags,
+    const AdapterLUID* adapterLUID,
+    IDXGIFactory* dxgiFactory,
+    List<ComPtr<IDXGIAdapter>>& outDxgiAdapters)
 {
     outDxgiAdapters.clear();
 
@@ -979,7 +911,8 @@ Result SLANG_MCALL reportD3DLiveObjects()
         }
 
         // If the right type then add it
-        if ((deviceFlags & DXGI_ADAPTER_FLAG_SOFTWARE) == 0 && (flags & DeviceCheckFlag::UseHardwareDevice) != 0)
+        if ((deviceFlags & DXGI_ADAPTER_FLAG_SOFTWARE) == 0 &&
+            (flags & DeviceCheckFlag::UseHardwareDevice) != 0)
         {
             outDxgiAdapters.add(dxgiAdapter);
         }
diff --git a/tools/gfx/d3d/d3d-util.h b/tools/gfx/d3d/d3d-util.h
index ce40ec722..af186a336 100644
--- a/tools/gfx/d3d/d3d-util.h
+++ b/tools/gfx/d3d/d3d-util.h
@@ -1,52 +1,49 @@
 // d3d-util.h
 #pragma once
 
-#include <stdint.h>
-
-#include "slang-com-helper.h"
-
-#include "slang-com-ptr.h"
+#include "../flag-combiner.h"
 #include "core/slang-basic.h"
 #include "core/slang-platform.h"
-
-#include "../flag-combiner.h"
-
+#include "slang-com-helper.h"
+#include "slang-com-ptr.h"
 #include "slang-gfx.h"
 
+#include <d3d12.h>
 #include <d3dcommon.h>
-#include <dxgiformat.h>
 #include <dxgi.h>
-#include <d3d12.h>
+#include <dxgiformat.h>
+#include <stdint.h>
 
 #if defined(__ID3D12Device5_FWD_DEFINED__) && defined(__ID3D12GraphicsCommandList4_FWD_DEFINED__)
-#    define SLANG_GFX_HAS_DXR_SUPPORT 1
+#define SLANG_GFX_HAS_DXR_SUPPORT 1
 #else
-#    define SLANG_GFX_HAS_DXR_SUPPORT 0
+#define SLANG_GFX_HAS_DXR_SUPPORT 0
 typedef ISlangUnknown ID3D12Device5;
 typedef ISlangUnknown ID3D12GraphicsCommandList4;
 
 #endif
 
-namespace gfx {
+namespace gfx
+{
 
 class D3DUtil
 {
-    public:
+public:
     enum UsageType
     {
-        USAGE_UNKNOWN,                      ///< Generally used to mark an error
-        USAGE_TARGET,                       ///< Format should be used when written as target
-        USAGE_DEPTH_STENCIL,                ///< Format should be used when written as depth stencil
-        USAGE_SRV,                          ///< Format if being read as srv
+        USAGE_UNKNOWN,       ///< Generally used to mark an error
+        USAGE_TARGET,        ///< Format should be used when written as target
+        USAGE_DEPTH_STENCIL, ///< Format should be used when written as depth stencil
+        USAGE_SRV,           ///< Format if being read as srv
         USAGE_COUNT_OF,
     };
     enum UsageFlag
     {
-        USAGE_FLAG_MULTI_SAMPLE = 0x1,      ///< If set will be used form multi sampling (such as MSAA)
-        USAGE_FLAG_SRV = 0x2,               ///< If set means will be used as a shader resource view (SRV)
+        USAGE_FLAG_MULTI_SAMPLE = 0x1, ///< If set will be used form multi sampling (such as MSAA)
+        USAGE_FLAG_SRV = 0x2, ///< If set means will be used as a shader resource view (SRV)
     };
 
-        /// Get primitive topology as D3D primitive topology
+    /// Get primitive topology as D3D primitive topology
     static D3D_PRIMITIVE_TOPOLOGY getPrimitiveTopology(PrimitiveTopology prim);
 
     static D3D12_PRIMITIVE_TOPOLOGY_TYPE getPrimitiveType(PrimitiveType type);
@@ -57,38 +54,58 @@ class D3DUtil
 
     static D3D12_DEPTH_STENCILOP_DESC translateStencilOpDesc(DepthStencilOpDesc desc);
 
-        /// Calculate size taking into account alignment. Alignment must be a power of 2
-    static UInt calcAligned(UInt size, UInt alignment) { return (size + alignment - 1) & ~(alignment - 1); }
+    /// Calculate size taking into account alignment. Alignment must be a power of 2
+    static UInt calcAligned(UInt size, UInt alignment)
+    {
+        return (size + alignment - 1) & ~(alignment - 1);
+    }
 
-        /// Compile HLSL code to DXBC
-    static Slang::Result compileHLSLShader(char const* sourcePath, char const* source, char const* entryPointName, char const* dxProfileName, Slang::ComPtr<ID3DBlob>& shaderBlobOut);
+    /// Compile HLSL code to DXBC
+    static Slang::Result compileHLSLShader(
+        char const* sourcePath,
+        char const* source,
+        char const* entryPointName,
+        char const* dxProfileName,
+        Slang::ComPtr<ID3DBlob>& shaderBlobOut);
 
-        /// Given a slang pixel format returns the equivalent DXGI_ pixel format. If the format is not known, will return DXGI_FORMAT_UNKNOWN
+    /// Given a slang pixel format returns the equivalent DXGI_ pixel format. If the format is not
+    /// known, will return DXGI_FORMAT_UNKNOWN
     static DXGI_FORMAT getMapFormat(Format format);
 
-        /// Given the usage, flags, and format will return the most suitable format. Will return DXGI_UNKNOWN if combination is not possible
+    /// Given the usage, flags, and format will return the most suitable format. Will return
+    /// DXGI_UNKNOWN if combination is not possible
     static DXGI_FORMAT calcFormat(UsageType usage, DXGI_FORMAT format);
-        /// Calculate appropriate format for creating a buffer for usage and flags
+    /// Calculate appropriate format for creating a buffer for usage and flags
     static DXGI_FORMAT calcResourceFormat(UsageType usage, Int usageFlags, DXGI_FORMAT format);
-        /// True if the type is 'typeless'
+    /// True if the type is 'typeless'
     static bool isTypeless(DXGI_FORMAT format);
 
-        /// Returns number of bits used for color channel for format (for channels with multiple sizes, returns smallest ie RGB565 -> 5)
+    /// Returns number of bits used for color channel for format (for channels with multiple sizes,
+    /// returns smallest ie RGB565 -> 5)
     static Int getNumColorChannelBits(DXGI_FORMAT fmt);
 
-    static SlangResult createFactory(DeviceCheckFlags flags, Slang::ComPtr<IDXGIFactory>& outFactory);
+    static SlangResult createFactory(
+        DeviceCheckFlags flags,
+        Slang::ComPtr<IDXGIFactory>& outFactory);
 
-        /// Get the dxgiModule
+    /// Get the dxgiModule
     static Slang::SharedLibrary::Handle getDxgiModule();
 
-        /// Find adapters
-    static SlangResult findAdapters(DeviceCheckFlags flags, const AdapterLUID* adapterLUID, IDXGIFactory* dxgiFactory, Slang::List<Slang::ComPtr<IDXGIAdapter>>& dxgiAdapters);
-        /// Find adapters
-    static SlangResult findAdapters(DeviceCheckFlags flags, const AdapterLUID* adapterLUID, Slang::List<Slang::ComPtr<IDXGIAdapter>>& dxgiAdapters);
+    /// Find adapters
+    static SlangResult findAdapters(
+        DeviceCheckFlags flags,
+        const AdapterLUID* adapterLUID,
+        IDXGIFactory* dxgiFactory,
+        Slang::List<Slang::ComPtr<IDXGIAdapter>>& dxgiAdapters);
+    /// Find adapters
+    static SlangResult findAdapters(
+        DeviceCheckFlags flags,
+        const AdapterLUID* adapterLUID,
+        Slang::List<Slang::ComPtr<IDXGIAdapter>>& dxgiAdapters);
 
     static AdapterLUID getAdapterLUID(IDXGIAdapter* dxgiAdapter);
 
-        /// True if the adapter is warp
+    /// True if the adapter is warp
     static bool isWarp(IDXGIFactory* dxgiFactory, IDXGIAdapter* adapter);
 
     static bool isUAVBinding(slang::BindingType bindingType);
@@ -122,8 +139,8 @@ class D3DUtil
 
     static SlangResult reportLiveObjects();
 
-        /// Call after a DXGI_ERROR_DEVICE_REMOVED/DXGI_ERROR_DEVICE_RESET on present, to wait for 
-        /// dumping to complete. Will return SLANG_OK if wait happened successfully
+    /// Call after a DXGI_ERROR_DEVICE_REMOVED/DXGI_ERROR_DEVICE_RESET on present, to wait for
+    /// dumping to complete. Will return SLANG_OK if wait happened successfully
     static SlangResult waitForCrashDumpCompletion(HRESULT res);
 };
 
@@ -138,11 +155,11 @@ struct D3DAccelerationStructureInputsBuilder
         IDebugCallback* callback);
 
 private:
-    D3D12_RAYTRACING_GEOMETRY_FLAGS translateGeometryFlags(
-        IAccelerationStructure::GeometryFlags::Enum flags)
+    D3D12_RAYTRACING_GEOMETRY_FLAGS
+    translateGeometryFlags(IAccelerationStructure::GeometryFlags::Enum flags)
     {
         return (D3D12_RAYTRACING_GEOMETRY_FLAGS)flags;
     }
 };
 #endif
-} // renderer_test
+} // namespace gfx