Move switch statement bodies to their own lines (#5493)

* Move switch statement bodies to their own lines

* format

---------

Co-authored-by: Yong He <yonghe@outlook.com>

44 files changed, 2159 insertions, 1070 deletions

diff --git a/tools/gfx/cpu/cpu-shader-object.cpp b/tools/gfx/cpu/cpu-shader-object.cpp
index 3c9dd3cb2..ec11b2272 100644
--- a/tools/gfx/cpu/cpu-shader-object.cpp
+++ b/tools/gfx/cpu/cpu-shader-object.cpp
@@ -223,7 +223,8 @@ ShaderObjectImpl::setObject(ShaderOffset const& offset, IShaderObject* object)
         break;
     case slang::BindingType::ExistentialValue:
     case slang::BindingType::RawBuffer:
-    case slang::BindingType::MutableRawBuffer: break;
+    case slang::BindingType::MutableRawBuffer:
+        break;
     }
     return SLANG_OK;
 }
diff --git a/tools/gfx/cuda/cuda-device.cpp b/tools/gfx/cuda/cuda-device.cpp
index 8162a20b8..a62f41ada 100644
--- a/tools/gfx/cuda/cuda-device.cpp
+++ b/tools/gfx/cuda/cuda-device.cpp
@@ -275,31 +275,47 @@ Result DeviceImpl::getCUDAFormat(Format format, CUarray_format* outFormat)
     case Format::R32G32B32_FLOAT:
     case Format::R32G32_FLOAT:
     case Format::R32_FLOAT:
-    case Format::D32_FLOAT:          *outFormat = CU_AD_FORMAT_FLOAT; return SLANG_OK;
+    case Format::D32_FLOAT:
+        *outFormat = CU_AD_FORMAT_FLOAT;
+        return SLANG_OK;
     case Format::R16G16B16A16_FLOAT:
     case Format::R16G16_FLOAT:
-    case Format::R16_FLOAT:          *outFormat = CU_AD_FORMAT_HALF; return SLANG_OK;
+    case Format::R16_FLOAT:
+        *outFormat = CU_AD_FORMAT_HALF;
+        return SLANG_OK;
     case Format::R32G32B32A32_UINT:
     case Format::R32G32B32_UINT:
     case Format::R32G32_UINT:
-    case Format::R32_UINT:           *outFormat = CU_AD_FORMAT_UNSIGNED_INT32; return SLANG_OK;
+    case Format::R32_UINT:
+        *outFormat = CU_AD_FORMAT_UNSIGNED_INT32;
+        return SLANG_OK;
     case Format::R16G16B16A16_UINT:
     case Format::R16G16_UINT:
-    case Format::R16_UINT:           *outFormat = CU_AD_FORMAT_UNSIGNED_INT16; return SLANG_OK;
+    case Format::R16_UINT:
+        *outFormat = CU_AD_FORMAT_UNSIGNED_INT16;
+        return SLANG_OK;
     case Format::R8G8B8A8_UINT:
     case Format::R8G8_UINT:
     case Format::R8_UINT:
-    case Format::R8G8B8A8_UNORM:     *outFormat = CU_AD_FORMAT_UNSIGNED_INT8; return SLANG_OK;
+    case Format::R8G8B8A8_UNORM:
+        *outFormat = CU_AD_FORMAT_UNSIGNED_INT8;
+        return SLANG_OK;
     case Format::R32G32B32A32_SINT:
     case Format::R32G32B32_SINT:
     case Format::R32G32_SINT:
-    case Format::R32_SINT:           *outFormat = CU_AD_FORMAT_SIGNED_INT32; return SLANG_OK;
+    case Format::R32_SINT:
+        *outFormat = CU_AD_FORMAT_SIGNED_INT32;
+        return SLANG_OK;
     case Format::R16G16B16A16_SINT:
     case Format::R16G16_SINT:
-    case Format::R16_SINT:           *outFormat = CU_AD_FORMAT_SIGNED_INT16; return SLANG_OK;
+    case Format::R16_SINT:
+        *outFormat = CU_AD_FORMAT_SIGNED_INT16;
+        return SLANG_OK;
     case Format::R8G8B8A8_SINT:
     case Format::R8G8_SINT:
-    case Format::R8_SINT:            *outFormat = CU_AD_FORMAT_SIGNED_INT8; return SLANG_OK;
+    case Format::R8_SINT:
+        *outFormat = CU_AD_FORMAT_SIGNED_INT8;
+        return SLANG_OK;
     default:
         SLANG_ASSERT(!"Only support R32_FLOAT/R8G8B8A8_UNORM formats for now");
         return SLANG_FAIL;
@@ -341,11 +357,16 @@ SLANG_NO_THROW Result SLANG_MCALL DeviceImpl::createTextureResource(
         depth = 0;
         break;
 
-    case IResource::Type::Texture2D: depth = 0; break;
+    case IResource::Type::Texture2D:
+        depth = 0;
+        break;
 
-    case IResource::Type::Texture3D: break;
+    case IResource::Type::Texture3D:
+        break;
 
-    case IResource::Type::TextureCube: depth = 1; break;
+    case IResource::Type::TextureCube:
+        depth = 1;
+        break;
     }
 
     {
@@ -771,7 +792,8 @@ SLANG_NO_THROW Result SLANG_MCALL DeviceImpl::createBufferFromSharedHandle(
     case InteropHandleAPI::Vulkan:
         externalMemoryHandleDesc.type = CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32;
         break;
-    default: return SLANG_FAIL;
+    default:
+        return SLANG_FAIL;
     }
     externalMemoryHandleDesc.handle.win32.handle = (void*)handle.handleValue;
     externalMemoryHandleDesc.size = desc.sizeInBytes;
@@ -834,7 +856,8 @@ SLANG_NO_THROW Result SLANG_MCALL DeviceImpl::createTextureFromSharedHandle(
     case InteropHandleAPI::Vulkan:
         externalMemoryHandleDesc.type = CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32;
         break;
-    default: return SLANG_FAIL;
+    default:
+        return SLANG_FAIL;
     }
     externalMemoryHandleDesc.handle.win32.handle = (void*)handle.handleValue;
     externalMemoryHandleDesc.size = size;
diff --git a/tools/gfx/cuda/cuda-shader-object.cpp b/tools/gfx/cuda/cuda-shader-object.cpp
index e7033e403..d1278f02b 100644
--- a/tools/gfx/cuda/cuda-shader-object.cpp
+++ b/tools/gfx/cuda/cuda-shader-object.cpp
@@ -273,7 +273,8 @@ ShaderObjectImpl::setObject(ShaderOffset const& offset, IShaderObject* object)
         break;
     case slang::BindingType::ExistentialValue:
     case slang::BindingType::RawBuffer:
-    case slang::BindingType::MutableRawBuffer: break;
+    case slang::BindingType::MutableRawBuffer:
+        break;
     }
     return SLANG_OK;
 }
diff --git a/tools/gfx/d3d/d3d-swapchain.h b/tools/gfx/d3d/d3d-swapchain.h
index 49a4f1c99..8942a4e14 100644
--- a/tools/gfx/d3d/d3d-swapchain.h
+++ b/tools/gfx/d3d/d3d-swapchain.h
@@ -26,8 +26,10 @@ 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;
diff --git a/tools/gfx/d3d/d3d-util.cpp b/tools/gfx/d3d/d3d-util.cpp
index 9d32f8532..62e21ac24 100644
--- a/tools/gfx/d3d/d3d-util.cpp
+++ b/tools/gfx/d3d/d3d-util.cpp
@@ -29,12 +29,18 @@ using namespace Slang;
 {
     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;
 }
@@ -44,11 +50,15 @@ 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;
 }
@@ -57,11 +67,16 @@ 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;
 }
@@ -70,15 +85,24 @@ 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;
     }
 }
 
@@ -86,15 +110,24 @@ 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;
     }
 }
 
@@ -112,111 +145,195 @@ D3D12_DEPTH_STENCILOP_DESC D3DUtil::translateStencilOpDesc(DepthStencilOpDesc de
 {
     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;
+    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;
     }
 }
 
@@ -234,8 +351,10 @@ D3DUtil::calcResourceFormat(UsageType usage, Int usageFlags, DXGI_FORMAT format)
             {
                 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;
     }
@@ -260,9 +379,12 @@ D3DUtil::calcResourceFormat(UsageType usage, Int usageFlags, DXGI_FORMAT format)
                 {
                     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;
         }
@@ -275,8 +397,10 @@ D3DUtil::calcResourceFormat(UsageType usage, Int usageFlags, DXGI_FORMAT format)
                 {
                     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;
         }
@@ -289,8 +413,10 @@ D3DUtil::calcResourceFormat(UsageType usage, Int usageFlags, DXGI_FORMAT format)
                 {
                     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;
@@ -331,7 +457,8 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
         {
             return true;
         }
-    default: break;
+    default:
+        break;
     }
     return false;
 }
@@ -387,9 +514,11 @@ bool D3DUtil::isTypeless(DXGI_FORMAT format)
         {
             return 5;
         }
-    case DXGI_FORMAT_B4G4R4A4_UNORM: return 4;
+    case DXGI_FORMAT_B4G4R4A4_UNORM:
+        return 4;
 
-    default: return 0;
+    default:
+        return 0;
     }
 }
 
@@ -593,8 +722,10 @@ 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;
     }
 }
 
@@ -628,8 +759,10 @@ 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;
     }
 }
 
@@ -638,19 +771,28 @@ 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;
     }
 }
 
@@ -658,8 +800,10 @@ 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;
@@ -670,9 +814,13 @@ 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;
     }
 }
 
@@ -680,10 +828,15 @@ 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;
     }
 }
 
@@ -691,12 +844,19 @@ 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;
     }
 }
 
@@ -704,24 +864,43 @@ 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;
     }
 }
 
@@ -744,33 +923,52 @@ 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;
+    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;
     }
 }
 
diff --git a/tools/gfx/d3d11/d3d11-device.cpp b/tools/gfx/d3d11/d3d11-device.cpp
index 8fe3bf589..ab4670a17 100644
--- a/tools/gfx/d3d11/d3d11-device.cpp
+++ b/tools/gfx/d3d11/d3d11-device.cpp
@@ -660,7 +660,8 @@ Result DeviceImpl::createTextureResource(
             texture->m_resource = texture3D;
             break;
         }
-    default: return SLANG_FAIL;
+    default:
+        return SLANG_FAIL;
     }
 
     returnComPtr(outResource, texture);
@@ -722,7 +723,8 @@ Result DeviceImpl::createBufferResource(
             bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
             break;
         }
-    default: break;
+    default:
+        break;
     }
 
     if (bufferDesc.BindFlags & (D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE))
@@ -818,7 +820,8 @@ Result DeviceImpl::createTextureView(
 
     switch (desc.type)
     {
-    default: return SLANG_FAIL;
+    default:
+        return SLANG_FAIL;
 
     case IResourceView::Type::RenderTarget:
         {
@@ -920,7 +923,8 @@ Result DeviceImpl::createBufferView(
 
     switch (desc.type)
     {
-    default: return SLANG_FAIL;
+    default:
+        return SLANG_FAIL;
 
     case IResourceView::Type::UnorderedAccess:
         {
@@ -1056,11 +1060,20 @@ Result DeviceImpl::createInputLayout(IInputLayout::Desc const& desc, IInputLayou
         switch (inputElementsIn[ii].format)
         {
         case Format::R32G32B32A32_FLOAT:
-        case Format::R8G8B8A8_UNORM:     typeName = "float4"; break;
-        case Format::R32G32B32_FLOAT:    typeName = "float3"; break;
-        case Format::R32G32_FLOAT:       typeName = "float2"; break;
-        case Format::R32_FLOAT:          typeName = "float"; break;
-        default:                         return SLANG_FAIL;
+        case Format::R8G8B8A8_UNORM:
+            typeName = "float4";
+            break;
+        case Format::R32G32B32_FLOAT:
+            typeName = "float3";
+            break;
+        case Format::R32G32_FLOAT:
+            typeName = "float2";
+            break;
+        case Format::R32_FLOAT:
+            typeName = "float";
+            break;
+        default:
+            return SLANG_FAIL;
         }
 
         hlslCursor += sprintf(
@@ -1117,10 +1130,17 @@ void* DeviceImpl::map(IBufferResource* bufferIn, MapFlavor flavor)
 
     switch (flavor)
     {
-    case MapFlavor::WriteDiscard: mapType = D3D11_MAP_WRITE_DISCARD; break;
-    case MapFlavor::HostWrite:    mapType = D3D11_MAP_WRITE_NO_OVERWRITE; break;
-    case MapFlavor::HostRead:     mapType = D3D11_MAP_READ; break;
-    default:                      return nullptr;
+    case MapFlavor::WriteDiscard:
+        mapType = D3D11_MAP_WRITE_DISCARD;
+        break;
+    case MapFlavor::HostWrite:
+        mapType = D3D11_MAP_WRITE_NO_OVERWRITE;
+        break;
+    case MapFlavor::HostRead:
+        mapType = D3D11_MAP_READ;
+        break;
+    default:
+        return nullptr;
     }
 
     bufferResource->m_mapFlavor = flavor;
@@ -1292,7 +1312,8 @@ void DeviceImpl::setPipelineState(IPipelineState* state)
 
     switch (pipelineType)
     {
-    default: break;
+    default:
+        break;
 
     case PipelineType::Graphics:
         {
@@ -1482,7 +1503,8 @@ Result DeviceImpl::createProgram(
                 nullptr,
                 shaderProgram->m_pixelShader.writeRef()));
             break;
-        default: SLANG_ASSERT(!"pipeline stage not implemented");
+        default:
+            SLANG_ASSERT(!"pipeline stage not implemented");
         }
     }
     returnComPtr(outProgram, shaderProgram);
diff --git a/tools/gfx/d3d11/d3d11-helper-functions.cpp b/tools/gfx/d3d11/d3d11-helper-functions.cpp
index 76b339880..e955e75a0 100644
--- a/tools/gfx/d3d11/d3d11-helper-functions.cpp
+++ b/tools/gfx/d3d11/d3d11-helper-functions.cpp
@@ -28,18 +28,27 @@ D3D11_BIND_FLAG calcResourceFlag(ResourceState state)
 {
     switch (state)
     {
-    case ResourceState::VertexBuffer:           return D3D11_BIND_VERTEX_BUFFER;
-    case ResourceState::IndexBuffer:            return D3D11_BIND_INDEX_BUFFER;
-    case ResourceState::ConstantBuffer:         return D3D11_BIND_CONSTANT_BUFFER;
-    case ResourceState::StreamOutput:           return D3D11_BIND_STREAM_OUTPUT;
-    case ResourceState::RenderTarget:           return D3D11_BIND_RENDER_TARGET;
+    case ResourceState::VertexBuffer:
+        return D3D11_BIND_VERTEX_BUFFER;
+    case ResourceState::IndexBuffer:
+        return D3D11_BIND_INDEX_BUFFER;
+    case ResourceState::ConstantBuffer:
+        return D3D11_BIND_CONSTANT_BUFFER;
+    case ResourceState::StreamOutput:
+        return D3D11_BIND_STREAM_OUTPUT;
+    case ResourceState::RenderTarget:
+        return D3D11_BIND_RENDER_TARGET;
     case ResourceState::DepthRead:
-    case ResourceState::DepthWrite:             return D3D11_BIND_DEPTH_STENCIL;
-    case ResourceState::UnorderedAccess:        return D3D11_BIND_UNORDERED_ACCESS;
+    case ResourceState::DepthWrite:
+        return D3D11_BIND_DEPTH_STENCIL;
+    case ResourceState::UnorderedAccess:
+        return D3D11_BIND_UNORDERED_ACCESS;
     case ResourceState::ShaderResource:
     case ResourceState::PixelShaderResource:
-    case ResourceState::NonPixelShaderResource: return D3D11_BIND_SHADER_RESOURCE;
-    default:                                    return D3D11_BIND_FLAG(0);
+    case ResourceState::NonPixelShaderResource:
+        return D3D11_BIND_SHADER_RESOURCE;
+    default:
+        return D3D11_BIND_FLAG(0);
     }
 }
 
@@ -59,10 +68,15 @@ int _calcResourceAccessFlags(MemoryType memType)
 {
     switch (memType)
     {
-    case MemoryType::DeviceLocal: return 0;
-    case MemoryType::ReadBack:    return D3D11_CPU_ACCESS_READ;
-    case MemoryType::Upload:      return D3D11_CPU_ACCESS_WRITE;
-    default:                      assert(!"Invalid flags"); return 0;
+    case MemoryType::DeviceLocal:
+        return 0;
+    case MemoryType::ReadBack:
+        return D3D11_CPU_ACCESS_READ;
+    case MemoryType::Upload:
+        return D3D11_CPU_ACCESS_WRITE;
+    default:
+        assert(!"Invalid flags");
+        return 0;
     }
 }
 
@@ -70,10 +84,12 @@ D3D11_FILTER_TYPE translateFilterMode(TextureFilteringMode mode)
 {
     switch (mode)
     {
-    default: return D3D11_FILTER_TYPE(0);
+    default:
+        return D3D11_FILTER_TYPE(0);
 
-#define CASE(SRC, DST) \
-    case TextureFilteringMode::SRC: return D3D11_FILTER_TYPE_##DST
+#define CASE(SRC, DST)              \
+    case TextureFilteringMode::SRC: \
+        return D3D11_FILTER_TYPE_##DST
 
         CASE(Point, POINT);
         CASE(Linear, LINEAR);
@@ -86,10 +102,12 @@ D3D11_FILTER_REDUCTION_TYPE translateFilterReduction(TextureReductionOp op)
 {
     switch (op)
     {
-    default: return D3D11_FILTER_REDUCTION_TYPE(0);
+    default:
+        return D3D11_FILTER_REDUCTION_TYPE(0);
 
-#define CASE(SRC, DST) \
-    case TextureReductionOp::SRC: return D3D11_FILTER_REDUCTION_TYPE_##DST
+#define CASE(SRC, DST)            \
+    case TextureReductionOp::SRC: \
+        return D3D11_FILTER_REDUCTION_TYPE_##DST
 
         CASE(Average, STANDARD);
         CASE(Comparison, COMPARISON);
@@ -104,10 +122,12 @@ D3D11_TEXTURE_ADDRESS_MODE translateAddressingMode(TextureAddressingMode mode)
 {
     switch (mode)
     {
-    default: return D3D11_TEXTURE_ADDRESS_MODE(0);
+    default:
+        return D3D11_TEXTURE_ADDRESS_MODE(0);
 
-#define CASE(SRC, DST) \
-    case TextureAddressingMode::SRC: return D3D11_TEXTURE_ADDRESS_##DST
+#define CASE(SRC, DST)               \
+    case TextureAddressingMode::SRC: \
+        return D3D11_TEXTURE_ADDRESS_##DST
 
         CASE(Wrap, WRAP);
         CASE(ClampToEdge, CLAMP);
@@ -127,8 +147,9 @@ D3D11_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func)
         // TODO: need to report failures
         return D3D11_COMPARISON_ALWAYS;
 
-#define CASE(FROM, TO) \
-    case ComparisonFunc::FROM: return D3D11_COMPARISON_##TO
+#define CASE(FROM, TO)         \
+    case ComparisonFunc::FROM: \
+        return D3D11_COMPARISON_##TO
 
         CASE(Never, NEVER);
         CASE(Less, LESS);
@@ -150,8 +171,9 @@ D3D11_STENCIL_OP translateStencilOp(StencilOp op)
         // TODO: need to report failures
         return D3D11_STENCIL_OP_KEEP;
 
-#define CASE(FROM, TO) \
-    case StencilOp::FROM: return D3D11_STENCIL_OP_##TO
+#define CASE(FROM, TO)    \
+    case StencilOp::FROM: \
+        return D3D11_STENCIL_OP_##TO
 
         CASE(Keep, KEEP);
         CASE(Zero, ZERO);
@@ -173,8 +195,10 @@ D3D11_FILL_MODE translateFillMode(FillMode mode)
         // TODO: need to report failures
         return D3D11_FILL_SOLID;
 
-    case FillMode::Solid:     return D3D11_FILL_SOLID;
-    case FillMode::Wireframe: return D3D11_FILL_WIREFRAME;
+    case FillMode::Solid:
+        return D3D11_FILL_SOLID;
+    case FillMode::Wireframe:
+        return D3D11_FILL_WIREFRAME;
     }
 }
 
@@ -186,9 +210,12 @@ D3D11_CULL_MODE translateCullMode(CullMode mode)
         // TODO: need to report failures
         return D3D11_CULL_NONE;
 
-    case CullMode::None:  return D3D11_CULL_NONE;
-    case CullMode::Back:  return D3D11_CULL_BACK;
-    case CullMode::Front: return D3D11_CULL_FRONT;
+    case CullMode::None:
+        return D3D11_CULL_NONE;
+    case CullMode::Back:
+        return D3D11_CULL_BACK;
+    case CullMode::Front:
+        return D3D11_CULL_FRONT;
     }
 }
 
@@ -208,10 +235,13 @@ D3D11_BLEND_OP translateBlendOp(BlendOp op)
 {
     switch (op)
     {
-    default: assert(!"unimplemented"); return (D3D11_BLEND_OP)-1;
+    default:
+        assert(!"unimplemented");
+        return (D3D11_BLEND_OP)-1;
 
-#define CASE(FROM, TO) \
-    case BlendOp::FROM: return D3D11_BLEND_OP_##TO
+#define CASE(FROM, TO)  \
+    case BlendOp::FROM: \
+        return D3D11_BLEND_OP_##TO
         CASE(Add, ADD);
         CASE(Subtract, SUBTRACT);
         CASE(ReverseSubtract, REV_SUBTRACT);
@@ -225,10 +255,13 @@ D3D11_BLEND translateBlendFactor(BlendFactor factor)
 {
     switch (factor)
     {
-    default: assert(!"unimplemented"); return (D3D11_BLEND)-1;
+    default:
+        assert(!"unimplemented");
+        return (D3D11_BLEND)-1;
 
-#define CASE(FROM, TO) \
-    case BlendFactor::FROM: return D3D11_BLEND_##TO
+#define CASE(FROM, TO)      \
+    case BlendFactor::FROM: \
+        return D3D11_BLEND_##TO
         CASE(Zero, ZERO);
         CASE(One, ONE);
         CASE(SrcColor, SRC_COLOR);
@@ -293,7 +326,8 @@ void initSrvDesc(
         case IResource::Type::Texture3D:
             descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
             break;
-        default: assert(!"Unknown dimension");
+        default:
+            assert(!"Unknown dimension");
         }
 
         descOut.Texture2D.MipLevels = textureDesc.numMipLevels;
@@ -334,7 +368,8 @@ void initSrvDesc(
             descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
             break;
 
-        default: assert(!"Unknown dimension");
+        default:
+            assert(!"Unknown dimension");
         }
 
         descOut.Texture2DArray.ArraySize = std::max(textureDesc.size.depth, arraySize);
diff --git a/tools/gfx/d3d11/d3d11-query.cpp b/tools/gfx/d3d11/d3d11-query.cpp
index 1a1c27466..8c55d727e 100644
--- a/tools/gfx/d3d11/d3d11-query.cpp
+++ b/tools/gfx/d3d11/d3d11-query.cpp
@@ -17,8 +17,11 @@ Result QueryPoolImpl::init(const IQueryPool::Desc& desc, DeviceImpl* device)
     m_queryDesc.MiscFlags = 0;
     switch (desc.type)
     {
-    case QueryType::Timestamp: m_queryDesc.Query = D3D11_QUERY_TIMESTAMP; break;
-    default:                   return SLANG_E_INVALID_ARG;
+    case QueryType::Timestamp:
+        m_queryDesc.Query = D3D11_QUERY_TIMESTAMP;
+        break;
+    default:
+        return SLANG_E_INVALID_ARG;
     }
     m_queries.setCount(desc.count);
     return SLANG_OK;
diff --git a/tools/gfx/d3d11/d3d11-shader-object-layout.cpp b/tools/gfx/d3d11/d3d11-shader-object-layout.cpp
index b2b851760..4cb156f2d 100644
--- a/tools/gfx/d3d11/d3d11-shader-object-layout.cpp
+++ b/tools/gfx/d3d11/d3d11-shader-object-layout.cpp
@@ -90,7 +90,8 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(
             m_samplerRanges.add(r);
             break;
 
-        case slang::BindingType::CombinedTextureSampler: break;
+        case slang::BindingType::CombinedTextureSampler:
+            break;
         case slang::BindingType::MutableTexture:
         case slang::BindingType::MutableTypedBuffer:
             bindingRangeInfo.baseIndex = m_uavCount;
@@ -98,9 +99,11 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(
             m_uavRanges.add(r);
             break;
 
-        case slang::BindingType::VaryingInput: break;
+        case slang::BindingType::VaryingInput:
+            break;
 
-        case slang::BindingType::VaryingOutput: break;
+        case slang::BindingType::VaryingOutput:
+            break;
 
         default:
             bindingRangeInfo.baseIndex = m_srvCount;
diff --git a/tools/gfx/d3d11/d3d11-shader-object.cpp b/tools/gfx/d3d11/d3d11-shader-object.cpp
index 697d463fb..cb882b701 100644
--- a/tools/gfx/d3d11/d3d11-shader-object.cpp
+++ b/tools/gfx/d3d11/d3d11-shader-object.cpp
@@ -478,7 +478,8 @@ Result ShaderObjectImpl::bindAsValue(
             }
             break;
 
-        default: break;
+        default:
+            break;
         }
     }
 
diff --git a/tools/gfx/d3d12/d3d12-command-encoder.cpp b/tools/gfx/d3d12/d3d12-command-encoder.cpp
index f0b4b0dfc..bed31f2f5 100644
--- a/tools/gfx/d3d12/d3d12-command-encoder.cpp
+++ b/tools/gfx/d3d12/d3d12-command-encoder.cpp
@@ -24,10 +24,15 @@ int PipelineCommandEncoder::getBindPointIndex(PipelineType type)
 {
     switch (type)
     {
-    case PipelineType::Graphics:   return 0;
-    case PipelineType::Compute:    return 1;
-    case PipelineType::RayTracing: return 2;
-    default:                       assert(!"unknown pipeline type."); return -1;
+    case PipelineType::Graphics:
+        return 0;
+    case PipelineType::Compute:
+        return 1;
+    case PipelineType::RayTracing:
+        return 2;
+    default:
+        assert(!"unknown pipeline type.");
+        return -1;
     }
 }
 
@@ -124,7 +129,9 @@ Result PipelineCommandEncoder::_bindRenderState(
             d3dheap = m_transientHeap->getCurrentSamplerHeap().getHeap();
             m_commandBuffer->bindDescriptorHeaps();
             break;
-        default: assert(!"shouldn't be here"); return SLANG_FAIL;
+        default:
+            assert(!"shouldn't be here");
+            return SLANG_FAIL;
         }
 
         // Try again.
@@ -456,7 +463,8 @@ void ResourceCommandEncoderImpl::clearResourceView(
             }
             break;
         }
-    default: break;
+    default:
+        break;
     }
 }
 
diff --git a/tools/gfx/d3d12/d3d12-descriptor-heap.h b/tools/gfx/d3d12/d3d12-descriptor-heap.h
index 44d03b5b0..fc426237c 100644
--- a/tools/gfx/d3d12/d3d12-descriptor-heap.h
+++ b/tools/gfx/d3d12/d3d12-descriptor-heap.h
@@ -399,31 +399,44 @@ struct DescriptorHeapReference
     {
         switch (type)
         {
-        case Type::Linear:           return ptr.linearHeap->getCpuHandle(index);
-        case Type::General:          return ptr.generalHeap->getCpuHandle(index);
-        case Type::ExpandingGeneral: return ptr.generalExpandingHeap->getCpuHandle(index);
-        case Type::ExpandingLinear:  return ptr.linearExpandingHeap->getCpuHandle(index);
-        default:                     return D3D12_CPU_DESCRIPTOR_HANDLE();
+        case Type::Linear:
+            return ptr.linearHeap->getCpuHandle(index);
+        case Type::General:
+            return ptr.generalHeap->getCpuHandle(index);
+        case Type::ExpandingGeneral:
+            return ptr.generalExpandingHeap->getCpuHandle(index);
+        case Type::ExpandingLinear:
+            return ptr.linearExpandingHeap->getCpuHandle(index);
+        default:
+            return D3D12_CPU_DESCRIPTOR_HANDLE();
         }
     }
     D3D12_GPU_DESCRIPTOR_HANDLE getGpuHandle(int index) const
     {
         switch (type)
         {
-        case Type::Linear:           return ptr.linearHeap->getGpuHandle(index);
-        case Type::General:          return ptr.generalHeap->getGpuHandle(index);
-        case Type::ExpandingGeneral: return ptr.generalExpandingHeap->getGpuHandle(index);
-        default:                     return D3D12_GPU_DESCRIPTOR_HANDLE();
+        case Type::Linear:
+            return ptr.linearHeap->getGpuHandle(index);
+        case Type::General:
+            return ptr.generalHeap->getGpuHandle(index);
+        case Type::ExpandingGeneral:
+            return ptr.generalExpandingHeap->getGpuHandle(index);
+        default:
+            return D3D12_GPU_DESCRIPTOR_HANDLE();
         }
     }
     int allocate(int numDescriptors)
     {
         switch (type)
         {
-        case Type::Linear:           return ptr.linearHeap->allocate(numDescriptors);
-        case Type::General:          return ptr.generalHeap->allocate(numDescriptors);
-        case Type::ExpandingGeneral: return ptr.generalExpandingHeap->allocate(numDescriptors);
-        default:                     return ptr.linearExpandingHeap->allocate(numDescriptors);
+        case Type::Linear:
+            return ptr.linearHeap->allocate(numDescriptors);
+        case Type::General:
+            return ptr.generalHeap->allocate(numDescriptors);
+        case Type::ExpandingGeneral:
+            return ptr.generalExpandingHeap->allocate(numDescriptors);
+        default:
+            return ptr.linearExpandingHeap->allocate(numDescriptors);
         }
     }
     void free(int index, int count)
@@ -431,19 +444,27 @@ struct DescriptorHeapReference
         switch (type)
         {
         default:
-        case Type::Linear:           SLANG_ASSERT(!"Linear heap does not support free()."); break;
-        case Type::General:          return ptr.generalHeap->free(index, count);
-        case Type::ExpandingGeneral: return ptr.generalExpandingHeap->free(index, count);
+        case Type::Linear:
+            SLANG_ASSERT(!"Linear heap does not support free().");
+            break;
+        case Type::General:
+            return ptr.generalHeap->free(index, count);
+        case Type::ExpandingGeneral:
+            return ptr.generalExpandingHeap->free(index, count);
         }
     }
     void freeIfSupported(int index, int count)
     {
         switch (type)
         {
-        case Type::Linear:           return;
-        case Type::General:          return ptr.generalHeap->free(index, count);
-        case Type::ExpandingGeneral: return ptr.generalExpandingHeap->free(index, count);
-        default:                     break;
+        case Type::Linear:
+            return;
+        case Type::General:
+            return ptr.generalHeap->free(index, count);
+        case Type::ExpandingGeneral:
+            return ptr.generalExpandingHeap->free(index, count);
+        default:
+            break;
         }
     }
 };
diff --git a/tools/gfx/d3d12/d3d12-device.cpp b/tools/gfx/d3d12/d3d12-device.cpp
index f2b24ab5f..cb5404961 100644
--- a/tools/gfx/d3d12/d3d12-device.cpp
+++ b/tools/gfx/d3d12/d3d12-device.cpp
@@ -124,7 +124,8 @@ Result DeviceImpl::createBuffer(
         if (initialState != D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE)
             initialState = D3D12_RESOURCE_STATE_COMMON;
         break;
-    default: return SLANG_FAIL;
+    default:
+        return SLANG_FAIL;
     }
 
     // Create the resource.
@@ -774,7 +775,8 @@ Result DeviceImpl::initialize(const Desc& desc)
                 case D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_1:
                     m_features.add("programmable-sample-positions-1");
                     break;
-                default: break;
+                default:
+                    break;
                 }
             }
         }
@@ -1436,7 +1438,8 @@ Result DeviceImpl::createTextureView(
     bool isMultiSample = resourceImpl ? resourceImpl->getDesc()->sampleDesc.numSamples > 1 : false;
     switch (desc.type)
     {
-    default: return SLANG_FAIL;
+    default:
+        return SLANG_FAIL;
 
     case IResourceView::Type::RenderTarget:
         {
@@ -1516,8 +1519,11 @@ Result DeviceImpl::createTextureView(
                 rtvDesc.Texture3D.WSize =
                     (desc.subresourceRange.layerCount == 0) ? -1 : desc.subresourceRange.layerCount;
                 break;
-            case IResource::Type::Buffer: rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_BUFFER; break;
-            default:                      return SLANG_FAIL;
+            case IResource::Type::Buffer:
+                rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_BUFFER;
+                break;
+            default:
+                return SLANG_FAIL;
             }
             m_device->CreateRenderTargetView(
                 resourceImpl ? resourceImpl->m_resource.getResource() : nullptr,
@@ -1561,7 +1567,8 @@ Result DeviceImpl::createTextureView(
                 dsvDesc.Texture2DArray.ArraySize = desc.subresourceRange.layerCount;
                 dsvDesc.Texture2DArray.FirstArraySlice = desc.subresourceRange.baseArrayLayer;
                 break;
-            default: return SLANG_FAIL;
+            default:
+                return SLANG_FAIL;
             }
             m_device->CreateDepthStencilView(
                 resourceImpl ? resourceImpl->m_resource.getResource() : nullptr,
@@ -1637,7 +1644,8 @@ Result DeviceImpl::createTextureView(
                 d3d12desc.Texture3D.WSize =
                     resourceDesc.size.depth >> desc.subresourceRange.mipLevel;
                 break;
-            default: return SLANG_FAIL;
+            default:
+                return SLANG_FAIL;
             }
             m_device->CreateUnorderedAccessView(
                 resourceImpl->m_resource,
diff --git a/tools/gfx/d3d12/d3d12-helper-functions.cpp b/tools/gfx/d3d12/d3d12-helper-functions.cpp
index 3ce9b872e..9d218dae0 100644
--- a/tools/gfx/d3d12/d3d12-helper-functions.cpp
+++ b/tools/gfx/d3d12/d3d12-helper-functions.cpp
@@ -42,12 +42,16 @@ D3D12_RESOURCE_FLAGS calcResourceFlag(ResourceState state)
 {
     switch (state)
     {
-    case ResourceState::RenderTarget:          return D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+    case ResourceState::RenderTarget:
+        return D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
     case ResourceState::DepthRead:
-    case ResourceState::DepthWrite:            return D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
+    case ResourceState::DepthWrite:
+        return D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
     case ResourceState::UnorderedAccess:
-    case ResourceState::AccelerationStructure: return D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
-    default:                                   return D3D12_RESOURCE_FLAG_NONE;
+    case ResourceState::AccelerationStructure:
+        return D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+    default:
+        return D3D12_RESOURCE_FLAG_NONE;
     }
 }
 
@@ -67,15 +71,19 @@ D3D12_RESOURCE_DIMENSION calcResourceDimension(IResource::Type type)
 {
     switch (type)
     {
-    case IResource::Type::Buffer:    return D3D12_RESOURCE_DIMENSION_BUFFER;
-    case IResource::Type::Texture1D: return D3D12_RESOURCE_DIMENSION_TEXTURE1D;
+    case IResource::Type::Buffer:
+        return D3D12_RESOURCE_DIMENSION_BUFFER;
+    case IResource::Type::Texture1D:
+        return D3D12_RESOURCE_DIMENSION_TEXTURE1D;
     case IResource::Type::TextureCube:
     case IResource::Type::Texture2D:
         {
             return D3D12_RESOURCE_DIMENSION_TEXTURE2D;
         }
-    case IResource::Type::Texture3D: return D3D12_RESOURCE_DIMENSION_TEXTURE3D;
-    default:                         return D3D12_RESOURCE_DIMENSION_UNKNOWN;
+    case IResource::Type::Texture3D:
+        return D3D12_RESOURCE_DIMENSION_TEXTURE3D;
+    default:
+        return D3D12_RESOURCE_DIMENSION_UNKNOWN;
     }
 }
 
@@ -83,12 +91,16 @@ DXGI_FORMAT getTypelessFormatFromDepthFormat(Format format)
 {
     switch (format)
     {
-    case Format::D16_UNORM:         return DXGI_FORMAT_R16_TYPELESS;
-    case Format::D32_FLOAT:         return DXGI_FORMAT_R32_TYPELESS;
-    case Format::D32_FLOAT_S8_UINT: return DXGI_FORMAT_R32G8X24_TYPELESS;
+    case Format::D16_UNORM:
+        return DXGI_FORMAT_R16_TYPELESS;
+    case Format::D32_FLOAT:
+        return DXGI_FORMAT_R32_TYPELESS;
+    case Format::D32_FLOAT_S8_UINT:
+        return DXGI_FORMAT_R32G8X24_TYPELESS;
     // case Format::D24_UNORM_S8_UINT:
     //     return DXGI_FORMAT_R24G8_TYPELESS;
-    default: return D3DUtil::getMapFormat(format);
+    default:
+        return D3DUtil::getMapFormat(format);
     }
 }
 
@@ -99,8 +111,10 @@ bool isTypelessDepthFormat(DXGI_FORMAT format)
     case DXGI_FORMAT_R16_TYPELESS:
     case DXGI_FORMAT_R32_TYPELESS:
     case DXGI_FORMAT_R32G8X24_TYPELESS:
-    case DXGI_FORMAT_R24G8_TYPELESS:    return true;
-    default:                            return false;
+    case DXGI_FORMAT_R24G8_TYPELESS:
+        return true;
+    default:
+        return false;
     }
 }
 
@@ -108,10 +122,12 @@ D3D12_FILTER_TYPE translateFilterMode(TextureFilteringMode mode)
 {
     switch (mode)
     {
-    default: return D3D12_FILTER_TYPE(0);
+    default:
+        return D3D12_FILTER_TYPE(0);
 
-#define CASE(SRC, DST) \
-    case TextureFilteringMode::SRC: return D3D12_FILTER_TYPE_##DST
+#define CASE(SRC, DST)              \
+    case TextureFilteringMode::SRC: \
+        return D3D12_FILTER_TYPE_##DST
 
         CASE(Point, POINT);
         CASE(Linear, LINEAR);
@@ -124,10 +140,12 @@ D3D12_FILTER_REDUCTION_TYPE translateFilterReduction(TextureReductionOp op)
 {
     switch (op)
     {
-    default: return D3D12_FILTER_REDUCTION_TYPE(0);
+    default:
+        return D3D12_FILTER_REDUCTION_TYPE(0);
 
-#define CASE(SRC, DST) \
-    case TextureReductionOp::SRC: return D3D12_FILTER_REDUCTION_TYPE_##DST
+#define CASE(SRC, DST)            \
+    case TextureReductionOp::SRC: \
+        return D3D12_FILTER_REDUCTION_TYPE_##DST
 
         CASE(Average, STANDARD);
         CASE(Comparison, COMPARISON);
@@ -142,10 +160,12 @@ D3D12_TEXTURE_ADDRESS_MODE translateAddressingMode(TextureAddressingMode mode)
 {
     switch (mode)
     {
-    default: return D3D12_TEXTURE_ADDRESS_MODE(0);
+    default:
+        return D3D12_TEXTURE_ADDRESS_MODE(0);
 
-#define CASE(SRC, DST) \
-    case TextureAddressingMode::SRC: return D3D12_TEXTURE_ADDRESS_MODE_##DST
+#define CASE(SRC, DST)               \
+    case TextureAddressingMode::SRC: \
+        return D3D12_TEXTURE_ADDRESS_MODE_##DST
 
         CASE(Wrap, WRAP);
         CASE(ClampToEdge, CLAMP);
@@ -165,8 +185,9 @@ D3D12_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func)
         // TODO: need to report failures
         return D3D12_COMPARISON_FUNC_ALWAYS;
 
-#define CASE(FROM, TO) \
-    case ComparisonFunc::FROM: return D3D12_COMPARISON_FUNC_##TO
+#define CASE(FROM, TO)         \
+    case ComparisonFunc::FROM: \
+        return D3D12_COMPARISON_FUNC_##TO
 
         CASE(Never, NEVER);
         CASE(Less, LESS);
@@ -236,7 +257,8 @@ void initSrvDesc(
                                               : subresourceRange.mipLevelCount;
             descOut.Texture3D.MostDetailedMip = subresourceRange.mipLevel;
             break;
-        default: assert(!"Unknown dimension");
+        default:
+            assert(!"Unknown dimension");
         }
     }
     else if (resourceType == IResource::Type::TextureCube)
@@ -324,7 +346,8 @@ void initSrvDesc(
                                               : subresourceRange.mipLevelCount;
             break;
 
-        default: assert(!"Unknown dimension");
+        default:
+            assert(!"Unknown dimension");
         }
     }
 }
@@ -503,16 +526,24 @@ Result createNullDescriptor(
             srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
             switch (bindingRange.resourceShape)
             {
-            case SLANG_TEXTURE_1D: srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1D; break;
+            case SLANG_TEXTURE_1D:
+                srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1D;
+                break;
             case SLANG_TEXTURE_1D_ARRAY:
                 srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1DARRAY;
                 break;
-            case SLANG_TEXTURE_2D: srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; break;
+            case SLANG_TEXTURE_2D:
+                srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
+                break;
             case SLANG_TEXTURE_2D_ARRAY:
                 srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
                 break;
-            case SLANG_TEXTURE_3D:   srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D; break;
-            case SLANG_TEXTURE_CUBE: srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE; break;
+            case SLANG_TEXTURE_3D:
+                srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D;
+                break;
+            case SLANG_TEXTURE_CUBE:
+                srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
+                break;
             case SLANG_TEXTURE_CUBE_ARRAY:
                 srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
                 break;
@@ -522,7 +553,8 @@ Result createNullDescriptor(
             case SLANG_TEXTURE_2D_MULTISAMPLE_ARRAY:
                 srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY;
                 break;
-            default: return SLANG_OK;
+            default:
+                return SLANG_OK;
             }
             d3dDevice->CreateShaderResourceView(nullptr, &srvDesc, destDescriptor);
         }
@@ -533,25 +565,33 @@ Result createNullDescriptor(
             uavDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
             switch (bindingRange.resourceShape)
             {
-            case SLANG_TEXTURE_1D: uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE1D; break;
+            case SLANG_TEXTURE_1D:
+                uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE1D;
+                break;
             case SLANG_TEXTURE_1D_ARRAY:
                 uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE1DARRAY;
                 break;
-            case SLANG_TEXTURE_2D: uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D; break;
+            case SLANG_TEXTURE_2D:
+                uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
+                break;
             case SLANG_TEXTURE_2D_ARRAY:
                 uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
                 break;
-            case SLANG_TEXTURE_3D:                   uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE3D; break;
+            case SLANG_TEXTURE_3D:
+                uavDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE3D;
+                break;
             case SLANG_TEXTURE_CUBE:
             case SLANG_TEXTURE_CUBE_ARRAY:
             case SLANG_TEXTURE_2D_MULTISAMPLE:
             case SLANG_TEXTURE_2D_MULTISAMPLE_ARRAY:
-            default:                                 return SLANG_OK;
+            default:
+                return SLANG_OK;
             }
             d3dDevice->CreateUnorderedAccessView(nullptr, nullptr, &uavDesc, destDescriptor);
         }
         break;
-    default: break;
+    default:
+        break;
     }
     return SLANG_OK;
 }
diff --git a/tools/gfx/d3d12/d3d12-query.cpp b/tools/gfx/d3d12/d3d12-query.cpp
index d0191e349..85f326b6e 100644
--- a/tools/gfx/d3d12/d3d12-query.cpp
+++ b/tools/gfx/d3d12/d3d12-query.cpp
@@ -25,7 +25,8 @@ Result QueryPoolImpl::init(const IQueryPool::Desc& desc, DeviceImpl* device)
         heapDesc.Type = D3D12_QUERY_HEAP_TYPE_TIMESTAMP;
         m_queryType = D3D12_QUERY_TYPE_TIMESTAMP;
         break;
-    default: return SLANG_E_INVALID_ARG;
+    default:
+        return SLANG_E_INVALID_ARG;
     }
 
     // Create query heap.
diff --git a/tools/gfx/d3d12/d3d12-resource-views.cpp b/tools/gfx/d3d12/d3d12-resource-views.cpp
index a760caef8..1e1439d66 100644
--- a/tools/gfx/d3d12/d3d12-resource-views.cpp
+++ b/tools/gfx/d3d12/d3d12-resource-views.cpp
@@ -40,7 +40,8 @@ SlangResult createD3D12BufferDescriptor(
 
     switch (desc.type)
     {
-    default: return SLANG_FAIL;
+    default:
+        return SLANG_FAIL;
 
     case IResourceView::Type::UnorderedAccess:
         {
diff --git a/tools/gfx/d3d12/d3d12-shader-object-layout.cpp b/tools/gfx/d3d12/d3d12-shader-object-layout.cpp
index ad60fb12d..6cf51ee2b 100644
--- a/tools/gfx/d3d12/d3d12-shader-object-layout.cpp
+++ b/tools/gfx/d3d12/d3d12-shader-object-layout.cpp
@@ -198,7 +198,8 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(
                 break;
 
             case slang::BindingType::VaryingInput:
-            case slang::BindingType::VaryingOutput: break;
+            case slang::BindingType::VaryingOutput:
+                break;
 
             default:
                 bindingRangeInfo.baseIndex = m_ownCounts.resource;
@@ -491,7 +492,8 @@ Result RootShaderObjectLayoutImpl::RootSignatureDescBuilder::translateDescriptor
     case slang::BindingType::Sampler:
         *outType = D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER;
         return SLANG_OK;
-    default: return SLANG_FAIL;
+    default:
+        return SLANG_FAIL;
     }
 }
 
@@ -748,9 +750,11 @@ void RootShaderObjectLayoutImpl::RootSignatureDescBuilder::addAsValue(
         {
         case slang::BindingType::ConstantBuffer:
         case slang::BindingType::ParameterBlock:
-        case slang::BindingType::ExistentialValue: continue;
+        case slang::BindingType::ExistentialValue:
+            continue;
 
-        default: break;
+        default:
+            break;
         }
 
         // For binding ranges that don't represent sub-objects, we will add
diff --git a/tools/gfx/d3d12/d3d12-shader-object.cpp b/tools/gfx/d3d12/d3d12-shader-object.cpp
index 77d3553ba..cd4055804 100644
--- a/tools/gfx/d3d12/d3d12-shader-object.cpp
+++ b/tools/gfx/d3d12/d3d12-shader-object.cpp
@@ -850,7 +850,8 @@ Result ShaderObjectImpl::bindRootArguments(BindingContext* context, uint32_t& in
         case IResourceView::Type::UnorderedAccess:
             context->submitter->setRootUAV(index, m_rootArguments[i]);
             break;
-        default: continue;
+        default:
+            continue;
         }
         index++;
     }
diff --git a/tools/gfx/debug-layer/debug-command-encoder.cpp b/tools/gfx/debug-layer/debug-command-encoder.cpp
index f09130d98..f20c19864 100644
--- a/tools/gfx/debug-layer/debug-command-encoder.cpp
+++ b/tools/gfx/debug-layer/debug-command-encoder.cpp
@@ -351,7 +351,8 @@ void DebugResourceCommandEncoderImpl::clearResourceView(
     {
     case IResourceView::Type::DepthStencil:
     case IResourceView::Type::RenderTarget:
-    case IResourceView::Type::UnorderedAccess: break;
+    case IResourceView::Type::UnorderedAccess:
+        break;
     default:
         GFX_DIAGNOSE_ERROR_FORMAT(
             "Resource view %lld cannot be cleared. Only DepthStencil, "
diff --git a/tools/gfx/debug-layer/debug-helper-functions.cpp b/tools/gfx/debug-layer/debug-helper-functions.cpp
index adeff9d2e..0174ffd62 100644
--- a/tools/gfx/debug-layer/debug-helper-functions.cpp
+++ b/tools/gfx/debug-layer/debug-helper-functions.cpp
@@ -75,7 +75,8 @@ void validateAccelerationStructureBuildInputs(
                 case Format::R16G16B16A16_FLOAT:
                 case Format::R16G16_FLOAT:
                 case Format::R16G16B16A16_SNORM:
-                case Format::R16G16_SNORM:       break;
+                case Format::R16G16_SNORM:
+                    break;
                 default:
                     GFX_DIAGNOSE_ERROR(
                         "Unsupported "
@@ -89,7 +90,8 @@ void validateAccelerationStructureBuildInputs(
                     switch (buildInputs.geometryDescs[i].content.triangles.indexFormat)
                     {
                     case Format::R32_UINT:
-                    case Format::R16_UINT: break;
+                    case Format::R16_UINT:
+                        break;
                     default:
                         GFX_DIAGNOSE_ERROR(
                             "Unsupported "
@@ -149,7 +151,9 @@ void validateAccelerationStructureBuildInputs(
             }
         }
         break;
-    default: GFX_DIAGNOSE_ERROR("Invalid value of IAccelerationStructure::Kind."); break;
+    default:
+        GFX_DIAGNOSE_ERROR("Invalid value of IAccelerationStructure::Kind.");
+        break;
     }
 }
 
diff --git a/tools/gfx/immediate-renderer-base.cpp b/tools/gfx/immediate-renderer-base.cpp
index e993ce319..d210d9a0a 100644
--- a/tools/gfx/immediate-renderer-base.cpp
+++ b/tools/gfx/immediate-renderer-base.cpp
@@ -616,7 +616,9 @@ public:
                     (Format)cmd.operands[1],
                     (UInt)cmd.operands[2]);
                 break;
-            case CommandName::Draw: m_renderer->draw(cmd.operands[0], cmd.operands[1]); break;
+            case CommandName::Draw:
+                m_renderer->draw(cmd.operands[0], cmd.operands[1]);
+                break;
             case CommandName::DrawIndexed:
                 m_renderer->drawIndexed(cmd.operands[0], cmd.operands[1], cmd.operands[2]);
                 break;
@@ -664,7 +666,9 @@ public:
                     m_writer.getObject<QueryPoolBase>(cmd.operands[0]),
                     (GfxIndex)cmd.operands[1]);
                 break;
-            default: assert(!"unknown command"); break;
+            default:
+                assert(!"unknown command");
+                break;
             }
         }
         m_writer.clear();
diff --git a/tools/gfx/metal/metal-command-encoder.cpp b/tools/gfx/metal/metal-command-encoder.cpp
index f4c393193..cd6682172 100644
--- a/tools/gfx/metal/metal-command-encoder.cpp
+++ b/tools/gfx/metal/metal-command-encoder.cpp
@@ -363,9 +363,14 @@ void RenderCommandEncoder::setIndexBuffer(
 
     switch (indexFormat)
     {
-    case Format::R16_UINT: m_indexBufferType = MTL::IndexTypeUInt16; break;
-    case Format::R32_UINT: m_indexBufferType = MTL::IndexTypeUInt32; break;
-    default:               assert(!"unsupported index format");
+    case Format::R16_UINT:
+        m_indexBufferType = MTL::IndexTypeUInt16;
+        break;
+    case Format::R32_UINT:
+        m_indexBufferType = MTL::IndexTypeUInt32;
+        break;
+    default:
+        assert(!"unsupported index format");
     }
 }
 
diff --git a/tools/gfx/metal/metal-device.cpp b/tools/gfx/metal/metal-device.cpp
index ff534a78c..a536f64ff 100644
--- a/tools/gfx/metal/metal-device.cpp
+++ b/tools/gfx/metal/metal-device.cpp
@@ -392,12 +392,16 @@ Result DeviceImpl::createTextureResource(
         NS::TransferPtr(MTL::TextureDescriptor::alloc()->init());
     switch (desc.memoryType)
     {
-    case MemoryType::DeviceLocal: textureDesc->setStorageMode(MTL::StorageModePrivate); break;
+    case MemoryType::DeviceLocal:
+        textureDesc->setStorageMode(MTL::StorageModePrivate);
+        break;
     case MemoryType::Upload:
         textureDesc->setStorageMode(MTL::StorageModeShared);
         textureDesc->setCpuCacheMode(MTL::CPUCacheModeWriteCombined);
         break;
-    case MemoryType::ReadBack: textureDesc->setStorageMode(MTL::StorageModeShared); break;
+    case MemoryType::ReadBack:
+        textureDesc->setStorageMode(MTL::StorageModeShared);
+        break;
     }
 
     bool isArray = desc.arraySize > 0;
@@ -433,7 +437,9 @@ Result DeviceImpl::createTextureResource(
         textureDesc->setHeight(descIn.size.height);
         textureDesc->setDepth(descIn.size.depth);
         break;
-    default: assert("!Unsupported texture type"); return SLANG_FAIL;
+    default:
+        assert("!Unsupported texture type");
+        return SLANG_FAIL;
     }
 
     MTL::TextureUsage textureUsage = MTL::TextureUsageUnknown;
@@ -456,7 +462,9 @@ Result DeviceImpl::createTextureResource(
         case Format::R32_UINT:
         case Format::R32_SINT:
         case Format::R32G32_UINT:
-        case Format::R32G32_SINT: textureUsage |= MTL::TextureUsageShaderAtomic; break;
+        case Format::R32G32_SINT:
+            textureUsage |= MTL::TextureUsageShaderAtomic;
+            break;
         }
     }
 
@@ -548,11 +556,15 @@ Result DeviceImpl::createBufferResource(
     MTL::ResourceOptions resourceOptions = MTL::ResourceOptions(0);
     switch (desc.memoryType)
     {
-    case MemoryType::DeviceLocal: resourceOptions = MTL::ResourceStorageModePrivate; break;
+    case MemoryType::DeviceLocal:
+        resourceOptions = MTL::ResourceStorageModePrivate;
+        break;
     case MemoryType::Upload:
         resourceOptions = MTL::ResourceStorageModeShared | MTL::CPUCacheModeWriteCombined;
         break;
-    case MemoryType::ReadBack: resourceOptions = MTL::ResourceStorageModeShared; break;
+    case MemoryType::ReadBack:
+        resourceOptions = MTL::ResourceStorageModeShared;
+        break;
     }
     resourceOptions |= (desc.memoryType == MemoryType::DeviceLocal)
                            ? MTL::ResourceStorageModePrivate
diff --git a/tools/gfx/metal/metal-pipeline-state.cpp b/tools/gfx/metal/metal-pipeline-state.cpp
index c2a9afaac..cda38b611 100644
--- a/tools/gfx/metal/metal-pipeline-state.cpp
+++ b/tools/gfx/metal/metal-pipeline-state.cpp
@@ -65,9 +65,14 @@ Result PipelineStateImpl::createMetalRenderPipelineState()
 
         switch (module.stage)
         {
-        case SLANG_STAGE_VERTEX:   pd->setVertexFunction(function.get()); break;
-        case SLANG_STAGE_FRAGMENT: pd->setFragmentFunction(function.get()); break;
-        default:                   return SLANG_FAIL;
+        case SLANG_STAGE_VERTEX:
+            pd->setVertexFunction(function.get());
+            break;
+        case SLANG_STAGE_FRAGMENT:
+            pd->setFragmentFunction(function.get());
+            break;
+        default:
+            return SLANG_FAIL;
         }
     }
 
@@ -236,7 +241,9 @@ Result PipelineStateImpl::ensureAPIPipelineStateCreated()
         return m_computePipelineState ? SLANG_OK : createMetalComputePipelineState();
     case PipelineType::Graphics:
         return m_renderPipelineState ? SLANG_OK : createMetalRenderPipelineState();
-    default: SLANG_UNREACHABLE("Unknown pipeline type."); return SLANG_FAIL;
+    default:
+        SLANG_UNREACHABLE("Unknown pipeline type.");
+        return SLANG_FAIL;
     }
     return SLANG_OK;
 }
diff --git a/tools/gfx/metal/metal-render-pass.cpp b/tools/gfx/metal/metal-render-pass.cpp
index 49e470028..2b8cf61d2 100644
--- a/tools/gfx/metal/metal-render-pass.cpp
+++ b/tools/gfx/metal/metal-render-pass.cpp
@@ -22,10 +22,14 @@ static inline MTL::LoadAction translateLoadOp(IRenderPassLayout::TargetLoadOp lo
 {
     switch (loadOp)
     {
-    case IRenderPassLayout::TargetLoadOp::Load:     return MTL::LoadActionLoad;
-    case IRenderPassLayout::TargetLoadOp::Clear:    return MTL::LoadActionClear;
-    case IRenderPassLayout::TargetLoadOp::DontCare: return MTL::LoadActionDontCare;
-    default:                                        return MTL::LoadAction(0);
+    case IRenderPassLayout::TargetLoadOp::Load:
+        return MTL::LoadActionLoad;
+    case IRenderPassLayout::TargetLoadOp::Clear:
+        return MTL::LoadActionClear;
+    case IRenderPassLayout::TargetLoadOp::DontCare:
+        return MTL::LoadActionDontCare;
+    default:
+        return MTL::LoadAction(0);
     }
 }
 
@@ -33,9 +37,12 @@ static inline MTL::StoreAction translateStoreOp(IRenderPassLayout::TargetStoreOp
 {
     switch (storeOp)
     {
-    case IRenderPassLayout::TargetStoreOp::Store:    return MTL::StoreActionStore;
-    case IRenderPassLayout::TargetStoreOp::DontCare: return MTL::StoreActionDontCare;
-    default:                                         return MTL::StoreAction(0);
+    case IRenderPassLayout::TargetStoreOp::Store:
+        return MTL::StoreActionStore;
+    case IRenderPassLayout::TargetStoreOp::DontCare:
+        return MTL::StoreActionDontCare;
+    default:
+        return MTL::StoreAction(0);
     }
 }
 
diff --git a/tools/gfx/metal/metal-shader-object-layout.cpp b/tools/gfx/metal/metal-shader-object-layout.cpp
index e674b830a..c233d706c 100644
--- a/tools/gfx/metal/metal-shader-object-layout.cpp
+++ b/tools/gfx/metal/metal-shader-object-layout.cpp
@@ -95,7 +95,8 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(
             m_textureCount += count;
             m_textureRanges.add(r);
             break;
-        default: break;
+        default:
+            break;
         }
 
         // We'd like to extract the information on the Metal resource
diff --git a/tools/gfx/metal/metal-shader-object.cpp b/tools/gfx/metal/metal-shader-object.cpp
index 7ee7e8023..adbecdfe1 100644
--- a/tools/gfx/metal/metal-shader-object.cpp
+++ b/tools/gfx/metal/metal-shader-object.cpp
@@ -674,7 +674,8 @@ Result ShaderObjectImpl::bindAsValue(
             break;
 #endif
 
-        default: break;
+        default:
+            break;
         }
     }
 
diff --git a/tools/gfx/metal/metal-util.cpp b/tools/gfx/metal/metal-util.cpp
index fd2e9e009..60d1c7465 100644
--- a/tools/gfx/metal/metal-util.cpp
+++ b/tools/gfx/metal/metal-util.cpp
@@ -13,107 +13,189 @@ MTL::PixelFormat MetalUtil::translatePixelFormat(Format format)
 {
     switch (format)
     {
-    case Format::R32G32B32A32_TYPELESS: return MTL::PixelFormatRGBA32Float;
-    case Format::R32G32B32_TYPELESS:    return MTL::PixelFormatInvalid;
-    case Format::R32G32_TYPELESS:       return MTL::PixelFormatRG32Float;
-    case Format::R32_TYPELESS:          return MTL::PixelFormatR32Float;
-
-    case Format::R16G16B16A16_TYPELESS: return MTL::PixelFormatRGBA16Float;
-    case Format::R16G16_TYPELESS:       return MTL::PixelFormatRG16Float;
-    case Format::R16_TYPELESS:          return MTL::PixelFormatR16Float;
-
-    case Format::R8G8B8A8_TYPELESS: return MTL::PixelFormatRGBA8Unorm;
-    case Format::R8G8_TYPELESS:     return MTL::PixelFormatRG8Unorm;
-    case Format::R8_TYPELESS:       return MTL::PixelFormatR8Unorm;
-    case Format::B8G8R8A8_TYPELESS: return MTL::PixelFormatBGRA8Unorm;
-
-    case Format::R32G32B32A32_FLOAT: return MTL::PixelFormatRGBA32Float;
-    case Format::R32G32B32_FLOAT:    return MTL::PixelFormatInvalid;
-    case Format::R32G32_FLOAT:       return MTL::PixelFormatRG32Float;
-    case Format::R32_FLOAT:          return MTL::PixelFormatR32Float;
-
-    case Format::R16G16B16A16_FLOAT: return MTL::PixelFormatRGBA16Float;
-    case Format::R16G16_FLOAT:       return MTL::PixelFormatRG16Float;
-    case Format::R16_FLOAT:          return MTL::PixelFormatR16Float;
-
-    case Format::R32G32B32A32_UINT: return MTL::PixelFormatRGBA32Uint;
-    case Format::R32G32B32_UINT:    return MTL::PixelFormatInvalid;
-    case Format::R32G32_UINT:       return MTL::PixelFormatRG32Uint;
-    case Format::R32_UINT:          return MTL::PixelFormatR32Uint;
-
-    case Format::R16G16B16A16_UINT: return MTL::PixelFormatRGBA16Uint;
-    case Format::R16G16_UINT:       return MTL::PixelFormatRG16Uint;
-    case Format::R16_UINT:          return MTL::PixelFormatR16Uint;
-
-    case Format::R8G8B8A8_UINT: return MTL::PixelFormatRGBA8Uint;
-    case Format::R8G8_UINT:     return MTL::PixelFormatRG8Uint;
-    case Format::R8_UINT:       return MTL::PixelFormatR8Uint;
-
-    case Format::R32G32B32A32_SINT: return MTL::PixelFormatRGBA32Sint;
-    case Format::R32G32B32_SINT:    return MTL::PixelFormatInvalid;
-    case Format::R32G32_SINT:       return MTL::PixelFormatRG32Sint;
-    case Format::R32_SINT:          return MTL::PixelFormatR32Sint;
-
-    case Format::R16G16B16A16_SINT: return MTL::PixelFormatRGBA16Sint;
-    case Format::R16G16_SINT:       return MTL::PixelFormatRG16Sint;
-    case Format::R16_SINT:          return MTL::PixelFormatR16Sint;
-
-    case Format::R8G8B8A8_SINT: return MTL::PixelFormatRGBA8Sint;
-    case Format::R8G8_SINT:     return MTL::PixelFormatRG8Sint;
-    case Format::R8_SINT:       return MTL::PixelFormatR8Sint;
-
-    case Format::R16G16B16A16_UNORM: return MTL::PixelFormatRGBA16Unorm;
-    case Format::R16G16_UNORM:       return MTL::PixelFormatRG16Unorm;
-    case Format::R16_UNORM:          return MTL::PixelFormatR16Unorm;
-
-    case Format::R8G8B8A8_UNORM:      return MTL::PixelFormatRGBA8Unorm;
-    case Format::R8G8B8A8_UNORM_SRGB: return MTL::PixelFormatRGBA8Unorm_sRGB;
-    case Format::R8G8_UNORM:          return MTL::PixelFormatRG8Unorm;
-    case Format::R8_UNORM:            return MTL::PixelFormatR8Unorm;
-    case Format::B8G8R8A8_UNORM:      return MTL::PixelFormatBGRA8Unorm;
-    case Format::B8G8R8A8_UNORM_SRGB: return MTL::PixelFormatBGRA8Unorm_sRGB;
-    case Format::B8G8R8X8_UNORM:      return MTL::PixelFormatInvalid;
-    case Format::B8G8R8X8_UNORM_SRGB: return MTL::PixelFormatInvalid;
-
-    case Format::R16G16B16A16_SNORM: return MTL::PixelFormatRGBA16Snorm;
-    case Format::R16G16_SNORM:       return MTL::PixelFormatRG16Snorm;
-    case Format::R16_SNORM:          return MTL::PixelFormatR16Snorm;
-
-    case Format::R8G8B8A8_SNORM: return MTL::PixelFormatRGBA8Snorm;
-    case Format::R8G8_SNORM:     return MTL::PixelFormatRG8Snorm;
-    case Format::R8_SNORM:       return MTL::PixelFormatR8Snorm;
-
-    case Format::D32_FLOAT:              return MTL::PixelFormatDepth32Float;
-    case Format::D16_UNORM:              return MTL::PixelFormatDepth16Unorm;
-    case Format::D32_FLOAT_S8_UINT:      return MTL::PixelFormatDepth32Float_Stencil8;
-    case Format::R32_FLOAT_X32_TYPELESS: return MTL::PixelFormatInvalid;
-
-    case Format::B4G4R4A4_UNORM: return MTL::PixelFormatABGR4Unorm;
-    case Format::B5G6R5_UNORM:   return MTL::PixelFormatB5G6R5Unorm;
-    case Format::B5G5R5A1_UNORM: return MTL::PixelFormatA1BGR5Unorm;
-
-    case Format::R9G9B9E5_SHAREDEXP:   return MTL::PixelFormatRGB9E5Float;
-    case Format::R10G10B10A2_TYPELESS: return MTL::PixelFormatInvalid;
-    case Format::R10G10B10A2_UINT:     return MTL::PixelFormatRGB10A2Uint;
-    case Format::R10G10B10A2_UNORM:    return MTL::PixelFormatRGB10A2Unorm;
-    case Format::R11G11B10_FLOAT:      return MTL::PixelFormatRG11B10Float;
-
-    case Format::BC1_UNORM:      return MTL::PixelFormatBC1_RGBA;
-    case Format::BC1_UNORM_SRGB: return MTL::PixelFormatBC1_RGBA_sRGB;
-    case Format::BC2_UNORM:      return MTL::PixelFormatBC2_RGBA;
-    case Format::BC2_UNORM_SRGB: return MTL::PixelFormatBC2_RGBA_sRGB;
-    case Format::BC3_UNORM:      return MTL::PixelFormatBC3_RGBA;
-    case Format::BC3_UNORM_SRGB: return MTL::PixelFormatBC3_RGBA_sRGB;
-    case Format::BC4_UNORM:      return MTL::PixelFormatBC4_RUnorm;
-    case Format::BC4_SNORM:      return MTL::PixelFormatBC4_RSnorm;
-    case Format::BC5_UNORM:      return MTL::PixelFormatBC5_RGUnorm;
-    case Format::BC5_SNORM:      return MTL::PixelFormatBC5_RGSnorm;
-    case Format::BC6H_UF16:      return MTL::PixelFormatBC6H_RGBUfloat;
-    case Format::BC6H_SF16:      return MTL::PixelFormatBC6H_RGBFloat;
-    case Format::BC7_UNORM:      return MTL::PixelFormatBC7_RGBAUnorm;
-    case Format::BC7_UNORM_SRGB: return MTL::PixelFormatBC7_RGBAUnorm_sRGB;
-
-    default: return MTL::PixelFormatInvalid;
+    case Format::R32G32B32A32_TYPELESS:
+        return MTL::PixelFormatRGBA32Float;
+    case Format::R32G32B32_TYPELESS:
+        return MTL::PixelFormatInvalid;
+    case Format::R32G32_TYPELESS:
+        return MTL::PixelFormatRG32Float;
+    case Format::R32_TYPELESS:
+        return MTL::PixelFormatR32Float;
+
+    case Format::R16G16B16A16_TYPELESS:
+        return MTL::PixelFormatRGBA16Float;
+    case Format::R16G16_TYPELESS:
+        return MTL::PixelFormatRG16Float;
+    case Format::R16_TYPELESS:
+        return MTL::PixelFormatR16Float;
+
+    case Format::R8G8B8A8_TYPELESS:
+        return MTL::PixelFormatRGBA8Unorm;
+    case Format::R8G8_TYPELESS:
+        return MTL::PixelFormatRG8Unorm;
+    case Format::R8_TYPELESS:
+        return MTL::PixelFormatR8Unorm;
+    case Format::B8G8R8A8_TYPELESS:
+        return MTL::PixelFormatBGRA8Unorm;
+
+    case Format::R32G32B32A32_FLOAT:
+        return MTL::PixelFormatRGBA32Float;
+    case Format::R32G32B32_FLOAT:
+        return MTL::PixelFormatInvalid;
+    case Format::R32G32_FLOAT:
+        return MTL::PixelFormatRG32Float;
+    case Format::R32_FLOAT:
+        return MTL::PixelFormatR32Float;
+
+    case Format::R16G16B16A16_FLOAT:
+        return MTL::PixelFormatRGBA16Float;
+    case Format::R16G16_FLOAT:
+        return MTL::PixelFormatRG16Float;
+    case Format::R16_FLOAT:
+        return MTL::PixelFormatR16Float;
+
+    case Format::R32G32B32A32_UINT:
+        return MTL::PixelFormatRGBA32Uint;
+    case Format::R32G32B32_UINT:
+        return MTL::PixelFormatInvalid;
+    case Format::R32G32_UINT:
+        return MTL::PixelFormatRG32Uint;
+    case Format::R32_UINT:
+        return MTL::PixelFormatR32Uint;
+
+    case Format::R16G16B16A16_UINT:
+        return MTL::PixelFormatRGBA16Uint;
+    case Format::R16G16_UINT:
+        return MTL::PixelFormatRG16Uint;
+    case Format::R16_UINT:
+        return MTL::PixelFormatR16Uint;
+
+    case Format::R8G8B8A8_UINT:
+        return MTL::PixelFormatRGBA8Uint;
+    case Format::R8G8_UINT:
+        return MTL::PixelFormatRG8Uint;
+    case Format::R8_UINT:
+        return MTL::PixelFormatR8Uint;
+
+    case Format::R32G32B32A32_SINT:
+        return MTL::PixelFormatRGBA32Sint;
+    case Format::R32G32B32_SINT:
+        return MTL::PixelFormatInvalid;
+    case Format::R32G32_SINT:
+        return MTL::PixelFormatRG32Sint;
+    case Format::R32_SINT:
+        return MTL::PixelFormatR32Sint;
+
+    case Format::R16G16B16A16_SINT:
+        return MTL::PixelFormatRGBA16Sint;
+    case Format::R16G16_SINT:
+        return MTL::PixelFormatRG16Sint;
+    case Format::R16_SINT:
+        return MTL::PixelFormatR16Sint;
+
+    case Format::R8G8B8A8_SINT:
+        return MTL::PixelFormatRGBA8Sint;
+    case Format::R8G8_SINT:
+        return MTL::PixelFormatRG8Sint;
+    case Format::R8_SINT:
+        return MTL::PixelFormatR8Sint;
+
+    case Format::R16G16B16A16_UNORM:
+        return MTL::PixelFormatRGBA16Unorm;
+    case Format::R16G16_UNORM:
+        return MTL::PixelFormatRG16Unorm;
+    case Format::R16_UNORM:
+        return MTL::PixelFormatR16Unorm;
+
+    case Format::R8G8B8A8_UNORM:
+        return MTL::PixelFormatRGBA8Unorm;
+    case Format::R8G8B8A8_UNORM_SRGB:
+        return MTL::PixelFormatRGBA8Unorm_sRGB;
+    case Format::R8G8_UNORM:
+        return MTL::PixelFormatRG8Unorm;
+    case Format::R8_UNORM:
+        return MTL::PixelFormatR8Unorm;
+    case Format::B8G8R8A8_UNORM:
+        return MTL::PixelFormatBGRA8Unorm;
+    case Format::B8G8R8A8_UNORM_SRGB:
+        return MTL::PixelFormatBGRA8Unorm_sRGB;
+    case Format::B8G8R8X8_UNORM:
+        return MTL::PixelFormatInvalid;
+    case Format::B8G8R8X8_UNORM_SRGB:
+        return MTL::PixelFormatInvalid;
+
+    case Format::R16G16B16A16_SNORM:
+        return MTL::PixelFormatRGBA16Snorm;
+    case Format::R16G16_SNORM:
+        return MTL::PixelFormatRG16Snorm;
+    case Format::R16_SNORM:
+        return MTL::PixelFormatR16Snorm;
+
+    case Format::R8G8B8A8_SNORM:
+        return MTL::PixelFormatRGBA8Snorm;
+    case Format::R8G8_SNORM:
+        return MTL::PixelFormatRG8Snorm;
+    case Format::R8_SNORM:
+        return MTL::PixelFormatR8Snorm;
+
+    case Format::D32_FLOAT:
+        return MTL::PixelFormatDepth32Float;
+    case Format::D16_UNORM:
+        return MTL::PixelFormatDepth16Unorm;
+    case Format::D32_FLOAT_S8_UINT:
+        return MTL::PixelFormatDepth32Float_Stencil8;
+    case Format::R32_FLOAT_X32_TYPELESS:
+        return MTL::PixelFormatInvalid;
+
+    case Format::B4G4R4A4_UNORM:
+        return MTL::PixelFormatABGR4Unorm;
+    case Format::B5G6R5_UNORM:
+        return MTL::PixelFormatB5G6R5Unorm;
+    case Format::B5G5R5A1_UNORM:
+        return MTL::PixelFormatA1BGR5Unorm;
+
+    case Format::R9G9B9E5_SHAREDEXP:
+        return MTL::PixelFormatRGB9E5Float;
+    case Format::R10G10B10A2_TYPELESS:
+        return MTL::PixelFormatInvalid;
+    case Format::R10G10B10A2_UINT:
+        return MTL::PixelFormatRGB10A2Uint;
+    case Format::R10G10B10A2_UNORM:
+        return MTL::PixelFormatRGB10A2Unorm;
+    case Format::R11G11B10_FLOAT:
+        return MTL::PixelFormatRG11B10Float;
+
+    case Format::BC1_UNORM:
+        return MTL::PixelFormatBC1_RGBA;
+    case Format::BC1_UNORM_SRGB:
+        return MTL::PixelFormatBC1_RGBA_sRGB;
+    case Format::BC2_UNORM:
+        return MTL::PixelFormatBC2_RGBA;
+    case Format::BC2_UNORM_SRGB:
+        return MTL::PixelFormatBC2_RGBA_sRGB;
+    case Format::BC3_UNORM:
+        return MTL::PixelFormatBC3_RGBA;
+    case Format::BC3_UNORM_SRGB:
+        return MTL::PixelFormatBC3_RGBA_sRGB;
+    case Format::BC4_UNORM:
+        return MTL::PixelFormatBC4_RUnorm;
+    case Format::BC4_SNORM:
+        return MTL::PixelFormatBC4_RSnorm;
+    case Format::BC5_UNORM:
+        return MTL::PixelFormatBC5_RGUnorm;
+    case Format::BC5_SNORM:
+        return MTL::PixelFormatBC5_RGSnorm;
+    case Format::BC6H_UF16:
+        return MTL::PixelFormatBC6H_RGBUfloat;
+    case Format::BC6H_SF16:
+        return MTL::PixelFormatBC6H_RGBFloat;
+    case Format::BC7_UNORM:
+        return MTL::PixelFormatBC7_RGBAUnorm;
+    case Format::BC7_UNORM_SRGB:
+        return MTL::PixelFormatBC7_RGBAUnorm_sRGB;
+
+    default:
+        return MTL::PixelFormatInvalid;
     }
 }
 
@@ -121,60 +203,104 @@ MTL::VertexFormat MetalUtil::translateVertexFormat(Format format)
 {
     switch (format)
     {
-    case Format::R8G8_UINT: return MTL::VertexFormatUChar2;
+    case Format::R8G8_UINT:
+        return MTL::VertexFormatUChar2;
     // VertexFormatUChar3
-    case Format::R8G8B8A8_UINT: return MTL::VertexFormatUChar4;
-    case Format::R8G8_SINT:     return MTL::VertexFormatChar2;
+    case Format::R8G8B8A8_UINT:
+        return MTL::VertexFormatUChar4;
+    case Format::R8G8_SINT:
+        return MTL::VertexFormatChar2;
     // return VertexFormatChar3
-    case Format::R8G8B8A8_SINT: return MTL::VertexFormatChar4;
-    case Format::R8G8_UNORM:    return MTL::VertexFormatUChar2Normalized;
+    case Format::R8G8B8A8_SINT:
+        return MTL::VertexFormatChar4;
+    case Format::R8G8_UNORM:
+        return MTL::VertexFormatUChar2Normalized;
     // return VertexFormatUChar3Normalized;
-    case Format::R8G8B8A8_UNORM: return MTL::VertexFormatUChar4Normalized;
-    case Format::R8G8_SNORM:     return MTL::VertexFormatChar2Normalized;
+    case Format::R8G8B8A8_UNORM:
+        return MTL::VertexFormatUChar4Normalized;
+    case Format::R8G8_SNORM:
+        return MTL::VertexFormatChar2Normalized;
     // return VertexFormatChar3Normalized
-    case Format::R8G8B8A8_SNORM: return MTL::VertexFormatChar4Normalized;
-    case Format::R16G16_UINT:    return MTL::VertexFormatUShort2;
+    case Format::R8G8B8A8_SNORM:
+        return MTL::VertexFormatChar4Normalized;
+    case Format::R16G16_UINT:
+        return MTL::VertexFormatUShort2;
     // return VertexFormatUShort3;
-    case Format::R16G16B16A16_UINT: return MTL::VertexFormatUShort4;
-    case Format::R16G16_SINT:       return MTL::VertexFormatShort2;
+    case Format::R16G16B16A16_UINT:
+        return MTL::VertexFormatUShort4;
+    case Format::R16G16_SINT:
+        return MTL::VertexFormatShort2;
     // return VertexFormatShort3;
-    case Format::R16G16B16A16_SINT: return MTL::VertexFormatShort4;
-    case Format::R16G16_UNORM:      return MTL::VertexFormatUShort2Normalized;
+    case Format::R16G16B16A16_SINT:
+        return MTL::VertexFormatShort4;
+    case Format::R16G16_UNORM:
+        return MTL::VertexFormatUShort2Normalized;
     // return VertexFormatUShort3Normalized;
-    case Format::R16G16B16A16_UNORM: return MTL::VertexFormatUShort4Normalized;
-    case Format::R16G16_SNORM:       return MTL::VertexFormatShort2Normalized;
+    case Format::R16G16B16A16_UNORM:
+        return MTL::VertexFormatUShort4Normalized;
+    case Format::R16G16_SNORM:
+        return MTL::VertexFormatShort2Normalized;
     // return VertexFormatShort3Normalized;
-    case Format::R16G16B16A16_SNORM: return MTL::VertexFormatShort4Normalized;
-    case Format::R16G16_FLOAT:       return MTL::VertexFormatHalf2;
+    case Format::R16G16B16A16_SNORM:
+        return MTL::VertexFormatShort4Normalized;
+    case Format::R16G16_FLOAT:
+        return MTL::VertexFormatHalf2;
     // return VertexFormatHalf3;
-    case Format::R16G16B16A16_FLOAT: return MTL::VertexFormatHalf4;
-    case Format::R32_FLOAT:          return MTL::VertexFormatFloat;
-    case Format::R32G32_FLOAT:       return MTL::VertexFormatFloat2;
-    case Format::R32G32B32_FLOAT:    return MTL::VertexFormatFloat3;
-    case Format::R32G32B32A32_FLOAT: return MTL::VertexFormatFloat4;
-    case Format::R32_SINT:           return MTL::VertexFormatInt;
-    case Format::R32G32_SINT:        return MTL::VertexFormatInt2;
-    case Format::R32G32B32_SINT:     return MTL::VertexFormatInt3;
-    case Format::R32G32B32A32_SINT:  return MTL::VertexFormatInt4;
-    case Format::R32_UINT:           return MTL::VertexFormatUInt;
-    case Format::R32G32_UINT:        return MTL::VertexFormatUInt2;
-    case Format::R32G32B32_UINT:     return MTL::VertexFormatUInt3;
-    case Format::R32G32B32A32_UINT:  return MTL::VertexFormatUInt4;
+    case Format::R16G16B16A16_FLOAT:
+        return MTL::VertexFormatHalf4;
+    case Format::R32_FLOAT:
+        return MTL::VertexFormatFloat;
+    case Format::R32G32_FLOAT:
+        return MTL::VertexFormatFloat2;
+    case Format::R32G32B32_FLOAT:
+        return MTL::VertexFormatFloat3;
+    case Format::R32G32B32A32_FLOAT:
+        return MTL::VertexFormatFloat4;
+    case Format::R32_SINT:
+        return MTL::VertexFormatInt;
+    case Format::R32G32_SINT:
+        return MTL::VertexFormatInt2;
+    case Format::R32G32B32_SINT:
+        return MTL::VertexFormatInt3;
+    case Format::R32G32B32A32_SINT:
+        return MTL::VertexFormatInt4;
+    case Format::R32_UINT:
+        return MTL::VertexFormatUInt;
+    case Format::R32G32_UINT:
+        return MTL::VertexFormatUInt2;
+    case Format::R32G32B32_UINT:
+        return MTL::VertexFormatUInt3;
+    case Format::R32G32B32A32_UINT:
+        return MTL::VertexFormatUInt4;
     // return VertexFormatInt1010102Normalized;
-    case Format::R10G10B10A2_UNORM:  return MTL::VertexFormatUInt1010102Normalized;
-    case Format::B4G4R4A4_UNORM:     return MTL::VertexFormatUChar4Normalized_BGRA;
-    case Format::R8_UINT:            return MTL::VertexFormatUChar;
-    case Format::R8_SINT:            return MTL::VertexFormatChar;
-    case Format::R8_UNORM:           return MTL::VertexFormatUCharNormalized;
-    case Format::R8_SNORM:           return MTL::VertexFormatCharNormalized;
-    case Format::R16_UINT:           return MTL::VertexFormatUShort;
-    case Format::R16_SINT:           return MTL::VertexFormatShort;
-    case Format::R16_UNORM:          return MTL::VertexFormatUShortNormalized;
-    case Format::R16_SNORM:          return MTL::VertexFormatShortNormalized;
-    case Format::R16_FLOAT:          return MTL::VertexFormatHalf;
-    case Format::R11G11B10_FLOAT:    return MTL::VertexFormatFloatRG11B10;
-    case Format::R9G9B9E5_SHAREDEXP: return MTL::VertexFormatFloatRGB9E5;
-    default:                         return MTL::VertexFormatInvalid;
+    case Format::R10G10B10A2_UNORM:
+        return MTL::VertexFormatUInt1010102Normalized;
+    case Format::B4G4R4A4_UNORM:
+        return MTL::VertexFormatUChar4Normalized_BGRA;
+    case Format::R8_UINT:
+        return MTL::VertexFormatUChar;
+    case Format::R8_SINT:
+        return MTL::VertexFormatChar;
+    case Format::R8_UNORM:
+        return MTL::VertexFormatUCharNormalized;
+    case Format::R8_SNORM:
+        return MTL::VertexFormatCharNormalized;
+    case Format::R16_UINT:
+        return MTL::VertexFormatUShort;
+    case Format::R16_SINT:
+        return MTL::VertexFormatShort;
+    case Format::R16_UNORM:
+        return MTL::VertexFormatUShortNormalized;
+    case Format::R16_SNORM:
+        return MTL::VertexFormatShortNormalized;
+    case Format::R16_FLOAT:
+        return MTL::VertexFormatHalf;
+    case Format::R11G11B10_FLOAT:
+        return MTL::VertexFormatFloatRG11B10;
+    case Format::R9G9B9E5_SHAREDEXP:
+        return MTL::VertexFormatFloatRGB9E5;
+    default:
+        return MTL::VertexFormatInvalid;
     }
 }
 
@@ -185,8 +311,10 @@ bool MetalUtil::isDepthFormat(MTL::PixelFormat format)
     case MTL::PixelFormatDepth16Unorm:
     case MTL::PixelFormatDepth32Float:
     case MTL::PixelFormatDepth24Unorm_Stencil8:
-    case MTL::PixelFormatDepth32Float_Stencil8: return true;
-    default:                                    return false;
+    case MTL::PixelFormatDepth32Float_Stencil8:
+        return true;
+    default:
+        return false;
     }
 }
 
@@ -198,8 +326,10 @@ bool MetalUtil::isStencilFormat(MTL::PixelFormat format)
     case MTL::PixelFormatDepth24Unorm_Stencil8:
     case MTL::PixelFormatDepth32Float_Stencil8:
     case MTL::PixelFormatX32_Stencil8:
-    case MTL::PixelFormatX24_Stencil8:          return true;
-    default:                                    return false;
+    case MTL::PixelFormatX24_Stencil8:
+        return true;
+    default:
+        return false;
     }
 }
 
@@ -207,9 +337,12 @@ MTL::SamplerMinMagFilter MetalUtil::translateSamplerMinMagFilter(TextureFilterin
 {
     switch (mode)
     {
-    case TextureFilteringMode::Point:  return MTL::SamplerMinMagFilterNearest;
-    case TextureFilteringMode::Linear: return MTL::SamplerMinMagFilterLinear;
-    default:                           return MTL::SamplerMinMagFilter(0);
+    case TextureFilteringMode::Point:
+        return MTL::SamplerMinMagFilterNearest;
+    case TextureFilteringMode::Linear:
+        return MTL::SamplerMinMagFilterLinear;
+    default:
+        return MTL::SamplerMinMagFilter(0);
     }
 }
 
@@ -217,9 +350,12 @@ MTL::SamplerMipFilter MetalUtil::translateSamplerMipFilter(TextureFilteringMode
 {
     switch (mode)
     {
-    case TextureFilteringMode::Point:  return MTL::SamplerMipFilterNearest;
-    case TextureFilteringMode::Linear: return MTL::SamplerMipFilterLinear;
-    default:                           return MTL::SamplerMipFilter(0);
+    case TextureFilteringMode::Point:
+        return MTL::SamplerMipFilterNearest;
+    case TextureFilteringMode::Linear:
+        return MTL::SamplerMipFilterLinear;
+    default:
+        return MTL::SamplerMipFilter(0);
     }
 }
 
@@ -227,12 +363,18 @@ MTL::SamplerAddressMode MetalUtil::translateSamplerAddressMode(TextureAddressing
 {
     switch (mode)
     {
-    case TextureAddressingMode::Wrap:          return MTL::SamplerAddressModeRepeat;
-    case TextureAddressingMode::ClampToEdge:   return MTL::SamplerAddressModeClampToEdge;
-    case TextureAddressingMode::ClampToBorder: return MTL::SamplerAddressModeClampToBorderColor;
-    case TextureAddressingMode::MirrorRepeat:  return MTL::SamplerAddressModeMirrorRepeat;
-    case TextureAddressingMode::MirrorOnce:    return MTL::SamplerAddressModeMirrorClampToEdge;
-    default:                                   return MTL::SamplerAddressMode(0);
+    case TextureAddressingMode::Wrap:
+        return MTL::SamplerAddressModeRepeat;
+    case TextureAddressingMode::ClampToEdge:
+        return MTL::SamplerAddressModeClampToEdge;
+    case TextureAddressingMode::ClampToBorder:
+        return MTL::SamplerAddressModeClampToBorderColor;
+    case TextureAddressingMode::MirrorRepeat:
+        return MTL::SamplerAddressModeMirrorRepeat;
+    case TextureAddressingMode::MirrorOnce:
+        return MTL::SamplerAddressModeMirrorClampToEdge;
+    default:
+        return MTL::SamplerAddressMode(0);
     }
 }
 
@@ -240,15 +382,24 @@ MTL::CompareFunction MetalUtil::translateCompareFunction(ComparisonFunc func)
 {
     switch (func)
     {
-    case ComparisonFunc::Never:        return MTL::CompareFunctionNever;
-    case ComparisonFunc::Less:         return MTL::CompareFunctionLess;
-    case ComparisonFunc::Equal:        return MTL::CompareFunctionEqual;
-    case ComparisonFunc::LessEqual:    return MTL::CompareFunctionLessEqual;
-    case ComparisonFunc::Greater:      return MTL::CompareFunctionGreater;
-    case ComparisonFunc::NotEqual:     return MTL::CompareFunctionNotEqual;
-    case ComparisonFunc::GreaterEqual: return MTL::CompareFunctionGreaterEqual;
-    case ComparisonFunc::Always:       return MTL::CompareFunctionAlways;
-    default:                           return MTL::CompareFunction(0);
+    case ComparisonFunc::Never:
+        return MTL::CompareFunctionNever;
+    case ComparisonFunc::Less:
+        return MTL::CompareFunctionLess;
+    case ComparisonFunc::Equal:
+        return MTL::CompareFunctionEqual;
+    case ComparisonFunc::LessEqual:
+        return MTL::CompareFunctionLessEqual;
+    case ComparisonFunc::Greater:
+        return MTL::CompareFunctionGreater;
+    case ComparisonFunc::NotEqual:
+        return MTL::CompareFunctionNotEqual;
+    case ComparisonFunc::GreaterEqual:
+        return MTL::CompareFunctionGreaterEqual;
+    case ComparisonFunc::Always:
+        return MTL::CompareFunctionAlways;
+    default:
+        return MTL::CompareFunction(0);
     }
 }
 
@@ -256,15 +407,24 @@ MTL::StencilOperation MetalUtil::translateStencilOperation(StencilOp op)
 {
     switch (op)
     {
-    case StencilOp::Keep:              return MTL::StencilOperationKeep;
-    case StencilOp::Zero:              return MTL::StencilOperationZero;
-    case StencilOp::Replace:           return MTL::StencilOperationReplace;
-    case StencilOp::IncrementSaturate: return MTL::StencilOperationIncrementClamp;
-    case StencilOp::DecrementSaturate: return MTL::StencilOperationDecrementClamp;
-    case StencilOp::Invert:            return MTL::StencilOperationInvert;
-    case StencilOp::IncrementWrap:     return MTL::StencilOperationIncrementWrap;
-    case StencilOp::DecrementWrap:     return MTL::StencilOperationDecrementWrap;
-    default:                           return MTL::StencilOperation(0);
+    case StencilOp::Keep:
+        return MTL::StencilOperationKeep;
+    case StencilOp::Zero:
+        return MTL::StencilOperationZero;
+    case StencilOp::Replace:
+        return MTL::StencilOperationReplace;
+    case StencilOp::IncrementSaturate:
+        return MTL::StencilOperationIncrementClamp;
+    case StencilOp::DecrementSaturate:
+        return MTL::StencilOperationDecrementClamp;
+    case StencilOp::Invert:
+        return MTL::StencilOperationInvert;
+    case StencilOp::IncrementWrap:
+        return MTL::StencilOperationIncrementWrap;
+    case StencilOp::DecrementWrap:
+        return MTL::StencilOperationDecrementWrap;
+    default:
+        return MTL::StencilOperation(0);
     }
 }
 
@@ -272,9 +432,12 @@ MTL::VertexStepFunction MetalUtil::translateVertexStepFunction(InputSlotClass sl
 {
     switch (slotClass)
     {
-    case InputSlotClass::PerVertex:   return MTL::VertexStepFunctionPerVertex;
-    case InputSlotClass::PerInstance: return MTL::VertexStepFunctionPerInstance;
-    default:                          return MTL::VertexStepFunctionPerVertex;
+    case InputSlotClass::PerVertex:
+        return MTL::VertexStepFunctionPerVertex;
+    case InputSlotClass::PerInstance:
+        return MTL::VertexStepFunctionPerInstance;
+    default:
+        return MTL::VertexStepFunctionPerVertex;
     }
 }
 
@@ -282,12 +445,18 @@ MTL::PrimitiveType MetalUtil::translatePrimitiveType(PrimitiveTopology topology)
 {
     switch (topology)
     {
-    case PrimitiveTopology::TriangleList:  return MTL::PrimitiveTypeTriangle;
-    case PrimitiveTopology::TriangleStrip: return MTL::PrimitiveTypeTriangleStrip;
-    case PrimitiveTopology::PointList:     return MTL::PrimitiveTypePoint;
-    case PrimitiveTopology::LineList:      return MTL::PrimitiveTypeLine;
-    case PrimitiveTopology::LineStrip:     return MTL::PrimitiveTypeLineStrip;
-    default:                               return MTL::PrimitiveType(0);
+    case PrimitiveTopology::TriangleList:
+        return MTL::PrimitiveTypeTriangle;
+    case PrimitiveTopology::TriangleStrip:
+        return MTL::PrimitiveTypeTriangleStrip;
+    case PrimitiveTopology::PointList:
+        return MTL::PrimitiveTypePoint;
+    case PrimitiveTopology::LineList:
+        return MTL::PrimitiveTypeLine;
+    case PrimitiveTopology::LineStrip:
+        return MTL::PrimitiveTypeLineStrip;
+    default:
+        return MTL::PrimitiveType(0);
     }
 }
 
@@ -295,11 +464,15 @@ MTL::PrimitiveTopologyClass MetalUtil::translatePrimitiveTopologyClass(Primitive
 {
     switch (type)
     {
-    case PrimitiveType::Point:    return MTL::PrimitiveTopologyClassPoint;
-    case PrimitiveType::Line:     return MTL::PrimitiveTopologyClassLine;
-    case PrimitiveType::Triangle: return MTL::PrimitiveTopologyClassTriangle;
+    case PrimitiveType::Point:
+        return MTL::PrimitiveTopologyClassPoint;
+    case PrimitiveType::Line:
+        return MTL::PrimitiveTopologyClassLine;
+    case PrimitiveType::Triangle:
+        return MTL::PrimitiveTopologyClassTriangle;
     case PrimitiveType::Patch:
-    default:                      return MTL::PrimitiveTopologyClassUnspecified;
+    default:
+        return MTL::PrimitiveTopologyClassUnspecified;
     }
 }
 
@@ -307,24 +480,42 @@ MTL::BlendFactor MetalUtil::translateBlendFactor(BlendFactor factor)
 {
     switch (factor)
     {
-    case BlendFactor::Zero:                 return MTL::BlendFactorZero;
-    case BlendFactor::One:                  return MTL::BlendFactorOne;
-    case BlendFactor::SrcColor:             return MTL::BlendFactorSourceColor;
-    case BlendFactor::InvSrcColor:          return MTL::BlendFactorOneMinusSourceColor;
-    case BlendFactor::SrcAlpha:             return MTL::BlendFactorSourceAlpha;
-    case BlendFactor::InvSrcAlpha:          return MTL::BlendFactorOneMinusSourceAlpha;
-    case BlendFactor::DestAlpha:            return MTL::BlendFactorDestinationAlpha;
-    case BlendFactor::InvDestAlpha:         return MTL::BlendFactorOneMinusDestinationAlpha;
-    case BlendFactor::DestColor:            return MTL::BlendFactorDestinationColor;
-    case BlendFactor::InvDestColor:         return MTL::BlendFactorOneMinusDestinationColor;
-    case BlendFactor::SrcAlphaSaturate:     return MTL::BlendFactorSourceAlphaSaturated;
-    case BlendFactor::BlendColor:           return MTL::BlendFactorBlendColor;
-    case BlendFactor::InvBlendColor:        return MTL::BlendFactorOneMinusBlendColor;
-    case BlendFactor::SecondarySrcColor:    return MTL::BlendFactorSource1Color;
-    case BlendFactor::InvSecondarySrcColor: return MTL::BlendFactorOneMinusSource1Color;
-    case BlendFactor::SecondarySrcAlpha:    return MTL::BlendFactorSource1Alpha;
-    case BlendFactor::InvSecondarySrcAlpha: return MTL::BlendFactorOneMinusSource1Alpha;
-    default:                                return MTL::BlendFactor(0);
+    case BlendFactor::Zero:
+        return MTL::BlendFactorZero;
+    case BlendFactor::One:
+        return MTL::BlendFactorOne;
+    case BlendFactor::SrcColor:
+        return MTL::BlendFactorSourceColor;
+    case BlendFactor::InvSrcColor:
+        return MTL::BlendFactorOneMinusSourceColor;
+    case BlendFactor::SrcAlpha:
+        return MTL::BlendFactorSourceAlpha;
+    case BlendFactor::InvSrcAlpha:
+        return MTL::BlendFactorOneMinusSourceAlpha;
+    case BlendFactor::DestAlpha:
+        return MTL::BlendFactorDestinationAlpha;
+    case BlendFactor::InvDestAlpha:
+        return MTL::BlendFactorOneMinusDestinationAlpha;
+    case BlendFactor::DestColor:
+        return MTL::BlendFactorDestinationColor;
+    case BlendFactor::InvDestColor:
+        return MTL::BlendFactorOneMinusDestinationColor;
+    case BlendFactor::SrcAlphaSaturate:
+        return MTL::BlendFactorSourceAlphaSaturated;
+    case BlendFactor::BlendColor:
+        return MTL::BlendFactorBlendColor;
+    case BlendFactor::InvBlendColor:
+        return MTL::BlendFactorOneMinusBlendColor;
+    case BlendFactor::SecondarySrcColor:
+        return MTL::BlendFactorSource1Color;
+    case BlendFactor::InvSecondarySrcColor:
+        return MTL::BlendFactorOneMinusSource1Color;
+    case BlendFactor::SecondarySrcAlpha:
+        return MTL::BlendFactorSource1Alpha;
+    case BlendFactor::InvSecondarySrcAlpha:
+        return MTL::BlendFactorOneMinusSource1Alpha;
+    default:
+        return MTL::BlendFactor(0);
     }
 }
 
@@ -332,12 +523,18 @@ MTL::BlendOperation MetalUtil::translateBlendOperation(BlendOp op)
 {
     switch (op)
     {
-    case BlendOp::Add:             return MTL::BlendOperationAdd;
-    case BlendOp::Subtract:        return MTL::BlendOperationSubtract;
-    case BlendOp::ReverseSubtract: return MTL::BlendOperationReverseSubtract;
-    case BlendOp::Min:             return MTL::BlendOperationMin;
-    case BlendOp::Max:             return MTL::BlendOperationMax;
-    default:                       return MTL::BlendOperation(0);
+    case BlendOp::Add:
+        return MTL::BlendOperationAdd;
+    case BlendOp::Subtract:
+        return MTL::BlendOperationSubtract;
+    case BlendOp::ReverseSubtract:
+        return MTL::BlendOperationReverseSubtract;
+    case BlendOp::Min:
+        return MTL::BlendOperationMin;
+    case BlendOp::Max:
+        return MTL::BlendOperationMax;
+    default:
+        return MTL::BlendOperation(0);
     }
 }
 
@@ -359,9 +556,12 @@ MTL::Winding MetalUtil::translateWinding(FrontFaceMode mode)
 {
     switch (mode)
     {
-    case FrontFaceMode::CounterClockwise: return MTL::WindingCounterClockwise;
-    case FrontFaceMode::Clockwise:        return MTL::WindingClockwise;
-    default:                              return MTL::Winding(0);
+    case FrontFaceMode::CounterClockwise:
+        return MTL::WindingCounterClockwise;
+    case FrontFaceMode::Clockwise:
+        return MTL::WindingClockwise;
+    default:
+        return MTL::Winding(0);
     }
 }
 
@@ -369,10 +569,14 @@ MTL::CullMode MetalUtil::translateCullMode(CullMode mode)
 {
     switch (mode)
     {
-    case CullMode::None:  return MTL::CullModeNone;
-    case CullMode::Front: return MTL::CullModeFront;
-    case CullMode::Back:  return MTL::CullModeBack;
-    default:              return MTL::CullMode(0);
+    case CullMode::None:
+        return MTL::CullModeNone;
+    case CullMode::Front:
+        return MTL::CullModeFront;
+    case CullMode::Back:
+        return MTL::CullModeBack;
+    default:
+        return MTL::CullMode(0);
     }
 }
 
@@ -380,9 +584,12 @@ MTL::TriangleFillMode MetalUtil::translateTriangleFillMode(FillMode mode)
 {
     switch (mode)
     {
-    case FillMode::Solid:     return MTL::TriangleFillModeFill;
-    case FillMode::Wireframe: return MTL::TriangleFillModeLines;
-    default:                  return MTL::TriangleFillMode(0);
+    case FillMode::Solid:
+        return MTL::TriangleFillModeFill;
+    case FillMode::Wireframe:
+        return MTL::TriangleFillModeLines;
+    default:
+        return MTL::TriangleFillMode(0);
     }
 }
 
diff --git a/tools/gfx/open-gl/render-gl.cpp b/tools/gfx/open-gl/render-gl.cpp
index 3a1460a5b..9af39f711 100644
--- a/tools/gfx/open-gl/render-gl.cpp
+++ b/tools/gfx/open-gl/render-gl.cpp
@@ -765,7 +765,8 @@ protected:
                         bindingRangeInfo.baseIndex = m_storageBufferCount;
                         m_storageBufferCount += count;
                         break;
-                    case slang::BindingType::Sampler: break;
+                    case slang::BindingType::Sampler:
+                        break;
 
                     case slang::BindingType::Texture:
                     case slang::BindingType::CombinedTextureSampler:
@@ -783,8 +784,11 @@ protected:
                         m_storageBufferCount += count;
                         break;
                     case slang::BindingType::VaryingInput:
-                    case slang::BindingType::VaryingOutput: break;
-                    default:                                SLANG_ASSERT(!"unsupported binding type."); break;
+                    case slang::BindingType::VaryingOutput:
+                        break;
+                    default:
+                        SLANG_ASSERT(!"unsupported binding type.");
+                        break;
                     }
                     m_bindingRanges.add(bindingRangeInfo);
                 }
@@ -1416,8 +1420,10 @@ protected:
                 {
                 case slang::BindingType::ConstantBuffer:
                 case slang::BindingType::ParameterBlock:
-                case slang::BindingType::ExistentialValue: break;
-                default:                                   continue;
+                case slang::BindingType::ExistentialValue:
+                    break;
+                default:
+                    continue;
                 }
 
                 for (Index i = 0; i < bindingRange.count; i++)
@@ -1742,12 +1748,16 @@ protected:
 {
     switch (format)
     {
-    case Format::R8G8B8A8_UNORM: return GlPixelFormat::R8G8B8A8_UNORM;
-    case Format::D32_FLOAT:      return GlPixelFormat::D32_FLOAT;
+    case Format::R8G8B8A8_UNORM:
+        return GlPixelFormat::R8G8B8A8_UNORM;
+    case Format::D32_FLOAT:
+        return GlPixelFormat::D32_FLOAT;
     // case Format::D24_UNORM_S8_UINT:     return GlPixelFormat::D_Unorm24_S8;
-    case Format::D32_FLOAT_S8_UINT: return GlPixelFormat::D32_FLOAT_S8;
+    case Format::D32_FLOAT_S8_UINT:
+        return GlPixelFormat::D32_FLOAT_S8;
 
-    default: return GlPixelFormat::Unknown;
+    default:
+        return GlPixelFormat::Unknown;
     }
 }
 
@@ -1779,8 +1789,11 @@ void GLDevice::debugCallback(
     DebugMessageType msgType = DebugMessageType::Info;
     switch (type)
     {
-    case GL_DEBUG_TYPE_ERROR: msgType = DebugMessageType::Error; break;
-    default:                  break;
+    case GL_DEBUG_TYPE_ERROR:
+        msgType = DebugMessageType::Error;
+        break;
+    default:
+        break;
     }
     getDebugCallback()->handleMessage(msgType, DebugMessageSource::Driver, message);
 }
@@ -1801,7 +1814,9 @@ void GLDevice::debugCallback(
 {
     switch (format)
     {
-    default: assert(!"unexpected"); return VertexAttributeFormat();
+    default:
+        assert(!"unexpected");
+        return VertexAttributeFormat();
 
 #define CASE(NAME, COUNT, TYPE, NORMALIZED)                           \
     case Format::NAME:                                                \
@@ -1935,8 +1950,10 @@ GLuint GLDevice::loadShader(GLenum stage, const char* source)
     const char* stagePrelude = "\n";
     switch (stage)
     {
-#define CASE(NAME) \
-    case GL_##NAME##_SHADER: stagePrelude = "#define __GLSL_" #NAME "__ 1\n"; break
+#define CASE(NAME)                                       \
+    case GL_##NAME##_SHADER:                             \
+        stagePrelude = "#define __GLSL_" #NAME "__ 1\n"; \
+        break
 
         CASE(VERTEX);
         CASE(TESS_CONTROL);
@@ -2573,7 +2590,8 @@ SLANG_NO_THROW Result SLANG_MCALL GLDevice::createTextureResource(
             }
             break;
         }
-    default: return SLANG_FAIL;
+    default:
+        return SLANG_FAIL;
     }
 
     glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_REPEAT);
@@ -2595,8 +2613,10 @@ static GLenum _calcUsage(ResourceState state)
 {
     switch (state)
     {
-    case ResourceState::ConstantBuffer: return GL_DYNAMIC_DRAW;
-    default:                            return GL_STATIC_READ;
+    case ResourceState::ConstantBuffer:
+        return GL_DYNAMIC_DRAW;
+    default:
+        return GL_STATIC_READ;
     }
 }
 
@@ -2604,8 +2624,10 @@ static GLenum _calcTarget(ResourceState state)
 {
     switch (state)
     {
-    case ResourceState::ConstantBuffer: return GL_UNIFORM_BUFFER;
-    default:                            return GL_SHADER_STORAGE_BUFFER;
+    case ResourceState::ConstantBuffer:
+        return GL_UNIFORM_BUFFER;
+    default:
+        return GL_SHADER_STORAGE_BUFFER;
     }
 }
 
@@ -2737,8 +2759,12 @@ void* GLDevice::map(IBufferResource* bufferIn, MapFlavor flavor)
     switch (flavor)
     {
     case MapFlavor::WriteDiscard:
-    case MapFlavor::HostWrite:    access = GL_WRITE_ONLY; break;
-    case MapFlavor::HostRead:     access = GL_READ_ONLY; break;
+    case MapFlavor::HostWrite:
+        access = GL_WRITE_ONLY;
+        break;
+    case MapFlavor::HostRead:
+        access = GL_READ_ONLY;
+        break;
     }
 
     glBindBuffer(buffer->m_target, buffer->m_handle);
@@ -2759,8 +2785,10 @@ void GLDevice::setPrimitiveTopology(PrimitiveTopology topology)
     GLenum glTopology = 0;
     switch (topology)
     {
-#define CASE(NAME, VALUE) \
-    case PrimitiveTopology::NAME: glTopology = VALUE; break
+#define CASE(NAME, VALUE)         \
+    case PrimitiveTopology::NAME: \
+        glTopology = VALUE;       \
+        break
 
         CASE(TriangleList, GL_TRIANGLES);
 
@@ -2930,13 +2958,27 @@ Result GLDevice::createProgram(
         auto stage = programLayout->getEntryPointByIndex(i)->getStage();
         switch (stage)
         {
-        case SLANG_STAGE_COMPUTE:  glShaderType = GL_COMPUTE_SHADER; break;
-        case SLANG_STAGE_VERTEX:   glShaderType = GL_VERTEX_SHADER; break;
-        case SLANG_STAGE_FRAGMENT: glShaderType = GL_FRAGMENT_SHADER; break;
-        case SLANG_STAGE_GEOMETRY: glShaderType = GL_GEOMETRY_SHADER; break;
-        case SLANG_STAGE_DOMAIN:   glShaderType = GL_TESS_CONTROL_SHADER; break;
-        case SLANG_STAGE_HULL:     glShaderType = GL_TESS_EVALUATION_SHADER; break;
-        default:                   SLANG_ASSERT(!"unsupported shader type."); break;
+        case SLANG_STAGE_COMPUTE:
+            glShaderType = GL_COMPUTE_SHADER;
+            break;
+        case SLANG_STAGE_VERTEX:
+            glShaderType = GL_VERTEX_SHADER;
+            break;
+        case SLANG_STAGE_FRAGMENT:
+            glShaderType = GL_FRAGMENT_SHADER;
+            break;
+        case SLANG_STAGE_GEOMETRY:
+            glShaderType = GL_GEOMETRY_SHADER;
+            break;
+        case SLANG_STAGE_DOMAIN:
+            glShaderType = GL_TESS_CONTROL_SHADER;
+            break;
+        case SLANG_STAGE_HULL:
+            glShaderType = GL_TESS_EVALUATION_SHADER;
+            break;
+        default:
+            SLANG_ASSERT(!"unsupported shader type.");
+            break;
         }
         auto shaderID = loadShader(glShaderType, (char const*)kernelCode->getBufferPointer());
         shaderIDs.add(shaderID);
diff --git a/tools/gfx/render.cpp b/tools/gfx/render.cpp
index 49d55acc8..1ae7e370c 100644
--- a/tools/gfx/render.cpp
+++ b/tools/gfx/render.cpp
@@ -221,8 +221,10 @@ extern "C"
         case Format::BC6H_UF16:
         case Format::BC6H_SF16:
         case Format::BC7_UNORM:
-        case Format::BC7_UNORM_SRGB: return true;
-        default:                     return false;
+        case Format::BC7_UNORM_SRGB:
+            return true;
+        default:
+            return false;
         }
     }
 
@@ -241,8 +243,10 @@ extern "C"
         case Format::R8G8_TYPELESS:
         case Format::R8_TYPELESS:
         case Format::B8G8R8A8_TYPELESS:
-        case Format::R10G10B10A2_TYPELESS:  return true;
-        default:                            return false;
+        case Format::R10G10B10A2_TYPELESS:
+            return true;
+        default:
+            return false;
         }
     }
 
@@ -260,23 +264,38 @@ extern "C"
         switch (type)
         {
 #if SLANG_ENABLE_DIRECTX
-        case DeviceType::DirectX11: SLANG_RETURN_ON_FAIL(getD3D11Adapters(adapters)); break;
-        case DeviceType::DirectX12: SLANG_RETURN_ON_FAIL(getD3D12Adapters(adapters)); break;
+        case DeviceType::DirectX11:
+            SLANG_RETURN_ON_FAIL(getD3D11Adapters(adapters));
+            break;
+        case DeviceType::DirectX12:
+            SLANG_RETURN_ON_FAIL(getD3D12Adapters(adapters));
+            break;
 #endif
 #if SLANG_WINDOWS_FAMILY
-        case DeviceType::OpenGl: return SLANG_E_NOT_IMPLEMENTED;
+        case DeviceType::OpenGl:
+            return SLANG_E_NOT_IMPLEMENTED;
 #endif
 #if SLANG_WINDOWS_FAMILY || SLANG_LINUX_FAMILY
         // Assume no Vulkan or CUDA on MacOS or Cygwin
-        case DeviceType::Vulkan: SLANG_RETURN_ON_FAIL(getVKAdapters(adapters)); break;
-        case DeviceType::CUDA:   SLANG_RETURN_ON_FAIL(getCUDAAdapters(adapters)); break;
+        case DeviceType::Vulkan:
+            SLANG_RETURN_ON_FAIL(getVKAdapters(adapters));
+            break;
+        case DeviceType::CUDA:
+            SLANG_RETURN_ON_FAIL(getCUDAAdapters(adapters));
+            break;
 #endif
 #if SLANG_APPLE_FAMILY
-        case DeviceType::Vulkan: SLANG_RETURN_ON_FAIL(getVKAdapters(adapters)); break;
-        case DeviceType::Metal:  SLANG_RETURN_ON_FAIL(getMetalAdapters(adapters)); break;
+        case DeviceType::Vulkan:
+            SLANG_RETURN_ON_FAIL(getVKAdapters(adapters));
+            break;
+        case DeviceType::Metal:
+            SLANG_RETURN_ON_FAIL(getMetalAdapters(adapters));
+            break;
 #endif
-        case DeviceType::CPU: return SLANG_E_NOT_IMPLEMENTED;
-        default:              return SLANG_E_INVALID_ARG;
+        case DeviceType::CPU:
+            return SLANG_E_NOT_IMPLEMENTED;
+        default:
+            return SLANG_E_INVALID_ARG;
         }
 
         auto adaptersBlob =
@@ -372,7 +391,8 @@ extern "C"
             }
             break;
 
-        default: return SLANG_FAIL;
+        default:
+            return SLANG_FAIL;
         }
     }
 
@@ -417,16 +437,26 @@ extern "C"
     {
         switch (type)
         {
-        case gfx::DeviceType::Unknown:   return "Unknown";
-        case gfx::DeviceType::Default:   return "Default";
-        case gfx::DeviceType::DirectX11: return "DirectX11";
-        case gfx::DeviceType::DirectX12: return "DirectX12";
-        case gfx::DeviceType::OpenGl:    return "OpenGL";
-        case gfx::DeviceType::Vulkan:    return "Vulkan";
-        case gfx::DeviceType::Metal:     return "Metal";
-        case gfx::DeviceType::CPU:       return "CPU";
-        case gfx::DeviceType::CUDA:      return "CUDA";
-        default:                         return "?";
+        case gfx::DeviceType::Unknown:
+            return "Unknown";
+        case gfx::DeviceType::Default:
+            return "Default";
+        case gfx::DeviceType::DirectX11:
+            return "DirectX11";
+        case gfx::DeviceType::DirectX12:
+            return "DirectX12";
+        case gfx::DeviceType::OpenGl:
+            return "OpenGL";
+        case gfx::DeviceType::Vulkan:
+            return "Vulkan";
+        case gfx::DeviceType::Metal:
+            return "Metal";
+        case gfx::DeviceType::CPU:
+            return "CPU";
+        case gfx::DeviceType::CUDA:
+            return "CUDA";
+        default:
+            return "?";
         }
     }
 
diff --git a/tools/gfx/renderer-shared.cpp b/tools/gfx/renderer-shared.cpp
index 5a7aa4b64..9f5574dcc 100644
--- a/tools/gfx/renderer-shared.cpp
+++ b/tools/gfx/renderer-shared.cpp
@@ -55,10 +55,13 @@ StageType translateStage(SlangStage slangStage)
 {
     switch (slangStage)
     {
-    default: SLANG_ASSERT(!"unhandled case"); return gfx::StageType::Unknown;
+    default:
+        SLANG_ASSERT(!"unhandled case");
+        return gfx::StageType::Unknown;
 
-#define CASE(FROM, TO) \
-    case SLANG_STAGE_##FROM: return gfx::StageType::TO
+#define CASE(FROM, TO)       \
+    case SLANG_STAGE_##FROM: \
+        return gfx::StageType::TO
 
         CASE(VERTEX, Vertex);
         CASE(HULL, Hull);
@@ -152,22 +155,37 @@ StageType mapStage(SlangStage stage)
 {
     switch (stage)
     {
-    default: return StageType::Unknown;
-
-    case SLANG_STAGE_AMPLIFICATION:  return gfx::StageType::Amplification;
-    case SLANG_STAGE_ANY_HIT:        return gfx::StageType::AnyHit;
-    case SLANG_STAGE_CALLABLE:       return gfx::StageType::Callable;
-    case SLANG_STAGE_CLOSEST_HIT:    return gfx::StageType::ClosestHit;
-    case SLANG_STAGE_COMPUTE:        return gfx::StageType::Compute;
-    case SLANG_STAGE_DOMAIN:         return gfx::StageType::Domain;
-    case SLANG_STAGE_FRAGMENT:       return gfx::StageType::Fragment;
-    case SLANG_STAGE_GEOMETRY:       return gfx::StageType::Geometry;
-    case SLANG_STAGE_HULL:           return gfx::StageType::Hull;
-    case SLANG_STAGE_INTERSECTION:   return gfx::StageType::Intersection;
-    case SLANG_STAGE_MESH:           return gfx::StageType::Mesh;
-    case SLANG_STAGE_MISS:           return gfx::StageType::Miss;
-    case SLANG_STAGE_RAY_GENERATION: return gfx::StageType::RayGeneration;
-    case SLANG_STAGE_VERTEX:         return gfx::StageType::Vertex;
+    default:
+        return StageType::Unknown;
+
+    case SLANG_STAGE_AMPLIFICATION:
+        return gfx::StageType::Amplification;
+    case SLANG_STAGE_ANY_HIT:
+        return gfx::StageType::AnyHit;
+    case SLANG_STAGE_CALLABLE:
+        return gfx::StageType::Callable;
+    case SLANG_STAGE_CLOSEST_HIT:
+        return gfx::StageType::ClosestHit;
+    case SLANG_STAGE_COMPUTE:
+        return gfx::StageType::Compute;
+    case SLANG_STAGE_DOMAIN:
+        return gfx::StageType::Domain;
+    case SLANG_STAGE_FRAGMENT:
+        return gfx::StageType::Fragment;
+    case SLANG_STAGE_GEOMETRY:
+        return gfx::StageType::Geometry;
+    case SLANG_STAGE_HULL:
+        return gfx::StageType::Hull;
+    case SLANG_STAGE_INTERSECTION:
+        return gfx::StageType::Intersection;
+    case SLANG_STAGE_MESH:
+        return gfx::StageType::Mesh;
+    case SLANG_STAGE_MISS:
+        return gfx::StageType::Miss;
+    case SLANG_STAGE_RAY_GENERATION:
+        return gfx::StageType::RayGeneration;
+    case SLANG_STAGE_VERTEX:
+        return gfx::StageType::Vertex;
     }
 }
 
@@ -246,7 +264,8 @@ bool _doesValueFitInExistentialPayload(
         // We want to ignore any ordinary/uniform data usage, since that
         // was already checked above.
         //
-        case slang::ParameterCategory::Uniform: break;
+        case slang::ParameterCategory::Uniform:
+            break;
 
         // Any other kind of data consumed means the value cannot possibly fit.
         default:
@@ -603,7 +622,8 @@ Result RendererBase::createProgram2(
                 return SLANG_FAIL;
             break;
         }
-    default: SLANG_RELEASE_ASSERT(false);
+    default:
+        SLANG_RELEASE_ASSERT(false);
     }
 
     Slang::List<ComPtr<slang::IComponentType>> componentTypes;
@@ -764,7 +784,8 @@ Result RendererBase::getShaderObjectLayout(
     case ShaderObjectContainerType::Array:
         type = session->getContainerType(type, slang::ContainerType::UnsizedArray);
         break;
-    default: break;
+    default:
+        break;
     }
 
     auto typeLayout = session->getTypeLayout(type);
@@ -851,7 +872,8 @@ ShaderComponentID ShaderCache::getComponentId(slang::TypeReflection* type)
         }
         // TODO: collect specialization arguments and append them to `key`.
         SLANG_UNIMPLEMENTED_X("specialized type");
-    default: break;
+    default:
+        break;
     }
     key.updateHash();
     return getComponentId(key);
@@ -1013,9 +1035,13 @@ ResourceViewBase* SimpleShaderObjectData::getResourceView(
 
     switch (bindingType)
     {
-    case slang::BindingType::RawBuffer:        return m_structuredBufferView.Ptr();
-    case slang::BindingType::MutableRawBuffer: return m_rwStructuredBufferView.Ptr();
-    default:                                   SLANG_ASSERT(false && "Invalid binding type."); return nullptr;
+    case slang::BindingType::RawBuffer:
+        return m_structuredBufferView.Ptr();
+    case slang::BindingType::MutableRawBuffer:
+        return m_rwStructuredBufferView.Ptr();
+    default:
+        SLANG_ASSERT(false && "Invalid binding type.");
+        return nullptr;
     }
 }
 
@@ -1258,7 +1284,8 @@ Result RendererBase::maybeSpecializePipeline(
                         specializedPipelineComPtr.writeRef()));
                     break;
                 }
-            default: break;
+            default:
+                break;
             }
             specializedPipelineState =
                 static_cast<PipelineStateBase*>(specializedPipelineComPtr.get());
@@ -1395,8 +1422,10 @@ bool isDepthFormat(Format format)
     {
     case Format::D16_UNORM:
     case Format::D32_FLOAT:
-    case Format::D32_FLOAT_S8_UINT: return true;
-    default:                        return false;
+    case Format::D32_FLOAT_S8_UINT:
+        return true;
+    default:
+        return false;
     }
 }
 
@@ -1404,8 +1433,10 @@ bool isStencilFormat(Format format)
 {
     switch (format)
     {
-    case Format::D32_FLOAT_S8_UINT: return true;
-    default:                        return false;
+    case Format::D32_FLOAT_S8_UINT:
+        return true;
+    default:
+        return false;
     }
 }
 
diff --git a/tools/gfx/renderer-shared.h b/tools/gfx/renderer-shared.h
index 72b35d8fa..c763c9ba2 100644
--- a/tools/gfx/renderer-shared.h
+++ b/tools/gfx/renderer-shared.h
@@ -439,7 +439,8 @@ public:
             case slang::TypeReflection::Kind::ParameterBlock:
                 typeLayout = typeLayout->getElementTypeLayout();
                 continue;
-            default: return typeLayout;
+            default:
+                return typeLayout;
             }
         }
     }
@@ -1009,8 +1010,10 @@ public:
         {
             switch (type)
             {
-            case PipelineType::Compute:  return static_cast<ShaderProgramBase*>(compute.program);
-            case PipelineType::Graphics: return static_cast<ShaderProgramBase*>(graphics.program);
+            case PipelineType::Compute:
+                return static_cast<ShaderProgramBase*>(compute.program);
+            case PipelineType::Graphics:
+                return static_cast<ShaderProgramBase*>(graphics.program);
             case PipelineType::RayTracing:
                 return static_cast<ShaderProgramBase*>(rayTracing.program);
             }
diff --git a/tools/gfx/resource-desc-utils.cpp b/tools/gfx/resource-desc-utils.cpp
index ab20c78a8..8d70d0487 100644
--- a/tools/gfx/resource-desc-utils.cpp
+++ b/tools/gfx/resource-desc-utils.cpp
@@ -22,14 +22,22 @@ Format srgbToLinearFormat(Format format)
 {
     switch (format)
     {
-    case Format::BC1_UNORM_SRGB:      return Format::BC1_UNORM;
-    case Format::BC2_UNORM_SRGB:      return Format::BC2_UNORM;
-    case Format::BC3_UNORM_SRGB:      return Format::BC3_UNORM;
-    case Format::BC7_UNORM_SRGB:      return Format::BC7_UNORM;
-    case Format::B8G8R8A8_UNORM_SRGB: return Format::B8G8R8A8_UNORM;
-    case Format::B8G8R8X8_UNORM_SRGB: return Format::B8G8R8X8_UNORM;
-    case Format::R8G8B8A8_UNORM_SRGB: return Format::R8G8B8A8_UNORM;
-    default:                          return format;
+    case Format::BC1_UNORM_SRGB:
+        return Format::BC1_UNORM;
+    case Format::BC2_UNORM_SRGB:
+        return Format::BC2_UNORM;
+    case Format::BC3_UNORM_SRGB:
+        return Format::BC3_UNORM;
+    case Format::BC7_UNORM_SRGB:
+        return Format::BC7_UNORM;
+    case Format::B8G8R8A8_UNORM_SRGB:
+        return Format::B8G8R8A8_UNORM;
+    case Format::B8G8R8X8_UNORM_SRGB:
+        return Format::B8G8R8X8_UNORM;
+    case Format::R8G8B8A8_UNORM_SRGB:
+        return Format::R8G8B8A8_UNORM;
+    default:
+        return format;
     }
 }
 } // namespace gfx
diff --git a/tools/gfx/resource-desc-utils.h b/tools/gfx/resource-desc-utils.h
index cdfeb4c25..54d04572e 100644
--- a/tools/gfx/resource-desc-utils.h
+++ b/tools/gfx/resource-desc-utils.h
@@ -35,9 +35,12 @@ inline int calcEffectiveArraySize(const ITextureResource::Desc& desc)
         {
             return arrSize;
         }
-    case IResource::Type::TextureCube: return arrSize * 6;
-    case IResource::Type::Texture3D:   return 1;
-    default:                           return 0;
+    case IResource::Type::TextureCube:
+        return arrSize * 6;
+    case IResource::Type::Texture3D:
+        return 1;
+    default:
+        return 0;
     }
 }
 
@@ -46,7 +49,8 @@ inline int calcMaxDimension(ITextureResource::Extents size, IResource::Type type
 {
     switch (type)
     {
-    case IResource::Type::Texture1D: return size.width;
+    case IResource::Type::Texture1D:
+        return size.width;
     case IResource::Type::Texture3D:
         return Slang::Math::Max(Slang::Math::Max(size.width, size.height), size.depth);
     case IResource::Type::TextureCube: // fallthru
@@ -54,7 +58,8 @@ inline int calcMaxDimension(ITextureResource::Extents size, IResource::Type type
         {
             return Slang::Math::Max(size.width, size.height);
         }
-    default: return 0;
+    default:
+        return 0;
     }
 }
 
@@ -84,7 +89,8 @@ inline int calcNumSubResources(const ITextureResource::Desc& desc)
             // There are 6 faces to a cubemap
             return numMipMaps * arrSize * 6;
         }
-    default: return 0;
+    default:
+        return 0;
     }
 }
 
diff --git a/tools/gfx/vulkan/vk-api.cpp b/tools/gfx/vulkan/vk-api.cpp
index 3d2042a8d..80b1d5814 100644
--- a/tools/gfx/vulkan/vk-api.cpp
+++ b/tools/gfx/vulkan/vk-api.cpp
@@ -16,9 +16,12 @@ bool VulkanApi::areDefined(ProcType type) const
 {
     switch (type)
     {
-    case ProcType::Global:   return VK_API_CHECK_FUNCTIONS(VK_API_ALL_GLOBAL_PROCS);
-    case ProcType::Instance: return VK_API_CHECK_FUNCTIONS(VK_API_ALL_INSTANCE_PROCS);
-    case ProcType::Device:   return VK_API_CHECK_FUNCTIONS(VK_API_DEVICE_PROCS);
+    case ProcType::Global:
+        return VK_API_CHECK_FUNCTIONS(VK_API_ALL_GLOBAL_PROCS);
+    case ProcType::Instance:
+        return VK_API_CHECK_FUNCTIONS(VK_API_ALL_INSTANCE_PROCS);
+    case ProcType::Device:
+        return VK_API_CHECK_FUNCTIONS(VK_API_DEVICE_PROCS);
     default:
         {
             assert(!"Unhandled type");
diff --git a/tools/gfx/vulkan/vk-command-encoder.cpp b/tools/gfx/vulkan/vk-command-encoder.cpp
index f9caff437..42af3bee9 100644
--- a/tools/gfx/vulkan/vk-command-encoder.cpp
+++ b/tools/gfx/vulkan/vk-command-encoder.cpp
@@ -25,10 +25,15 @@ int PipelineCommandEncoder::getBindPointIndex(VkPipelineBindPoint bindPoint)
 {
     switch (bindPoint)
     {
-    case VK_PIPELINE_BIND_POINT_GRAPHICS:        return 0;
-    case VK_PIPELINE_BIND_POINT_COMPUTE:         return 1;
-    case VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR: return 2;
-    default:                                     assert(!"unknown pipeline type."); return -1;
+    case VK_PIPELINE_BIND_POINT_GRAPHICS:
+        return 0;
+    case VK_PIPELINE_BIND_POINT_COMPUTE:
+        return 1;
+    case VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR:
+        return 2;
+    default:
+        assert(!"unknown pipeline type.");
+        return -1;
     }
 }
 
@@ -1063,7 +1068,8 @@ void RenderCommandEncoder::setPrimitiveTopology(PrimitiveTopology topology)
     {
         switch (topology)
         {
-        case PrimitiveTopology::TriangleList: break;
+        case PrimitiveTopology::TriangleList:
+            break;
         default:
             // We are using a non-list topology, but we don't have dynmaic state
             // extension, error out.
@@ -1107,9 +1113,14 @@ void RenderCommandEncoder::setIndexBuffer(
     VkIndexType indexType = VK_INDEX_TYPE_UINT16;
     switch (indexFormat)
     {
-    case Format::R16_UINT: indexType = VK_INDEX_TYPE_UINT16; break;
-    case Format::R32_UINT: indexType = VK_INDEX_TYPE_UINT32; break;
-    default:               assert(!"unsupported index format");
+    case Format::R16_UINT:
+        indexType = VK_INDEX_TYPE_UINT16;
+        break;
+    case Format::R32_UINT:
+        indexType = VK_INDEX_TYPE_UINT32;
+        break;
+    default:
+        assert(!"unsupported index format");
     }
 
     BufferResourceImpl* bufferImpl = static_cast<BufferResourceImpl*>(buffer);
@@ -1367,7 +1378,8 @@ void RayTracingCommandEncoder::_queryAccelerationStructureProperties(
         case QueryType::AccelerationStructureSerializedSize:
             queryType = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR;
             break;
-        case QueryType::AccelerationStructureCurrentSize: continue;
+        case QueryType::AccelerationStructureCurrentSize:
+            continue;
         default:
             getDebugCallback()->handleMessage(
                 DebugMessageType::Error,
diff --git a/tools/gfx/vulkan/vk-device.cpp b/tools/gfx/vulkan/vk-device.cpp
index 68b8ba1db..689213437 100644
--- a/tools/gfx/vulkan/vk-device.cpp
+++ b/tools/gfx/vulkan/vk-device.cpp
@@ -1429,7 +1429,8 @@ uint32_t DeviceImpl::getQueueFamilyIndex(ICommandQueue::QueueType queueType)
     switch (queueType)
     {
     case ICommandQueue::QueueType::Graphics:
-    default:                                 return m_queueFamilyIndex;
+    default:
+        return m_queueFamilyIndex;
     }
 }
 
@@ -2154,11 +2155,15 @@ Result DeviceImpl::createTextureView(
     case IResource::Type::Texture2D:
         createInfo.viewType = isArray ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
         break;
-    case IResource::Type::Texture3D: createInfo.viewType = VK_IMAGE_VIEW_TYPE_3D; break;
+    case IResource::Type::Texture3D:
+        createInfo.viewType = VK_IMAGE_VIEW_TYPE_3D;
+        break;
     case IResource::Type::TextureCube:
         createInfo.viewType = isArray ? VK_IMAGE_VIEW_TYPE_CUBE_ARRAY : VK_IMAGE_VIEW_TYPE_CUBE;
         break;
-    default: SLANG_UNIMPLEMENTED_X("Unknown Texture type."); break;
+    default:
+        SLANG_UNIMPLEMENTED_X("Unknown Texture type.");
+        break;
     }
 
     createInfo.subresourceRange.aspectMask = getAspectMaskFromFormat(resourceImpl->m_vkformat);
@@ -2190,8 +2195,12 @@ Result DeviceImpl::createTextureView(
     case IResourceView::Type::ShaderResource:
         view->m_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
         break;
-    case IResourceView::Type::UnorderedAccess: view->m_layout = VK_IMAGE_LAYOUT_GENERAL; break;
-    default:                                   SLANG_UNIMPLEMENTED_X("Unknown TextureViewDesc type."); break;
+    case IResourceView::Type::UnorderedAccess:
+        view->m_layout = VK_IMAGE_LAYOUT_GENERAL;
+        break;
+    default:
+        SLANG_UNIMPLEMENTED_X("Unknown TextureViewDesc type.");
+        break;
     }
     m_api.vkCreateImageView(m_device, &createInfo, nullptr, &view->m_view);
     returnComPtr(outView, view);
@@ -2246,8 +2255,11 @@ Result DeviceImpl::getFormatSupportedResourceStates(Format format, ResourceState
     switch (format)
     {
     case Format::R32_UINT:
-    case Format::R16_UINT: allowedStates.add(ResourceState::IndexBuffer); break;
-    default:               break;
+    case Format::R16_UINT:
+        allowedStates.add(ResourceState::IndexBuffer);
+        break;
+    default:
+        break;
     }
     // ConstantBuffer
     allowedStates.add(ResourceState::ConstantBuffer);
@@ -2335,7 +2347,9 @@ Result DeviceImpl::createBufferView(
 
     switch (desc.type)
     {
-    default: assert(!"unhandled"); return SLANG_FAIL;
+    default:
+        assert(!"unhandled");
+        return SLANG_FAIL;
 
     case IResourceView::Type::UnorderedAccess:
     case IResourceView::Type::ShaderResource:
diff --git a/tools/gfx/vulkan/vk-helper-functions.cpp b/tools/gfx/vulkan/vk-helper-functions.cpp
index b7bbeec2b..f1f517567 100644
--- a/tools/gfx/vulkan/vk-helper-functions.cpp
+++ b/tools/gfx/vulkan/vk-helper-functions.cpp
@@ -31,9 +31,12 @@ VkAttachmentLoadOp translateLoadOp(IRenderPassLayout::TargetLoadOp loadOp)
 {
     switch (loadOp)
     {
-    case IRenderPassLayout::TargetLoadOp::Clear: return VK_ATTACHMENT_LOAD_OP_CLEAR;
-    case IRenderPassLayout::TargetLoadOp::Load:  return VK_ATTACHMENT_LOAD_OP_LOAD;
-    default:                                     return VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+    case IRenderPassLayout::TargetLoadOp::Clear:
+        return VK_ATTACHMENT_LOAD_OP_CLEAR;
+    case IRenderPassLayout::TargetLoadOp::Load:
+        return VK_ATTACHMENT_LOAD_OP_LOAD;
+    default:
+        return VK_ATTACHMENT_LOAD_OP_DONT_CARE;
     }
 }
 
@@ -41,8 +44,10 @@ VkAttachmentStoreOp translateStoreOp(IRenderPassLayout::TargetStoreOp storeOp)
 {
     switch (storeOp)
     {
-    case IRenderPassLayout::TargetStoreOp::Store: return VK_ATTACHMENT_STORE_OP_STORE;
-    default:                                      return VK_ATTACHMENT_STORE_OP_DONT_CARE;
+    case IRenderPassLayout::TargetStoreOp::Store:
+        return VK_ATTACHMENT_STORE_OP_STORE;
+    default:
+        return VK_ATTACHMENT_STORE_OP_DONT_CARE;
     }
 }
 
@@ -66,21 +71,33 @@ VkImageLayout translateImageLayout(ResourceState state)
 {
     switch (state)
     {
-    case ResourceState::Undefined:              return VK_IMAGE_LAYOUT_UNDEFINED;
-    case ResourceState::PreInitialized:         return VK_IMAGE_LAYOUT_PREINITIALIZED;
-    case ResourceState::UnorderedAccess:        return VK_IMAGE_LAYOUT_GENERAL;
-    case ResourceState::RenderTarget:           return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-    case ResourceState::DepthRead:              return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
-    case ResourceState::DepthWrite:             return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+    case ResourceState::Undefined:
+        return VK_IMAGE_LAYOUT_UNDEFINED;
+    case ResourceState::PreInitialized:
+        return VK_IMAGE_LAYOUT_PREINITIALIZED;
+    case ResourceState::UnorderedAccess:
+        return VK_IMAGE_LAYOUT_GENERAL;
+    case ResourceState::RenderTarget:
+        return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+    case ResourceState::DepthRead:
+        return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
+    case ResourceState::DepthWrite:
+        return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
     case ResourceState::ShaderResource:
     case ResourceState::NonPixelShaderResource:
-    case ResourceState::PixelShaderResource:    return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    case ResourceState::PixelShaderResource:
+        return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
     case ResourceState::ResolveDestination:
-    case ResourceState::CopyDestination:        return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+    case ResourceState::CopyDestination:
+        return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
     case ResourceState::ResolveSource:
-    case ResourceState::CopySource:             return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-    case ResourceState::Present:                return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-    default:                                    assert(!"Unsupported"); return VK_IMAGE_LAYOUT_UNDEFINED;
+    case ResourceState::CopySource:
+        return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    case ResourceState::Present:
+        return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+    default:
+        assert(!"Unsupported");
+        return VK_IMAGE_LAYOUT_UNDEFINED;
     }
 }
 
@@ -90,28 +107,37 @@ VkAccessFlagBits calcAccessFlags(ResourceState state)
     {
     case ResourceState::Undefined:
     case ResourceState::Present:
-    case ResourceState::PreInitialized: return VkAccessFlagBits(0);
-    case ResourceState::VertexBuffer:   return VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
-    case ResourceState::ConstantBuffer: return VK_ACCESS_UNIFORM_READ_BIT;
-    case ResourceState::IndexBuffer:    return VK_ACCESS_INDEX_READ_BIT;
+    case ResourceState::PreInitialized:
+        return VkAccessFlagBits(0);
+    case ResourceState::VertexBuffer:
+        return VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
+    case ResourceState::ConstantBuffer:
+        return VK_ACCESS_UNIFORM_READ_BIT;
+    case ResourceState::IndexBuffer:
+        return VK_ACCESS_INDEX_READ_BIT;
     case ResourceState::RenderTarget:
         return VkAccessFlagBits(
             VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT);
     case ResourceState::ShaderResource:
     case ResourceState::NonPixelShaderResource:
-    case ResourceState::PixelShaderResource:    return VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
+    case ResourceState::PixelShaderResource:
+        return VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
     case ResourceState::UnorderedAccess:
         return VkAccessFlagBits(VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);
-    case ResourceState::DepthRead: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+    case ResourceState::DepthRead:
+        return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
     case ResourceState::DepthWrite:
         return VkAccessFlagBits(
             VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
             VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT);
-    case ResourceState::IndirectArgument:   return VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
+    case ResourceState::IndirectArgument:
+        return VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
     case ResourceState::ResolveDestination:
-    case ResourceState::CopyDestination:    return VK_ACCESS_TRANSFER_WRITE_BIT;
+    case ResourceState::CopyDestination:
+        return VK_ACCESS_TRANSFER_WRITE_BIT;
     case ResourceState::ResolveSource:
-    case ResourceState::CopySource:         return VK_ACCESS_TRANSFER_READ_BIT;
+    case ResourceState::CopySource:
+        return VK_ACCESS_TRANSFER_READ_BIT;
     case ResourceState::AccelerationStructure:
         return VkAccessFlagBits(
             VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR |
@@ -120,7 +146,9 @@ VkAccessFlagBits calcAccessFlags(ResourceState state)
         return VkAccessFlagBits(VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR);
     case ResourceState::General:
         return VkAccessFlagBits(VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT);
-    default: assert(!"Unsupported"); return VkAccessFlagBits(0);
+    default:
+        assert(!"Unsupported");
+        return VkAccessFlagBits(0);
     }
 }
 
@@ -129,9 +157,12 @@ VkPipelineStageFlagBits calcPipelineStageFlags(ResourceState state, bool src)
     switch (state)
     {
     case ResourceState::Undefined:
-    case ResourceState::PreInitialized: assert(src); return VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+    case ResourceState::PreInitialized:
+        assert(src);
+        return VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
     case ResourceState::VertexBuffer:
-    case ResourceState::IndexBuffer:    return VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
+    case ResourceState::IndexBuffer:
+        return VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
     case ResourceState::ConstantBuffer:
     case ResourceState::UnorderedAccess:
         return VkPipelineStageFlagBits(
@@ -142,22 +173,27 @@ VkPipelineStageFlagBits calcPipelineStageFlags(ResourceState state, bool src)
             VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
     case ResourceState::ShaderResource:
     case ResourceState::NonPixelShaderResource:
-    case ResourceState::PixelShaderResource:    return VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-    case ResourceState::RenderTarget:           return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    case ResourceState::PixelShaderResource:
+        return VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
+    case ResourceState::RenderTarget:
+        return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
     case ResourceState::DepthRead:
     case ResourceState::DepthWrite:
         return VkPipelineStageFlagBits(
             VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
-    case ResourceState::IndirectArgument:   return VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
+    case ResourceState::IndirectArgument:
+        return VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
     case ResourceState::CopySource:
     case ResourceState::CopyDestination:
     case ResourceState::ResolveSource:
-    case ResourceState::ResolveDestination: return VK_PIPELINE_STAGE_TRANSFER_BIT;
+    case ResourceState::ResolveDestination:
+        return VK_PIPELINE_STAGE_TRANSFER_BIT;
     case ResourceState::Present:
         return src ? VkPipelineStageFlagBits(
                          VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_ALL_COMMANDS_BIT)
                    : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
-    case ResourceState::General: return VkPipelineStageFlagBits(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+    case ResourceState::General:
+        return VkPipelineStageFlagBits(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
     case ResourceState::AccelerationStructure:
         return VkPipelineStageFlagBits(
             VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
@@ -168,7 +204,9 @@ VkPipelineStageFlagBits calcPipelineStageFlags(ResourceState state, bool src)
             VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR);
     case ResourceState::AccelerationStructureBuildInput:
         return VkPipelineStageFlagBits(VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR);
-    default: assert(!"Unsupported"); return VkPipelineStageFlagBits(0);
+    default:
+        assert(!"Unsupported");
+        return VkPipelineStageFlagBits(0);
     }
 }
 
@@ -187,10 +225,14 @@ VkBufferUsageFlagBits _calcBufferUsageFlags(ResourceState state)
 {
     switch (state)
     {
-    case ResourceState::VertexBuffer:   return VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
-    case ResourceState::IndexBuffer:    return VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
-    case ResourceState::ConstantBuffer: return VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
-    case ResourceState::StreamOutput:   return VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
+    case ResourceState::VertexBuffer:
+        return VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
+    case ResourceState::IndexBuffer:
+        return VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
+    case ResourceState::ConstantBuffer:
+        return VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+    case ResourceState::StreamOutput:
+        return VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
     case ResourceState::RenderTarget:
     case ResourceState::DepthRead:
     case ResourceState::DepthWrite:
@@ -206,14 +248,18 @@ VkBufferUsageFlagBits _calcBufferUsageFlags(ResourceState state)
     case ResourceState::PixelShaderResource:
         return (VkBufferUsageFlagBits)(VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
                                        VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
-    case ResourceState::CopySource:      return VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
-    case ResourceState::CopyDestination: return VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+    case ResourceState::CopySource:
+        return VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+    case ResourceState::CopyDestination:
+        return VK_BUFFER_USAGE_TRANSFER_DST_BIT;
     case ResourceState::AccelerationStructure:
         return VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR;
-    case ResourceState::IndirectArgument: return VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
+    case ResourceState::IndirectArgument:
+        return VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
     case ResourceState::AccelerationStructureBuildInput:
         return VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR;
-    default: return VkBufferUsageFlagBits(0);
+    default:
+        return VkBufferUsageFlagBits(0);
     }
 }
 
@@ -233,20 +279,31 @@ VkImageUsageFlagBits _calcImageUsageFlags(ResourceState state)
 {
     switch (state)
     {
-    case ResourceState::RenderTarget:           return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-    case ResourceState::DepthWrite:             return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
-    case ResourceState::DepthRead:              return VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+    case ResourceState::RenderTarget:
+        return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    case ResourceState::DepthWrite:
+        return VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+    case ResourceState::DepthRead:
+        return VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
     case ResourceState::ShaderResource:
     case ResourceState::NonPixelShaderResource:
-    case ResourceState::PixelShaderResource:    return VK_IMAGE_USAGE_SAMPLED_BIT;
-    case ResourceState::UnorderedAccess:        return VK_IMAGE_USAGE_STORAGE_BIT;
-    case ResourceState::CopySource:             return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-    case ResourceState::CopyDestination:        return VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-    case ResourceState::ResolveSource:          return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-    case ResourceState::ResolveDestination:     return VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-    case ResourceState::Present:                return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    case ResourceState::PixelShaderResource:
+        return VK_IMAGE_USAGE_SAMPLED_BIT;
+    case ResourceState::UnorderedAccess:
+        return VK_IMAGE_USAGE_STORAGE_BIT;
+    case ResourceState::CopySource:
+        return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    case ResourceState::CopyDestination:
+        return VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    case ResourceState::ResolveSource:
+        return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+    case ResourceState::ResolveDestination:
+        return VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    case ResourceState::Present:
+        return VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
     case ResourceState::Undefined:
-    case ResourceState::General:                return (VkImageUsageFlagBits)0;
+    case ResourceState::General:
+        return (VkImageUsageFlagBits)0;
     default:
         {
             assert(!"Unsupported");
@@ -275,7 +332,8 @@ VkImageViewType _calcImageViewType(ITextureResource::Type type, const ITextureRe
             }
             break;
         }
-    default: break;
+    default:
+        break;
     }
 
     return VK_IMAGE_VIEW_TYPE_MAX_ENUM;
@@ -331,9 +389,12 @@ VkAccessFlags calcAccessFlagsFromImageLayout(VkImageLayout layout)
     case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL:
     case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL:
         return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
-    case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: return VK_ACCESS_SHADER_READ_BIT;
-    case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:     return VK_ACCESS_TRANSFER_READ_BIT;
-    case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:     return VK_ACCESS_TRANSFER_WRITE_BIT;
+    case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+        return VK_ACCESS_SHADER_READ_BIT;
+    case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
+        return VK_ACCESS_TRANSFER_READ_BIT;
+    case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+        return VK_ACCESS_TRANSFER_WRITE_BIT;
     default:
         assert(!"Unsupported VkImageLayout");
         return (VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT);
@@ -347,13 +408,16 @@ VkPipelineStageFlags calcPipelineStageFlagsFromImageLayout(VkImageLayout layout)
     case VK_IMAGE_LAYOUT_UNDEFINED:
     case VK_IMAGE_LAYOUT_PREINITIALIZED:
     case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
-    case VK_IMAGE_LAYOUT_GENERAL:         return VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+    case VK_IMAGE_LAYOUT_GENERAL:
+        return VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
     case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
         return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
     case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
         return (VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: return VK_PIPELINE_STAGE_TRANSFER_BIT;
-    case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: return VK_PIPELINE_STAGE_TRANSFER_BIT;
+    case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
+        return VK_PIPELINE_STAGE_TRANSFER_BIT;
+    case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
+        return VK_PIPELINE_STAGE_TRANSFER_BIT;
     case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
     case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
     case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL:
@@ -364,7 +428,9 @@ VkPipelineStageFlags calcPipelineStageFlagsFromImageLayout(VkImageLayout layout)
     case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL:
         return (
             VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT);
-    default: assert(!"Unsupported VkImageLayout"); return VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
+    default:
+        assert(!"Unsupported VkImageLayout");
+        return VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
     }
 }
 
@@ -378,9 +444,12 @@ VkImageAspectFlags getAspectMaskFromFormat(VkFormat format)
         return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
     case VK_FORMAT_D16_UNORM:
     case VK_FORMAT_D32_SFLOAT:
-    case VK_FORMAT_X8_D24_UNORM_PACK32: return VK_IMAGE_ASPECT_DEPTH_BIT;
-    case VK_FORMAT_S8_UINT:             return VK_IMAGE_ASPECT_STENCIL_BIT;
-    default:                            return VK_IMAGE_ASPECT_COLOR_BIT;
+    case VK_FORMAT_X8_D24_UNORM_PACK32:
+        return VK_IMAGE_ASPECT_DEPTH_BIT;
+    case VK_FORMAT_S8_UINT:
+        return VK_IMAGE_ASPECT_STENCIL_BIT;
+    default:
+        return VK_IMAGE_ASPECT_COLOR_BIT;
     }
 }
 
diff --git a/tools/gfx/vulkan/vk-pipeline-state.cpp b/tools/gfx/vulkan/vk-pipeline-state.cpp
index 8fd0c5680..d850b499d 100644
--- a/tools/gfx/vulkan/vk-pipeline-state.cpp
+++ b/tools/gfx/vulkan/vk-pipeline-state.cpp
@@ -343,9 +343,13 @@ Result PipelineStateImpl::ensureAPIPipelineStateCreated()
 
     switch (desc.type)
     {
-    case PipelineType::Compute:  return createVKComputePipelineState();
-    case PipelineType::Graphics: return createVKGraphicsPipelineState();
-    default:                     SLANG_UNREACHABLE("Unknown pipeline type."); return SLANG_FAIL;
+    case PipelineType::Compute:
+        return createVKComputePipelineState();
+    case PipelineType::Graphics:
+        return createVKGraphicsPipelineState();
+    default:
+        SLANG_UNREACHABLE("Unknown pipeline type.");
+        return SLANG_FAIL;
     }
 }
 SLANG_NO_THROW Result SLANG_MCALL PipelineStateImpl::getNativeHandle(InteropHandle* outHandle)
@@ -493,8 +497,11 @@ Result RayTracingPipelineStateImpl::ensureAPIPipelineStateCreated()
 
     switch (desc.type)
     {
-    case PipelineType::RayTracing: return createVKRayTracingPipelineState();
-    default:                       SLANG_UNREACHABLE("Unknown pipeline type."); return SLANG_FAIL;
+    case PipelineType::RayTracing:
+        return createVKRayTracingPipelineState();
+    default:
+        SLANG_UNREACHABLE("Unknown pipeline type.");
+        return SLANG_FAIL;
     }
 }
 Result RayTracingPipelineStateImpl::getNativeHandle(InteropHandle* outHandle)
diff --git a/tools/gfx/vulkan/vk-query.cpp b/tools/gfx/vulkan/vk-query.cpp
index 694896966..910a65b87 100644
--- a/tools/gfx/vulkan/vk-query.cpp
+++ b/tools/gfx/vulkan/vk-query.cpp
@@ -19,7 +19,9 @@ Result QueryPoolImpl::init(const IQueryPool::Desc& desc, DeviceImpl* device)
     createInfo.queryCount = (uint32_t)desc.count;
     switch (desc.type)
     {
-    case QueryType::Timestamp: createInfo.queryType = VK_QUERY_TYPE_TIMESTAMP; break;
+    case QueryType::Timestamp:
+        createInfo.queryType = VK_QUERY_TYPE_TIMESTAMP;
+        break;
     case QueryType::AccelerationStructureCompactedSize:
         createInfo.queryType = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR;
         break;
@@ -29,7 +31,8 @@ Result QueryPoolImpl::init(const IQueryPool::Desc& desc, DeviceImpl* device)
     case QueryType::AccelerationStructureCurrentSize:
         // Vulkan does not support CurrentSize query, will not create actual pools here.
         return SLANG_OK;
-    default: return SLANG_E_INVALID_ARG;
+    default:
+        return SLANG_E_INVALID_ARG;
     }
     SLANG_VK_RETURN_ON_FAIL(
         m_device->m_api.vkCreateQueryPool(m_device->m_api.m_device, &createInfo, nullptr, &m_pool));
diff --git a/tools/gfx/vulkan/vk-shader-object-layout.cpp b/tools/gfx/vulkan/vk-shader-object-layout.cpp
index 6129246cb..676645449 100644
--- a/tools/gfx/vulkan/vk-shader-object-layout.cpp
+++ b/tools/gfx/vulkan/vk-shader-object-layout.cpp
@@ -31,22 +31,33 @@ VkDescriptorType ShaderObjectLayoutImpl::Builder::_mapDescriptorType(
     switch (slangBindingType)
     {
     case slang::BindingType::PushConstant:
-    default:                               SLANG_ASSERT("unsupported binding type"); return VK_DESCRIPTOR_TYPE_MAX_ENUM;
+    default:
+        SLANG_ASSERT("unsupported binding type");
+        return VK_DESCRIPTOR_TYPE_MAX_ENUM;
 
-    case slang::BindingType::Sampler: return VK_DESCRIPTOR_TYPE_SAMPLER;
+    case slang::BindingType::Sampler:
+        return VK_DESCRIPTOR_TYPE_SAMPLER;
     case slang::BindingType::CombinedTextureSampler:
         return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-    case slang::BindingType::Texture:            return VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
-    case slang::BindingType::MutableTexture:     return VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
-    case slang::BindingType::TypedBuffer:        return VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
-    case slang::BindingType::MutableTypedBuffer: return VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
+    case slang::BindingType::Texture:
+        return VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
+    case slang::BindingType::MutableTexture:
+        return VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+    case slang::BindingType::TypedBuffer:
+        return VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
+    case slang::BindingType::MutableTypedBuffer:
+        return VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
     case slang::BindingType::RawBuffer:
-    case slang::BindingType::MutableRawBuffer:   return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
-    case slang::BindingType::InputRenderTarget:  return VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
-    case slang::BindingType::InlineUniformData:  return VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
+    case slang::BindingType::MutableRawBuffer:
+        return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+    case slang::BindingType::InputRenderTarget:
+        return VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
+    case slang::BindingType::InlineUniformData:
+        return VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
     case slang::BindingType::RayTracingAccelerationStructure:
         return VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
-    case slang::BindingType::ConstantBuffer: return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+    case slang::BindingType::ConstantBuffer:
+        return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
     }
 }
 
@@ -84,7 +95,8 @@ void ShaderObjectLayoutImpl::Builder::_addDescriptorRangesAsValue(
         auto bindingRangeType = typeLayout->getBindingRangeType(bindingRangeIndex);
         switch (bindingRangeType)
         {
-        default: break;
+        default:
+            break;
 
         // We will skip over ranges that represent sub-objects for now, and handle
         // them in a separate pass.
@@ -92,7 +104,8 @@ void ShaderObjectLayoutImpl::Builder::_addDescriptorRangesAsValue(
         case slang::BindingType::ParameterBlock:
         case slang::BindingType::ConstantBuffer:
         case slang::BindingType::ExistentialValue:
-        case slang::BindingType::PushConstant:     continue;
+        case slang::BindingType::PushConstant:
+            continue;
         }
 
         // Given a binding range we are interested in, we will then enumerate
@@ -124,8 +137,10 @@ void ShaderObjectLayoutImpl::Builder::_addDescriptorRangesAsValue(
             {
             case slang::BindingType::ExistentialValue:
             case slang::BindingType::InlineUniformData:
-            case slang::BindingType::PushConstant:      continue;
-            default:                                    break;
+            case slang::BindingType::PushConstant:
+                continue;
+            default:
+                break;
             }
 
             auto vkDescriptorType = _mapDescriptorType(slangDescriptorType);
@@ -170,7 +185,8 @@ void ShaderObjectLayoutImpl::Builder::_addDescriptorRangesAsValue(
         // decriptor sets of a parent object.
         //
         case slang::BindingType::ParameterBlock:
-        default:                                 break;
+        default:
+            break;
 
         case slang::BindingType::ExistentialValue:
             // An interest/existential-typed sub-object range will only contribute
@@ -508,7 +524,8 @@ void ShaderObjectLayoutImpl::Builder::addBindingRanges(slang::TypeLayoutReflecti
             }
             break;
 
-        default: break;
+        default:
+            break;
         }
 
         m_subObjectRanges.add(subObjectRange);
diff --git a/tools/gfx/vulkan/vk-shader-object.cpp b/tools/gfx/vulkan/vk-shader-object.cpp
index 862f6137a..eaee69edb 100644
--- a/tools/gfx/vulkan/vk-shader-object.cpp
+++ b/tools/gfx/vulkan/vk-shader-object.cpp
@@ -672,7 +672,8 @@ Result ShaderObjectImpl::bindAsValue(
         {
         case slang::BindingType::ConstantBuffer:
         case slang::BindingType::ParameterBlock:
-        case slang::BindingType::ExistentialValue: break;
+        case slang::BindingType::ExistentialValue:
+            break;
 
         case slang::BindingType::Texture:
             rangeOffset.bindingSet += bindingRangeInfo.setOffset;
@@ -751,7 +752,8 @@ Result ShaderObjectImpl::bindAsValue(
                 m_resourceViews.getArrayView(baseIndex, count));
             break;
         case slang::BindingType::VaryingInput:
-        case slang::BindingType::VaryingOutput: break;
+        case slang::BindingType::VaryingOutput:
+            break;
 
         default:
             SLANG_ASSERT(!"unsupported binding type");
diff --git a/tools/gfx/vulkan/vk-util.cpp b/tools/gfx/vulkan/vk-util.cpp
index 696e80fc7..2490d48ce 100644
--- a/tools/gfx/vulkan/vk-util.cpp
+++ b/tools/gfx/vulkan/vk-util.cpp
@@ -13,111 +13,195 @@ namespace gfx
 {
     switch (format)
     {
-    case Format::R32G32B32A32_TYPELESS: return VK_FORMAT_R32G32B32A32_SFLOAT;
-    case Format::R32G32B32_TYPELESS:    return VK_FORMAT_R32G32B32_SFLOAT;
-    case Format::R32G32_TYPELESS:       return VK_FORMAT_R32G32_SFLOAT;
-    case Format::R32_TYPELESS:          return VK_FORMAT_R32_SFLOAT;
-
-    case Format::R16G16B16A16_TYPELESS: return VK_FORMAT_R16G16B16A16_SFLOAT;
-    case Format::R16G16_TYPELESS:       return VK_FORMAT_R16G16_SFLOAT;
-    case Format::R16_TYPELESS:          return VK_FORMAT_R16_SFLOAT;
-
-    case Format::R8G8B8A8_TYPELESS: return VK_FORMAT_R8G8B8A8_UNORM;
-    case Format::R8G8_TYPELESS:     return VK_FORMAT_R8G8_UNORM;
-    case Format::R8_TYPELESS:       return VK_FORMAT_R8_UNORM;
-    case Format::B8G8R8A8_TYPELESS: return VK_FORMAT_B8G8R8A8_UNORM;
-
-    case Format::R64_UINT: return VK_FORMAT_R64_UINT;
-
-    case Format::R32G32B32A32_FLOAT: return VK_FORMAT_R32G32B32A32_SFLOAT;
-    case Format::R32G32B32_FLOAT:    return VK_FORMAT_R32G32B32_SFLOAT;
-    case Format::R32G32_FLOAT:       return VK_FORMAT_R32G32_SFLOAT;
-    case Format::R32_FLOAT:          return VK_FORMAT_R32_SFLOAT;
-
-    case Format::R16G16B16A16_FLOAT: return VK_FORMAT_R16G16B16A16_SFLOAT;
-    case Format::R16G16_FLOAT:       return VK_FORMAT_R16G16_SFLOAT;
-    case Format::R16_FLOAT:          return VK_FORMAT_R16_SFLOAT;
-
-    case Format::R32G32B32A32_UINT: return VK_FORMAT_R32G32B32A32_UINT;
-    case Format::R32G32B32_UINT:    return VK_FORMAT_R32G32B32_UINT;
-    case Format::R32G32_UINT:       return VK_FORMAT_R32G32_UINT;
-    case Format::R32_UINT:          return VK_FORMAT_R32_UINT;
-
-    case Format::R16G16B16A16_UINT: return VK_FORMAT_R16G16B16A16_UINT;
-    case Format::R16G16_UINT:       return VK_FORMAT_R16G16_UINT;
-    case Format::R16_UINT:          return VK_FORMAT_R16_UINT;
-
-    case Format::R8G8B8A8_UINT: return VK_FORMAT_R8G8B8A8_UINT;
-    case Format::R8G8_UINT:     return VK_FORMAT_R8G8_UINT;
-    case Format::R8_UINT:       return VK_FORMAT_R8_UINT;
-
-    case Format::R64_SINT: return VK_FORMAT_R64_SINT;
-
-    case Format::R32G32B32A32_SINT: return VK_FORMAT_R32G32B32A32_SINT;
-    case Format::R32G32B32_SINT:    return VK_FORMAT_R32G32B32_SINT;
-    case Format::R32G32_SINT:       return VK_FORMAT_R32G32_SINT;
-    case Format::R32_SINT:          return VK_FORMAT_R32_SINT;
-
-    case Format::R16G16B16A16_SINT: return VK_FORMAT_R16G16B16A16_SINT;
-    case Format::R16G16_SINT:       return VK_FORMAT_R16G16_SINT;
-    case Format::R16_SINT:          return VK_FORMAT_R16_SINT;
-
-    case Format::R8G8B8A8_SINT: return VK_FORMAT_R8G8B8A8_SINT;
-    case Format::R8G8_SINT:     return VK_FORMAT_R8G8_SINT;
-    case Format::R8_SINT:       return VK_FORMAT_R8_SINT;
-
-    case Format::R16G16B16A16_UNORM: return VK_FORMAT_R16G16B16A16_UNORM;
-    case Format::R16G16_UNORM:       return VK_FORMAT_R16G16_UNORM;
-    case Format::R16_UNORM:          return VK_FORMAT_R16_UNORM;
-
-    case Format::R8G8B8A8_UNORM:      return VK_FORMAT_R8G8B8A8_UNORM;
-    case Format::R8G8B8A8_UNORM_SRGB: return VK_FORMAT_R8G8B8A8_SRGB;
-    case Format::R8G8_UNORM:          return VK_FORMAT_R8G8_UNORM;
-    case Format::R8_UNORM:            return VK_FORMAT_R8_UNORM;
-    case Format::B8G8R8A8_UNORM:      return VK_FORMAT_B8G8R8A8_UNORM;
-    case Format::B8G8R8A8_UNORM_SRGB: return VK_FORMAT_B8G8R8A8_SRGB;
-    case Format::B8G8R8X8_UNORM:      return VK_FORMAT_B8G8R8A8_UNORM;
-    case Format::B8G8R8X8_UNORM_SRGB: return VK_FORMAT_B8G8R8A8_SRGB;
-
-    case Format::R16G16B16A16_SNORM: return VK_FORMAT_R16G16B16A16_SNORM;
-    case Format::R16G16_SNORM:       return VK_FORMAT_R16G16_SNORM;
-    case Format::R16_SNORM:          return VK_FORMAT_R16_SNORM;
-
-    case Format::R8G8B8A8_SNORM: return VK_FORMAT_R8G8B8A8_SNORM;
-    case Format::R8G8_SNORM:     return VK_FORMAT_R8G8_SNORM;
-    case Format::R8_SNORM:       return VK_FORMAT_R8_SNORM;
-
-    case Format::D32_FLOAT:              return VK_FORMAT_D32_SFLOAT;
-    case Format::D16_UNORM:              return VK_FORMAT_D16_UNORM;
-    case Format::D32_FLOAT_S8_UINT:      return VK_FORMAT_D32_SFLOAT_S8_UINT;
-    case Format::R32_FLOAT_X32_TYPELESS: return VK_FORMAT_R32_SFLOAT;
-
-    case Format::B4G4R4A4_UNORM: return VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT;
-    case Format::B5G6R5_UNORM:   return VK_FORMAT_R5G6B5_UNORM_PACK16;
-    case Format::B5G5R5A1_UNORM: return VK_FORMAT_A1R5G5B5_UNORM_PACK16;
-
-    case Format::R9G9B9E5_SHAREDEXP:   return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
-    case Format::R10G10B10A2_TYPELESS: return VK_FORMAT_A2B10G10R10_UINT_PACK32;
-    case Format::R10G10B10A2_UINT:     return VK_FORMAT_A2B10G10R10_UINT_PACK32;
-    case Format::R10G10B10A2_UNORM:    return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
-    case Format::R11G11B10_FLOAT:      return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
-
-    case Format::BC1_UNORM:      return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
-    case Format::BC1_UNORM_SRGB: return VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
-    case Format::BC2_UNORM:      return VK_FORMAT_BC2_UNORM_BLOCK;
-    case Format::BC2_UNORM_SRGB: return VK_FORMAT_BC2_SRGB_BLOCK;
-    case Format::BC3_UNORM:      return VK_FORMAT_BC3_UNORM_BLOCK;
-    case Format::BC3_UNORM_SRGB: return VK_FORMAT_BC3_SRGB_BLOCK;
-    case Format::BC4_UNORM:      return VK_FORMAT_BC4_UNORM_BLOCK;
-    case Format::BC4_SNORM:      return VK_FORMAT_BC4_SNORM_BLOCK;
-    case Format::BC5_UNORM:      return VK_FORMAT_BC5_UNORM_BLOCK;
-    case Format::BC5_SNORM:      return VK_FORMAT_BC5_SNORM_BLOCK;
-    case Format::BC6H_UF16:      return VK_FORMAT_BC6H_UFLOAT_BLOCK;
-    case Format::BC6H_SF16:      return VK_FORMAT_BC6H_SFLOAT_BLOCK;
-    case Format::BC7_UNORM:      return VK_FORMAT_BC7_UNORM_BLOCK;
-    case Format::BC7_UNORM_SRGB: return VK_FORMAT_BC7_SRGB_BLOCK;
-
-    default: return VK_FORMAT_UNDEFINED;
+    case Format::R32G32B32A32_TYPELESS:
+        return VK_FORMAT_R32G32B32A32_SFLOAT;
+    case Format::R32G32B32_TYPELESS:
+        return VK_FORMAT_R32G32B32_SFLOAT;
+    case Format::R32G32_TYPELESS:
+        return VK_FORMAT_R32G32_SFLOAT;
+    case Format::R32_TYPELESS:
+        return VK_FORMAT_R32_SFLOAT;
+
+    case Format::R16G16B16A16_TYPELESS:
+        return VK_FORMAT_R16G16B16A16_SFLOAT;
+    case Format::R16G16_TYPELESS:
+        return VK_FORMAT_R16G16_SFLOAT;
+    case Format::R16_TYPELESS:
+        return VK_FORMAT_R16_SFLOAT;
+
+    case Format::R8G8B8A8_TYPELESS:
+        return VK_FORMAT_R8G8B8A8_UNORM;
+    case Format::R8G8_TYPELESS:
+        return VK_FORMAT_R8G8_UNORM;
+    case Format::R8_TYPELESS:
+        return VK_FORMAT_R8_UNORM;
+    case Format::B8G8R8A8_TYPELESS:
+        return VK_FORMAT_B8G8R8A8_UNORM;
+
+    case Format::R64_UINT:
+        return VK_FORMAT_R64_UINT;
+
+    case Format::R32G32B32A32_FLOAT:
+        return VK_FORMAT_R32G32B32A32_SFLOAT;
+    case Format::R32G32B32_FLOAT:
+        return VK_FORMAT_R32G32B32_SFLOAT;
+    case Format::R32G32_FLOAT:
+        return VK_FORMAT_R32G32_SFLOAT;
+    case Format::R32_FLOAT:
+        return VK_FORMAT_R32_SFLOAT;
+
+    case Format::R16G16B16A16_FLOAT:
+        return VK_FORMAT_R16G16B16A16_SFLOAT;
+    case Format::R16G16_FLOAT:
+        return VK_FORMAT_R16G16_SFLOAT;
+    case Format::R16_FLOAT:
+        return VK_FORMAT_R16_SFLOAT;
+
+    case Format::R32G32B32A32_UINT:
+        return VK_FORMAT_R32G32B32A32_UINT;
+    case Format::R32G32B32_UINT:
+        return VK_FORMAT_R32G32B32_UINT;
+    case Format::R32G32_UINT:
+        return VK_FORMAT_R32G32_UINT;
+    case Format::R32_UINT:
+        return VK_FORMAT_R32_UINT;
+
+    case Format::R16G16B16A16_UINT:
+        return VK_FORMAT_R16G16B16A16_UINT;
+    case Format::R16G16_UINT:
+        return VK_FORMAT_R16G16_UINT;
+    case Format::R16_UINT:
+        return VK_FORMAT_R16_UINT;
+
+    case Format::R8G8B8A8_UINT:
+        return VK_FORMAT_R8G8B8A8_UINT;
+    case Format::R8G8_UINT:
+        return VK_FORMAT_R8G8_UINT;
+    case Format::R8_UINT:
+        return VK_FORMAT_R8_UINT;
+
+    case Format::R64_SINT:
+        return VK_FORMAT_R64_SINT;
+
+    case Format::R32G32B32A32_SINT:
+        return VK_FORMAT_R32G32B32A32_SINT;
+    case Format::R32G32B32_SINT:
+        return VK_FORMAT_R32G32B32_SINT;
+    case Format::R32G32_SINT:
+        return VK_FORMAT_R32G32_SINT;
+    case Format::R32_SINT:
+        return VK_FORMAT_R32_SINT;
+
+    case Format::R16G16B16A16_SINT:
+        return VK_FORMAT_R16G16B16A16_SINT;
+    case Format::R16G16_SINT:
+        return VK_FORMAT_R16G16_SINT;
+    case Format::R16_SINT:
+        return VK_FORMAT_R16_SINT;
+
+    case Format::R8G8B8A8_SINT:
+        return VK_FORMAT_R8G8B8A8_SINT;
+    case Format::R8G8_SINT:
+        return VK_FORMAT_R8G8_SINT;
+    case Format::R8_SINT:
+        return VK_FORMAT_R8_SINT;
+
+    case Format::R16G16B16A16_UNORM:
+        return VK_FORMAT_R16G16B16A16_UNORM;
+    case Format::R16G16_UNORM:
+        return VK_FORMAT_R16G16_UNORM;
+    case Format::R16_UNORM:
+        return VK_FORMAT_R16_UNORM;
+
+    case Format::R8G8B8A8_UNORM:
+        return VK_FORMAT_R8G8B8A8_UNORM;
+    case Format::R8G8B8A8_UNORM_SRGB:
+        return VK_FORMAT_R8G8B8A8_SRGB;
+    case Format::R8G8_UNORM:
+        return VK_FORMAT_R8G8_UNORM;
+    case Format::R8_UNORM:
+        return VK_FORMAT_R8_UNORM;
+    case Format::B8G8R8A8_UNORM:
+        return VK_FORMAT_B8G8R8A8_UNORM;
+    case Format::B8G8R8A8_UNORM_SRGB:
+        return VK_FORMAT_B8G8R8A8_SRGB;
+    case Format::B8G8R8X8_UNORM:
+        return VK_FORMAT_B8G8R8A8_UNORM;
+    case Format::B8G8R8X8_UNORM_SRGB:
+        return VK_FORMAT_B8G8R8A8_SRGB;
+
+    case Format::R16G16B16A16_SNORM:
+        return VK_FORMAT_R16G16B16A16_SNORM;
+    case Format::R16G16_SNORM:
+        return VK_FORMAT_R16G16_SNORM;
+    case Format::R16_SNORM:
+        return VK_FORMAT_R16_SNORM;
+
+    case Format::R8G8B8A8_SNORM:
+        return VK_FORMAT_R8G8B8A8_SNORM;
+    case Format::R8G8_SNORM:
+        return VK_FORMAT_R8G8_SNORM;
+    case Format::R8_SNORM:
+        return VK_FORMAT_R8_SNORM;
+
+    case Format::D32_FLOAT:
+        return VK_FORMAT_D32_SFLOAT;
+    case Format::D16_UNORM:
+        return VK_FORMAT_D16_UNORM;
+    case Format::D32_FLOAT_S8_UINT:
+        return VK_FORMAT_D32_SFLOAT_S8_UINT;
+    case Format::R32_FLOAT_X32_TYPELESS:
+        return VK_FORMAT_R32_SFLOAT;
+
+    case Format::B4G4R4A4_UNORM:
+        return VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT;
+    case Format::B5G6R5_UNORM:
+        return VK_FORMAT_R5G6B5_UNORM_PACK16;
+    case Format::B5G5R5A1_UNORM:
+        return VK_FORMAT_A1R5G5B5_UNORM_PACK16;
+
+    case Format::R9G9B9E5_SHAREDEXP:
+        return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
+    case Format::R10G10B10A2_TYPELESS:
+        return VK_FORMAT_A2B10G10R10_UINT_PACK32;
+    case Format::R10G10B10A2_UINT:
+        return VK_FORMAT_A2B10G10R10_UINT_PACK32;
+    case Format::R10G10B10A2_UNORM:
+        return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+    case Format::R11G11B10_FLOAT:
+        return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
+
+    case Format::BC1_UNORM:
+        return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
+    case Format::BC1_UNORM_SRGB:
+        return VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
+    case Format::BC2_UNORM:
+        return VK_FORMAT_BC2_UNORM_BLOCK;
+    case Format::BC2_UNORM_SRGB:
+        return VK_FORMAT_BC2_SRGB_BLOCK;
+    case Format::BC3_UNORM:
+        return VK_FORMAT_BC3_UNORM_BLOCK;
+    case Format::BC3_UNORM_SRGB:
+        return VK_FORMAT_BC3_SRGB_BLOCK;
+    case Format::BC4_UNORM:
+        return VK_FORMAT_BC4_UNORM_BLOCK;
+    case Format::BC4_SNORM:
+        return VK_FORMAT_BC4_SNORM_BLOCK;
+    case Format::BC5_UNORM:
+        return VK_FORMAT_BC5_UNORM_BLOCK;
+    case Format::BC5_SNORM:
+        return VK_FORMAT_BC5_SNORM_BLOCK;
+    case Format::BC6H_UF16:
+        return VK_FORMAT_BC6H_UFLOAT_BLOCK;
+    case Format::BC6H_SF16:
+        return VK_FORMAT_BC6H_SFLOAT_BLOCK;
+    case Format::BC7_UNORM:
+        return VK_FORMAT_BC7_UNORM_BLOCK;
+    case Format::BC7_UNORM_SRGB:
+        return VK_FORMAT_BC7_SRGB_BLOCK;
+
+    default:
+        return VK_FORMAT_UNDEFINED;
     }
 }
 
@@ -134,22 +218,34 @@ VkImageAspectFlags VulkanUtil::getAspectMask(TextureAspect aspect, VkFormat form
             return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
         case VK_FORMAT_D16_UNORM:
         case VK_FORMAT_D32_SFLOAT:
-        case VK_FORMAT_X8_D24_UNORM_PACK32: return VK_IMAGE_ASPECT_DEPTH_BIT;
-        case VK_FORMAT_S8_UINT:             return VK_IMAGE_ASPECT_STENCIL_BIT;
-        default:                            return VK_IMAGE_ASPECT_COLOR_BIT;
+        case VK_FORMAT_X8_D24_UNORM_PACK32:
+            return VK_IMAGE_ASPECT_DEPTH_BIT;
+        case VK_FORMAT_S8_UINT:
+            return VK_IMAGE_ASPECT_STENCIL_BIT;
+        default:
+            return VK_IMAGE_ASPECT_COLOR_BIT;
         }
-    case TextureAspect::Color: return VK_IMAGE_ASPECT_COLOR_BIT;
-    case TextureAspect::Depth: return VK_IMAGE_ASPECT_DEPTH_BIT;
+    case TextureAspect::Color:
+        return VK_IMAGE_ASPECT_COLOR_BIT;
+    case TextureAspect::Depth:
+        return VK_IMAGE_ASPECT_DEPTH_BIT;
     case TextureAspect::DepthStencil:
         return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
-    case TextureAspect::Stencil: return VK_IMAGE_ASPECT_STENCIL_BIT;
-    case TextureAspect::Plane0:  return VK_IMAGE_ASPECT_PLANE_0_BIT;
-    case TextureAspect::Plane1:  return VK_IMAGE_ASPECT_PLANE_1_BIT;
-
-    case TextureAspect::Plane2: return VK_IMAGE_ASPECT_PLANE_2_BIT;
-
-    case TextureAspect::MetaData: return VK_IMAGE_ASPECT_METADATA_BIT;
-    default:                      SLANG_UNREACHABLE("getAspectMask"); return 0;
+    case TextureAspect::Stencil:
+        return VK_IMAGE_ASPECT_STENCIL_BIT;
+    case TextureAspect::Plane0:
+        return VK_IMAGE_ASPECT_PLANE_0_BIT;
+    case TextureAspect::Plane1:
+        return VK_IMAGE_ASPECT_PLANE_1_BIT;
+
+    case TextureAspect::Plane2:
+        return VK_IMAGE_ASPECT_PLANE_2_BIT;
+
+    case TextureAspect::MetaData:
+        return VK_IMAGE_ASPECT_METADATA_BIT;
+    default:
+        SLANG_UNREACHABLE("getAspectMask");
+        return 0;
     }
 }
 
@@ -162,21 +258,37 @@ VkShaderStageFlags VulkanUtil::getShaderStage(SlangStage stage)
 {
     switch (stage)
     {
-    case SLANG_STAGE_ANY_HIT:        return VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
-    case SLANG_STAGE_CALLABLE:       return VK_SHADER_STAGE_CALLABLE_BIT_KHR;
-    case SLANG_STAGE_CLOSEST_HIT:    return VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
-    case SLANG_STAGE_COMPUTE:        return VK_SHADER_STAGE_COMPUTE_BIT;
-    case SLANG_STAGE_DOMAIN:         return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
-    case SLANG_STAGE_FRAGMENT:       return VK_SHADER_STAGE_FRAGMENT_BIT;
-    case SLANG_STAGE_GEOMETRY:       return VK_SHADER_STAGE_GEOMETRY_BIT;
-    case SLANG_STAGE_HULL:           return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
-    case SLANG_STAGE_INTERSECTION:   return VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
-    case SLANG_STAGE_MISS:           return VK_SHADER_STAGE_MISS_BIT_KHR;
-    case SLANG_STAGE_RAY_GENERATION: return VK_SHADER_STAGE_RAYGEN_BIT_KHR;
-    case SLANG_STAGE_VERTEX:         return VK_SHADER_STAGE_VERTEX_BIT;
-    case SLANG_STAGE_MESH:           return VK_SHADER_STAGE_MESH_BIT_EXT;
-    case SLANG_STAGE_AMPLIFICATION:  return VK_SHADER_STAGE_TASK_BIT_EXT;
-    default:                         assert(!"unsupported stage."); return VkShaderStageFlags(-1);
+    case SLANG_STAGE_ANY_HIT:
+        return VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
+    case SLANG_STAGE_CALLABLE:
+        return VK_SHADER_STAGE_CALLABLE_BIT_KHR;
+    case SLANG_STAGE_CLOSEST_HIT:
+        return VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
+    case SLANG_STAGE_COMPUTE:
+        return VK_SHADER_STAGE_COMPUTE_BIT;
+    case SLANG_STAGE_DOMAIN:
+        return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
+    case SLANG_STAGE_FRAGMENT:
+        return VK_SHADER_STAGE_FRAGMENT_BIT;
+    case SLANG_STAGE_GEOMETRY:
+        return VK_SHADER_STAGE_GEOMETRY_BIT;
+    case SLANG_STAGE_HULL:
+        return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
+    case SLANG_STAGE_INTERSECTION:
+        return VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
+    case SLANG_STAGE_MISS:
+        return VK_SHADER_STAGE_MISS_BIT_KHR;
+    case SLANG_STAGE_RAY_GENERATION:
+        return VK_SHADER_STAGE_RAYGEN_BIT_KHR;
+    case SLANG_STAGE_VERTEX:
+        return VK_SHADER_STAGE_VERTEX_BIT;
+    case SLANG_STAGE_MESH:
+        return VK_SHADER_STAGE_MESH_BIT_EXT;
+    case SLANG_STAGE_AMPLIFICATION:
+        return VK_SHADER_STAGE_TASK_BIT_EXT;
+    default:
+        assert(!"unsupported stage.");
+        return VkShaderStageFlags(-1);
     }
 }
 
@@ -186,18 +298,29 @@ VkImageLayout VulkanUtil::getImageLayoutFromState(ResourceState state)
     {
     case ResourceState::ShaderResource:
     case ResourceState::PixelShaderResource:
-    case ResourceState::NonPixelShaderResource: return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    case ResourceState::NonPixelShaderResource:
+        return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
     case ResourceState::UnorderedAccess:
-    case ResourceState::General:                return VK_IMAGE_LAYOUT_GENERAL;
-    case ResourceState::Present:                return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-    case ResourceState::CopySource:             return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-    case ResourceState::CopyDestination:        return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-    case ResourceState::RenderTarget:           return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-    case ResourceState::DepthWrite:             return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-    case ResourceState::DepthRead:              return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
-    case ResourceState::ResolveSource:          return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-    case ResourceState::ResolveDestination:     return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-    default:                                    return VK_IMAGE_LAYOUT_UNDEFINED;
+    case ResourceState::General:
+        return VK_IMAGE_LAYOUT_GENERAL;
+    case ResourceState::Present:
+        return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+    case ResourceState::CopySource:
+        return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    case ResourceState::CopyDestination:
+        return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+    case ResourceState::RenderTarget:
+        return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+    case ResourceState::DepthWrite:
+        return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+    case ResourceState::DepthRead:
+        return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
+    case ResourceState::ResolveSource:
+        return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    case ResourceState::ResolveDestination:
+        return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+    default:
+        return VK_IMAGE_LAYOUT_UNDEFINED;
     }
     return VkImageLayout();
 }
@@ -206,14 +329,23 @@ VkSampleCountFlagBits VulkanUtil::translateSampleCount(uint32_t sampleCount)
 {
     switch (sampleCount)
     {
-    case 1:  return VK_SAMPLE_COUNT_1_BIT;
-    case 2:  return VK_SAMPLE_COUNT_2_BIT;
-    case 4:  return VK_SAMPLE_COUNT_4_BIT;
-    case 8:  return VK_SAMPLE_COUNT_8_BIT;
-    case 16: return VK_SAMPLE_COUNT_16_BIT;
-    case 32: return VK_SAMPLE_COUNT_32_BIT;
-    case 64: return VK_SAMPLE_COUNT_64_BIT;
-    default: assert(!"Unsupported sample count"); return VK_SAMPLE_COUNT_1_BIT;
+    case 1:
+        return VK_SAMPLE_COUNT_1_BIT;
+    case 2:
+        return VK_SAMPLE_COUNT_2_BIT;
+    case 4:
+        return VK_SAMPLE_COUNT_4_BIT;
+    case 8:
+        return VK_SAMPLE_COUNT_8_BIT;
+    case 16:
+        return VK_SAMPLE_COUNT_16_BIT;
+    case 32:
+        return VK_SAMPLE_COUNT_32_BIT;
+    case 64:
+        return VK_SAMPLE_COUNT_64_BIT;
+    default:
+        assert(!"Unsupported sample count");
+        return VK_SAMPLE_COUNT_1_BIT;
     }
 }
 
@@ -221,10 +353,15 @@ VkCullModeFlags VulkanUtil::translateCullMode(CullMode cullMode)
 {
     switch (cullMode)
     {
-    case CullMode::None:  return VK_CULL_MODE_NONE;
-    case CullMode::Front: return VK_CULL_MODE_FRONT_BIT;
-    case CullMode::Back:  return VK_CULL_MODE_BACK_BIT;
-    default:              assert(!"Unsupported cull mode"); return VK_CULL_MODE_NONE;
+    case CullMode::None:
+        return VK_CULL_MODE_NONE;
+    case CullMode::Front:
+        return VK_CULL_MODE_FRONT_BIT;
+    case CullMode::Back:
+        return VK_CULL_MODE_BACK_BIT;
+    default:
+        assert(!"Unsupported cull mode");
+        return VK_CULL_MODE_NONE;
     }
 }
 
@@ -232,9 +369,13 @@ VkFrontFace VulkanUtil::translateFrontFaceMode(FrontFaceMode frontFaceMode)
 {
     switch (frontFaceMode)
     {
-    case FrontFaceMode::CounterClockwise: return VK_FRONT_FACE_COUNTER_CLOCKWISE;
-    case FrontFaceMode::Clockwise:        return VK_FRONT_FACE_CLOCKWISE;
-    default:                              assert(!"Unsupported front face mode"); return VK_FRONT_FACE_CLOCKWISE;
+    case FrontFaceMode::CounterClockwise:
+        return VK_FRONT_FACE_COUNTER_CLOCKWISE;
+    case FrontFaceMode::Clockwise:
+        return VK_FRONT_FACE_CLOCKWISE;
+    default:
+        assert(!"Unsupported front face mode");
+        return VK_FRONT_FACE_CLOCKWISE;
     }
 }
 
@@ -242,9 +383,13 @@ VkPolygonMode VulkanUtil::translateFillMode(FillMode fillMode)
 {
     switch (fillMode)
     {
-    case FillMode::Solid:     return VK_POLYGON_MODE_FILL;
-    case FillMode::Wireframe: return VK_POLYGON_MODE_LINE;
-    default:                  assert(!"Unsupported fill mode"); return VK_POLYGON_MODE_FILL;
+    case FillMode::Solid:
+        return VK_POLYGON_MODE_FILL;
+    case FillMode::Wireframe:
+        return VK_POLYGON_MODE_LINE;
+    default:
+        assert(!"Unsupported fill mode");
+        return VK_POLYGON_MODE_FILL;
     }
 }
 
@@ -252,25 +397,44 @@ VkBlendFactor VulkanUtil::translateBlendFactor(BlendFactor blendFactor)
 {
     switch (blendFactor)
     {
-    case BlendFactor::Zero:                 return VK_BLEND_FACTOR_ZERO;
-    case BlendFactor::One:                  return VK_BLEND_FACTOR_ONE;
-    case BlendFactor::SrcColor:             return VK_BLEND_FACTOR_SRC_COLOR;
-    case BlendFactor::InvSrcColor:          return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
-    case BlendFactor::SrcAlpha:             return VK_BLEND_FACTOR_SRC_ALPHA;
-    case BlendFactor::InvSrcAlpha:          return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
-    case BlendFactor::DestAlpha:            return VK_BLEND_FACTOR_DST_ALPHA;
-    case BlendFactor::InvDestAlpha:         return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
-    case BlendFactor::DestColor:            return VK_BLEND_FACTOR_DST_COLOR;
-    case BlendFactor::InvDestColor:         return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
-    case BlendFactor::SrcAlphaSaturate:     return VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
-    case BlendFactor::BlendColor:           return VK_BLEND_FACTOR_CONSTANT_COLOR;
-    case BlendFactor::InvBlendColor:        return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
-    case BlendFactor::SecondarySrcColor:    return VK_BLEND_FACTOR_SRC1_COLOR;
-    case BlendFactor::InvSecondarySrcColor: return VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR;
-    case BlendFactor::SecondarySrcAlpha:    return VK_BLEND_FACTOR_SRC1_ALPHA;
-    case BlendFactor::InvSecondarySrcAlpha: return VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA;
-
-    default: assert(!"Unsupported blend factor"); return VK_BLEND_FACTOR_ONE;
+    case BlendFactor::Zero:
+        return VK_BLEND_FACTOR_ZERO;
+    case BlendFactor::One:
+        return VK_BLEND_FACTOR_ONE;
+    case BlendFactor::SrcColor:
+        return VK_BLEND_FACTOR_SRC_COLOR;
+    case BlendFactor::InvSrcColor:
+        return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
+    case BlendFactor::SrcAlpha:
+        return VK_BLEND_FACTOR_SRC_ALPHA;
+    case BlendFactor::InvSrcAlpha:
+        return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+    case BlendFactor::DestAlpha:
+        return VK_BLEND_FACTOR_DST_ALPHA;
+    case BlendFactor::InvDestAlpha:
+        return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
+    case BlendFactor::DestColor:
+        return VK_BLEND_FACTOR_DST_COLOR;
+    case BlendFactor::InvDestColor:
+        return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
+    case BlendFactor::SrcAlphaSaturate:
+        return VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
+    case BlendFactor::BlendColor:
+        return VK_BLEND_FACTOR_CONSTANT_COLOR;
+    case BlendFactor::InvBlendColor:
+        return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
+    case BlendFactor::SecondarySrcColor:
+        return VK_BLEND_FACTOR_SRC1_COLOR;
+    case BlendFactor::InvSecondarySrcColor:
+        return VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR;
+    case BlendFactor::SecondarySrcAlpha:
+        return VK_BLEND_FACTOR_SRC1_ALPHA;
+    case BlendFactor::InvSecondarySrcAlpha:
+        return VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA;
+
+    default:
+        assert(!"Unsupported blend factor");
+        return VK_BLEND_FACTOR_ONE;
     }
 }
 
@@ -278,12 +442,19 @@ VkBlendOp VulkanUtil::translateBlendOp(BlendOp op)
 {
     switch (op)
     {
-    case BlendOp::Add:             return VK_BLEND_OP_ADD;
-    case BlendOp::Subtract:        return VK_BLEND_OP_SUBTRACT;
-    case BlendOp::ReverseSubtract: return VK_BLEND_OP_REVERSE_SUBTRACT;
-    case BlendOp::Min:             return VK_BLEND_OP_MIN;
-    case BlendOp::Max:             return VK_BLEND_OP_MAX;
-    default:                       assert(!"Unsupported blend op"); return VK_BLEND_OP_ADD;
+    case BlendOp::Add:
+        return VK_BLEND_OP_ADD;
+    case BlendOp::Subtract:
+        return VK_BLEND_OP_SUBTRACT;
+    case BlendOp::ReverseSubtract:
+        return VK_BLEND_OP_REVERSE_SUBTRACT;
+    case BlendOp::Min:
+        return VK_BLEND_OP_MIN;
+    case BlendOp::Max:
+        return VK_BLEND_OP_MAX;
+    default:
+        assert(!"Unsupported blend op");
+        return VK_BLEND_OP_ADD;
     }
 }
 
@@ -291,11 +462,17 @@ VkPrimitiveTopology VulkanUtil::translatePrimitiveTypeToListTopology(PrimitiveTy
 {
     switch (primitiveType)
     {
-    case PrimitiveType::Point:    return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
-    case PrimitiveType::Line:     return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
-    case PrimitiveType::Triangle: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-    case PrimitiveType::Patch:    return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
-    default:                      assert(!"unknown topology type."); return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case PrimitiveType::Point:
+        return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+    case PrimitiveType::Line:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
+    case PrimitiveType::Triangle:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case PrimitiveType::Patch:
+        return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
+    default:
+        assert(!"unknown topology type.");
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
     }
 }
 
@@ -303,15 +480,24 @@ VkStencilOp VulkanUtil::translateStencilOp(StencilOp op)
 {
     switch (op)
     {
-    case StencilOp::DecrementSaturate: return VK_STENCIL_OP_DECREMENT_AND_CLAMP;
-    case StencilOp::DecrementWrap:     return VK_STENCIL_OP_DECREMENT_AND_WRAP;
-    case StencilOp::IncrementSaturate: return VK_STENCIL_OP_INCREMENT_AND_CLAMP;
-    case StencilOp::IncrementWrap:     return VK_STENCIL_OP_INCREMENT_AND_WRAP;
-    case StencilOp::Invert:            return VK_STENCIL_OP_INVERT;
-    case StencilOp::Keep:              return VK_STENCIL_OP_KEEP;
-    case StencilOp::Replace:           return VK_STENCIL_OP_REPLACE;
-    case StencilOp::Zero:              return VK_STENCIL_OP_ZERO;
-    default:                           return VK_STENCIL_OP_KEEP;
+    case StencilOp::DecrementSaturate:
+        return VK_STENCIL_OP_DECREMENT_AND_CLAMP;
+    case StencilOp::DecrementWrap:
+        return VK_STENCIL_OP_DECREMENT_AND_WRAP;
+    case StencilOp::IncrementSaturate:
+        return VK_STENCIL_OP_INCREMENT_AND_CLAMP;
+    case StencilOp::IncrementWrap:
+        return VK_STENCIL_OP_INCREMENT_AND_WRAP;
+    case StencilOp::Invert:
+        return VK_STENCIL_OP_INVERT;
+    case StencilOp::Keep:
+        return VK_STENCIL_OP_KEEP;
+    case StencilOp::Replace:
+        return VK_STENCIL_OP_REPLACE;
+    case StencilOp::Zero:
+        return VK_STENCIL_OP_ZERO;
+    default:
+        return VK_STENCIL_OP_KEEP;
     }
 }
 
@@ -319,10 +505,12 @@ VkFilter VulkanUtil::translateFilterMode(TextureFilteringMode mode)
 {
     switch (mode)
     {
-    default: return VkFilter(0);
+    default:
+        return VkFilter(0);
 
-#define CASE(SRC, DST) \
-    case TextureFilteringMode::SRC: return VK_FILTER_##DST
+#define CASE(SRC, DST)              \
+    case TextureFilteringMode::SRC: \
+        return VK_FILTER_##DST
 
         CASE(Point, NEAREST);
         CASE(Linear, LINEAR);
@@ -335,10 +523,12 @@ VkSamplerMipmapMode VulkanUtil::translateMipFilterMode(TextureFilteringMode mode
 {
     switch (mode)
     {
-    default: return VkSamplerMipmapMode(0);
+    default:
+        return VkSamplerMipmapMode(0);
 
-#define CASE(SRC, DST) \
-    case TextureFilteringMode::SRC: return VK_SAMPLER_MIPMAP_MODE_##DST
+#define CASE(SRC, DST)              \
+    case TextureFilteringMode::SRC: \
+        return VK_SAMPLER_MIPMAP_MODE_##DST
 
         CASE(Point, NEAREST);
         CASE(Linear, LINEAR);
@@ -351,10 +541,12 @@ VkSamplerAddressMode VulkanUtil::translateAddressingMode(TextureAddressingMode m
 {
     switch (mode)
     {
-    default: return VkSamplerAddressMode(0);
+    default:
+        return VkSamplerAddressMode(0);
 
-#define CASE(SRC, DST) \
-    case TextureAddressingMode::SRC: return VK_SAMPLER_ADDRESS_MODE_##DST
+#define CASE(SRC, DST)               \
+    case TextureAddressingMode::SRC: \
+        return VK_SAMPLER_ADDRESS_MODE_##DST
 
         CASE(Wrap, REPEAT);
         CASE(ClampToEdge, CLAMP_TO_EDGE);
@@ -374,8 +566,9 @@ VkCompareOp VulkanUtil::translateComparisonFunc(ComparisonFunc func)
         // TODO: need to report failures
         return VK_COMPARE_OP_ALWAYS;
 
-#define CASE(FROM, TO) \
-    case ComparisonFunc::FROM: return VK_COMPARE_OP_##TO
+#define CASE(FROM, TO)         \
+    case ComparisonFunc::FROM: \
+        return VK_COMPARE_OP_##TO
 
         CASE(Never, NEVER);
         CASE(Less, LESS);
@@ -406,9 +599,12 @@ VkSamplerReductionMode VulkanUtil::translateReductionOp(TextureReductionOp op)
 {
     switch (op)
     {
-    case gfx::TextureReductionOp::Minimum: return VK_SAMPLER_REDUCTION_MODE_MIN;
-    case gfx::TextureReductionOp::Maximum: return VK_SAMPLER_REDUCTION_MODE_MAX;
-    default:                               return VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE;
+    case gfx::TextureReductionOp::Minimum:
+        return VK_SAMPLER_REDUCTION_MODE_MIN;
+    case gfx::TextureReductionOp::Maximum:
+        return VK_SAMPLER_REDUCTION_MODE_MAX;
+    default:
+        return VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE;
     }
 }
 
@@ -431,12 +627,18 @@ VkSamplerReductionMode VulkanUtil::translateReductionOp(TextureReductionOp op)
 {
     switch (topology)
     {
-    case PrimitiveTopology::LineList:      return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
-    case PrimitiveTopology::LineStrip:     return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
-    case PrimitiveTopology::TriangleList:  return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-    case PrimitiveTopology::TriangleStrip: return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
-    case PrimitiveTopology::PointList:     return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
-    default:                               break;
+    case PrimitiveTopology::LineList:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
+    case PrimitiveTopology::LineStrip:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
+    case PrimitiveTopology::TriangleList:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case PrimitiveTopology::TriangleStrip:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
+    case PrimitiveTopology::PointList:
+        return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+    default:
+        break;
     }
     assert(!"Unknown topology");
     return VK_PRIMITIVE_TOPOLOGY_MAX_ENUM;
@@ -446,20 +648,32 @@ VkImageLayout VulkanUtil::mapResourceStateToLayout(ResourceState state)
 {
     switch (state)
     {
-    case ResourceState::Undefined:              return VK_IMAGE_LAYOUT_UNDEFINED;
+    case ResourceState::Undefined:
+        return VK_IMAGE_LAYOUT_UNDEFINED;
     case ResourceState::ShaderResource:
     case ResourceState::PixelShaderResource:
-    case ResourceState::NonPixelShaderResource: return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-    case ResourceState::UnorderedAccess:        return VK_IMAGE_LAYOUT_GENERAL;
-    case ResourceState::RenderTarget:           return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-    case ResourceState::DepthRead:              return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
-    case ResourceState::DepthWrite:             return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-    case ResourceState::Present:                return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-    case ResourceState::CopySource:             return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-    case ResourceState::CopyDestination:        return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-    case ResourceState::ResolveSource:          return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
-    case ResourceState::ResolveDestination:     return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-    default:                                    return VK_IMAGE_LAYOUT_UNDEFINED;
+    case ResourceState::NonPixelShaderResource:
+        return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    case ResourceState::UnorderedAccess:
+        return VK_IMAGE_LAYOUT_GENERAL;
+    case ResourceState::RenderTarget:
+        return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+    case ResourceState::DepthRead:
+        return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
+    case ResourceState::DepthWrite:
+        return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+    case ResourceState::Present:
+        return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+    case ResourceState::CopySource:
+        return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    case ResourceState::CopyDestination:
+        return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+    case ResourceState::ResolveSource:
+        return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    case ResourceState::ResolveDestination:
+        return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+    default:
+        return VK_IMAGE_LAYOUT_UNDEFINED;
     }
 }
 
@@ -546,8 +760,12 @@ Result AccelerationStructureBuildGeometryInfoBuilder::build(
                 vkGeomData.triangles.maxVertex = geomDesc.content.triangles.vertexCount - 1;
                 switch (geomDesc.content.triangles.indexFormat)
                 {
-                case Format::R32_UINT: vkGeomData.triangles.indexType = VK_INDEX_TYPE_UINT32; break;
-                case Format::R16_UINT: vkGeomData.triangles.indexType = VK_INDEX_TYPE_UINT16; break;
+                case Format::R32_UINT:
+                    vkGeomData.triangles.indexType = VK_INDEX_TYPE_UINT32;
+                    break;
+                case Format::R16_UINT:
+                    vkGeomData.triangles.indexType = VK_INDEX_TYPE_UINT16;
+                    break;
                 case Format::Unknown:
                     vkGeomData.triangles.indexType = VK_INDEX_TYPE_NONE_KHR;
                     break;
diff --git a/tools/gfx/vulkan/vk-util.h b/tools/gfx/vulkan/vk-util.h
index a22c76fc3..4bad710a0 100644
--- a/tools/gfx/vulkan/vk-util.h
+++ b/tools/gfx/vulkan/vk-util.h
@@ -85,7 +85,8 @@ struct VulkanUtil
         case VK_FORMAT_D24_UNORM_S8_UINT:
         case VK_FORMAT_X8_D24_UNORM_PACK32:
         case VK_FORMAT_D32_SFLOAT:
-        case VK_FORMAT_D32_SFLOAT_S8_UINT:  return true;
+        case VK_FORMAT_D32_SFLOAT_S8_UINT:
+            return true;
         }
         return false;
     }
@@ -96,7 +97,8 @@ struct VulkanUtil
         {
         case VK_FORMAT_S8_UINT:
         case VK_FORMAT_D24_UNORM_S8_UINT:
-        case VK_FORMAT_D32_SFLOAT_S8_UINT: return true;
+        case VK_FORMAT_D32_SFLOAT_S8_UINT:
+            return true;
         }
         return false;
     }