format

* format

* Minor test fixes

* enable checking cpp format in ci

50 files changed, 1774 insertions, 1572 deletions

diff --git a/tools/gfx/vulkan/vk-api.cpp b/tools/gfx/vulkan/vk-api.cpp
index 8f5e4235b..3d2042a8d 100644
--- a/tools/gfx/vulkan/vk-api.cpp
+++ b/tools/gfx/vulkan/vk-api.cpp
@@ -3,22 +3,23 @@
 
 #include "core/slang-list.h"
 
-namespace gfx {
+namespace gfx
+{
 using namespace Slang;
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! VulkanApi !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-#define VK_API_CHECK_FUNCTION(x) && (x != nullptr)
-#define  VK_API_CHECK_FUNCTIONS(FUNCTION_LIST) true FUNCTION_LIST(VK_API_CHECK_FUNCTION)
+#define VK_API_CHECK_FUNCTION(x) &&(x != nullptr)
+#define VK_API_CHECK_FUNCTIONS(FUNCTION_LIST) true FUNCTION_LIST(VK_API_CHECK_FUNCTION)
 
 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);
-        default:
+    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");
             return false;
@@ -49,7 +50,7 @@ Slang::Result VulkanApi::initInstanceProcs(VkInstance instance)
 
     VK_API_ALL_INSTANCE_PROCS(VK_API_GET_INSTANCE_PROC)
 
-    // Get optional 
+    // Get optional
     VK_API_INSTANCE_PROCS_OPT(VK_API_GET_INSTANCE_PROC)
 
     if (!areDefined(ProcType::Instance))
@@ -108,7 +109,7 @@ int VulkanApi::findMemoryTypeIndex(uint32_t typeBits, VkMemoryPropertyFlags prop
     // bit holds current test bit against typeBits. Ie bit == 1 << typeBits
 
     uint32_t bit = 1;
-    for (int i = 0;  i < numMemoryTypes; ++i, bit += bit)
+    for (int i = 0; i < numMemoryTypes; ++i, bit += bit)
     {
         auto const& memoryType = m_deviceMemoryProperties.memoryTypes[i];
         if ((typeBits & bit) && (memoryType.propertyFlags & properties) == properties)
@@ -117,7 +118,7 @@ int VulkanApi::findMemoryTypeIndex(uint32_t typeBits, VkMemoryPropertyFlags prop
         }
     }
 
-    //assert(!"failed to find a usable memory type");
+    // assert(!"failed to find a usable memory type");
     return -1;
 }
 
@@ -130,10 +131,13 @@ int VulkanApi::findQueue(VkQueueFlags reqFlags) const
 
     Slang::List<VkQueueFamilyProperties> queueFamilies;
     queueFamilies.setCount(numQueueFamilies);
-    vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice, &numQueueFamilies, queueFamilies.getBuffer());
+    vkGetPhysicalDeviceQueueFamilyProperties(
+        m_physicalDevice,
+        &numQueueFamilies,
+        queueFamilies.getBuffer());
 
     // Find a queue that can service our needs
-    //VkQueueFlags reqQueueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT;
+    // VkQueueFlags reqQueueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT;
 
     int queueFamilyIndex = -1;
     for (int i = 0; i < int(numQueueFamilies); ++i)
@@ -147,4 +151,4 @@ int VulkanApi::findQueue(VkQueueFlags reqFlags) const
     return -1;
 }
 
-} // renderer_test
+} // namespace gfx
diff --git a/tools/gfx/vulkan/vk-api.h b/tools/gfx/vulkan/vk-api.h
index 04744369a..8b86bc281 100644
--- a/tools/gfx/vulkan/vk-api.h
+++ b/tools/gfx/vulkan/vk-api.h
@@ -3,7 +3,8 @@
 
 #include "vk-module.h"
 
-namespace gfx {
+namespace gfx
+{
 
 // clang-format off
 #define VK_API_GLOBAL_PROCS(x) \
@@ -242,86 +243,66 @@ struct VulkanExtendedFeatureProperties
 {
     // 16 bit storage features
     VkPhysicalDevice16BitStorageFeatures storage16BitFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR};
     // Atomic Float features
     VkPhysicalDeviceShaderAtomicFloatFeaturesEXT atomicFloatFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT};
     VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT atomicFloat2Features = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT};
     // Image int64 atomic features
     VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT imageInt64AtomicFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT};
     // Extended dynamic state features
     VkPhysicalDeviceExtendedDynamicStateFeaturesEXT extendedDynamicStateFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT};
     // Acceleration structure features
     VkPhysicalDeviceAccelerationStructureFeaturesKHR accelerationStructureFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR};
     // Ray tracing pipeline features
     VkPhysicalDeviceRayTracingPipelineFeaturesKHR rayTracingPipelineFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR};
     // Ray query (inline ray-tracing) features
     VkPhysicalDeviceRayQueryFeaturesKHR rayQueryFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR};
     // Inline uniform block features
     VkPhysicalDeviceInlineUniformBlockFeaturesEXT inlineUniformBlockFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT};
     // Robustness2 features
     VkPhysicalDeviceRobustness2FeaturesEXT robustness2Features = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT};
 
     VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV rayTracingInvocationReorderFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV};
 
     VkPhysicalDeviceVariablePointerFeaturesKHR variablePointersFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR};
 
     VkPhysicalDeviceComputeShaderDerivativesFeaturesNV computeShaderDerivativeFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV};
 
     // Clock features
-    VkPhysicalDeviceShaderClockFeaturesKHR clockFeatures = { 
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR
-    };
+    VkPhysicalDeviceShaderClockFeaturesKHR clockFeatures = {
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR};
 
     // Mesh shader features
     VkPhysicalDeviceMeshShaderFeaturesEXT meshShaderFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT};
 
     // Multiview features
     VkPhysicalDeviceMultiviewFeaturesKHR multiviewFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR 
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR};
 
     // Fragment shading rate features
     VkPhysicalDeviceFragmentShadingRateFeaturesKHR fragmentShadingRateFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR 
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR};
 
     // Vulkan 1.2 features.
     VkPhysicalDeviceVulkan12Features vulkan12Features = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES
-    };
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES};
 
     // Ray tracing validation features
     VkPhysicalDeviceRayTracingValidationFeaturesNV rayTracingValidationFeatures = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV
-    };
-
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV};
 };
 
 struct VulkanApi
@@ -335,38 +316,38 @@ struct VulkanApi
         Device,
     };
 
-        /// Returns true if all the functions in the class are defined
+    /// Returns true if all the functions in the class are defined
     bool areDefined(ProcType type) const;
 
-        /// Sets up global parameters
+    /// Sets up global parameters
     Slang::Result initGlobalProcs(const VulkanModule& module);
-        /// Initialize the instance functions
+    /// Initialize the instance functions
     Slang::Result initInstanceProcs(VkInstance instance);
 
-        /// Called before initDevice
+    /// Called before initDevice
     Slang::Result initPhysicalDevice(VkPhysicalDevice physicalDevice);
 
-        /// Initialize the device functions
+    /// Initialize the device functions
     Slang::Result initDeviceProcs(VkDevice device);
 
-        /// Type bits control which indices are tested against bit 0 for testing at index 0
-        /// properties - a memory type must have all the bits set as passed in
-        /// Returns -1 if couldn't find an appropriate memory type index
+    /// Type bits control which indices are tested against bit 0 for testing at index 0
+    /// properties - a memory type must have all the bits set as passed in
+    /// Returns -1 if couldn't find an appropriate memory type index
     int findMemoryTypeIndex(uint32_t typeBits, VkMemoryPropertyFlags properties) const;
 
-        /// Given queue required flags, finds a queue
+    /// Given queue required flags, finds a queue
     int findQueue(VkQueueFlags reqFlags) const;
 
-    const VulkanModule* m_module = nullptr;               ///< Module this was all loaded from
+    const VulkanModule* m_module = nullptr; ///< Module this was all loaded from
     VkInstance m_instance = VK_NULL_HANDLE;
     VkDevice m_device = VK_NULL_HANDLE;
     VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
 
-    VkPhysicalDeviceProperties                              m_deviceProperties;
-    VkPhysicalDeviceRayTracingPipelinePropertiesKHR         m_rtProperties;
-    VkPhysicalDeviceFeatures                                m_deviceFeatures;
-    VkPhysicalDeviceMemoryProperties                        m_deviceMemoryProperties;
-    VulkanExtendedFeatureProperties                         m_extendedFeatures;
+    VkPhysicalDeviceProperties m_deviceProperties;
+    VkPhysicalDeviceRayTracingPipelinePropertiesKHR m_rtProperties;
+    VkPhysicalDeviceFeatures m_deviceFeatures;
+    VkPhysicalDeviceMemoryProperties m_deviceMemoryProperties;
+    VulkanExtendedFeatureProperties m_extendedFeatures;
 };
 
-} // renderer_test
+} // namespace gfx
diff --git a/tools/gfx/vulkan/vk-base.h b/tools/gfx/vulkan/vk-base.h
index 3d765b42f..0e36c4454 100644
--- a/tools/gfx/vulkan/vk-base.h
+++ b/tools/gfx/vulkan/vk-base.h
@@ -16,41 +16,41 @@ namespace gfx
 namespace vk
 {
 
-    class DeviceImpl;
-    class InputLayoutImpl;
-    class BufferResourceImpl;
-    class FenceImpl;
-    class TextureResourceImpl;
-    class SamplerStateImpl;
-    class ResourceViewImpl;
-    class TextureResourceViewImpl;
-    class TexelBufferResourceViewImpl;
-    class PlainBufferResourceViewImpl;
-    class AccelerationStructureImpl;
-    class FramebufferLayoutImpl;
-    class RenderPassLayoutImpl;
-    class FramebufferImpl;
-    class PipelineStateImpl;
-    class RayTracingPipelineStateImpl;
-    class ShaderObjectLayoutImpl;
-    class EntryPointLayout;
-    class RootShaderObjectLayout;
-    class ShaderProgramImpl;
-    class PipelineCommandEncoder;
-    class ShaderObjectImpl;
-    class MutableShaderObjectImpl;
-    class RootShaderObjectImpl;
-    class MutableRootShaderObjectImpl;
-    class ShaderTableImpl;
-    class ResourceCommandEncoder;
-    class RenderCommandEncoder;
-    class ComputeCommandEncoder;
-    class RayTracingCommandEncoder;
-    class CommandBufferImpl;
-    class CommandQueueImpl;
-    class TransientResourceHeapImpl;
-    class QueryPoolImpl;
-    class SwapchainImpl;
+class DeviceImpl;
+class InputLayoutImpl;
+class BufferResourceImpl;
+class FenceImpl;
+class TextureResourceImpl;
+class SamplerStateImpl;
+class ResourceViewImpl;
+class TextureResourceViewImpl;
+class TexelBufferResourceViewImpl;
+class PlainBufferResourceViewImpl;
+class AccelerationStructureImpl;
+class FramebufferLayoutImpl;
+class RenderPassLayoutImpl;
+class FramebufferImpl;
+class PipelineStateImpl;
+class RayTracingPipelineStateImpl;
+class ShaderObjectLayoutImpl;
+class EntryPointLayout;
+class RootShaderObjectLayout;
+class ShaderProgramImpl;
+class PipelineCommandEncoder;
+class ShaderObjectImpl;
+class MutableShaderObjectImpl;
+class RootShaderObjectImpl;
+class MutableRootShaderObjectImpl;
+class ShaderTableImpl;
+class ResourceCommandEncoder;
+class RenderCommandEncoder;
+class ComputeCommandEncoder;
+class RayTracingCommandEncoder;
+class CommandBufferImpl;
+class CommandQueueImpl;
+class TransientResourceHeapImpl;
+class QueryPoolImpl;
+class SwapchainImpl;
 
 } // namespace vk
 } // namespace gfx
diff --git a/tools/gfx/vulkan/vk-buffer.cpp b/tools/gfx/vulkan/vk-buffer.cpp
index 721886d9f..76e64c32f 100644
--- a/tools/gfx/vulkan/vk-buffer.cpp
+++ b/tools/gfx/vulkan/vk-buffer.cpp
@@ -3,7 +3,7 @@
 
 #include "vk-util.h"
 #if SLANG_WINDOWS_FAMILY
-#    include <dxgi1_2.h>
+#include <dxgi1_2.h>
 #endif
 
 namespace gfx
@@ -28,20 +28,21 @@ Result VKBufferHandleRAII::init(
     m_memory = VK_NULL_HANDLE;
     m_buffer = VK_NULL_HANDLE;
 
-    VkBufferCreateInfo bufferCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+    VkBufferCreateInfo bufferCreateInfo = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
     bufferCreateInfo.size = bufferSize;
     bufferCreateInfo.usage = usage;
     bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
     VkExternalMemoryBufferCreateInfo externalMemoryBufferCreateInfo = {
-        VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO };
+        VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO};
     if (isShared)
     {
         externalMemoryBufferCreateInfo.handleTypes = extMemHandleType;
         bufferCreateInfo.pNext = &externalMemoryBufferCreateInfo;
     }
 
-    SLANG_VK_RETURN_ON_FAIL(api.vkCreateBuffer(api.m_device, &bufferCreateInfo, nullptr, &m_buffer));
+    SLANG_VK_RETURN_ON_FAIL(
+        api.vkCreateBuffer(api.m_device, &bufferCreateInfo, nullptr, &m_buffer));
 
     VkMemoryRequirements memoryReqs = {};
     api.vkGetBufferMemoryRequirements(api.m_device, m_buffer, &memoryReqs);
@@ -51,15 +52,15 @@ Result VKBufferHandleRAII::init(
 
     VkMemoryPropertyFlags actualMemoryProperites =
         api.m_deviceMemoryProperties.memoryTypes[memoryTypeIndex].propertyFlags;
-    VkMemoryAllocateInfo allocateInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+    VkMemoryAllocateInfo allocateInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
     allocateInfo.allocationSize = memoryReqs.size;
     allocateInfo.memoryTypeIndex = memoryTypeIndex;
 #if SLANG_WINDOWS_FAMILY
     VkExportMemoryWin32HandleInfoKHR exportMemoryWin32HandleInfo = {
-        VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR };
+        VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR};
 #endif
     VkExportMemoryAllocateInfoKHR exportMemoryAllocateInfo = {
-        VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR };
+        VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR};
     if (isShared)
     {
 #if SLANG_WINDOWS_FAMILY
@@ -71,13 +72,13 @@ Result VKBufferHandleRAII::init(
 
         exportMemoryAllocateInfo.pNext =
             extMemHandleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
-            ? &exportMemoryWin32HandleInfo
-            : nullptr;
+                ? &exportMemoryWin32HandleInfo
+                : nullptr;
 #endif
         exportMemoryAllocateInfo.handleTypes = extMemHandleType;
         allocateInfo.pNext = &exportMemoryAllocateInfo;
     }
-    VkMemoryAllocateFlagsInfo flagInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO };
+    VkMemoryAllocateFlagsInfo flagInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO};
     if (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT)
     {
         flagInfo.deviceMask = 1;
@@ -94,8 +95,7 @@ Result VKBufferHandleRAII::init(
 }
 
 BufferResourceImpl::BufferResourceImpl(const IBufferResource::Desc& desc, DeviceImpl* renderer)
-    : Parent(desc)
-    , m_renderer(renderer)
+    : Parent(desc), m_renderer(renderer)
 {
     assert(renderer);
 }
diff --git a/tools/gfx/vulkan/vk-buffer.h b/tools/gfx/vulkan/vk-buffer.h
index c824f3529..cc82cef90 100644
--- a/tools/gfx/vulkan/vk-buffer.h
+++ b/tools/gfx/vulkan/vk-buffer.h
@@ -29,7 +29,8 @@ public:
 
     VKBufferHandleRAII()
         : m_api(nullptr)
-    {}
+    {
+    }
 
     ~VKBufferHandleRAII()
     {
@@ -61,12 +62,12 @@ public:
     virtual SLANG_NO_THROW DeviceAddress SLANG_MCALL getDeviceAddress() override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getNativeResourceHandle(InteropHandle* outHandle) override;
+    getNativeResourceHandle(InteropHandle* outHandle) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL getSharedHandle(InteropHandle* outHandle) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        map(MemoryRange* rangeToRead, void** outPointer) override;
+    map(MemoryRange* rangeToRead, void** outPointer) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL unmap(MemoryRange* writtenRange) override;
 
diff --git a/tools/gfx/vulkan/vk-command-buffer.cpp b/tools/gfx/vulkan/vk-command-buffer.cpp
index 8e0b35750..320212c9a 100644
--- a/tools/gfx/vulkan/vk-command-buffer.cpp
+++ b/tools/gfx/vulkan/vk-command-buffer.cpp
@@ -24,10 +24,15 @@ ICommandBuffer* CommandBufferImpl::getInterface(const Guid& guid)
     return nullptr;
 }
 
-void CommandBufferImpl::comFree() { m_transientHeap.breakStrongReference(); }
+void CommandBufferImpl::comFree()
+{
+    m_transientHeap.breakStrongReference();
+}
 
 Result CommandBufferImpl::init(
-    DeviceImpl* renderer, VkCommandPool pool, TransientResourceHeapImpl* transientHeap)
+    DeviceImpl* renderer,
+    VkCommandPool pool,
+    TransientResourceHeapImpl* transientHeap)
 {
     m_renderer = renderer;
     m_transientHeap = transientHeap;
@@ -89,7 +94,9 @@ VkCommandBuffer CommandBufferImpl::getPreCommandBuffer()
 }
 
 void CommandBufferImpl::encodeRenderCommands(
-    IRenderPassLayout* renderPass, IFramebuffer* framebuffer, IRenderCommandEncoder** outEncoder)
+    IRenderPassLayout* renderPass,
+    IFramebuffer* framebuffer,
+    IRenderCommandEncoder** outEncoder)
 {
     if (!m_renderCommandEncoder)
     {
diff --git a/tools/gfx/vulkan/vk-command-buffer.h b/tools/gfx/vulkan/vk-command-buffer.h
index 1c1c76ebd..aa45fc56e 100644
--- a/tools/gfx/vulkan/vk-command-buffer.h
+++ b/tools/gfx/vulkan/vk-command-buffer.h
@@ -14,9 +14,7 @@ using namespace Slang;
 namespace vk
 {
 
-class CommandBufferImpl
-    : public ICommandBuffer
-    , public ComObject
+class CommandBufferImpl : public ICommandBuffer, public ComObject
 {
 public:
     // There are a pair of cyclic references between a `TransientResourceHeap` and
@@ -59,11 +57,11 @@ public:
         IFramebuffer* framebuffer,
         IRenderCommandEncoder** outEncoder) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        encodeComputeCommands(IComputeCommandEncoder** outEncoder) override;
+    encodeComputeCommands(IComputeCommandEncoder** outEncoder) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        encodeResourceCommands(IResourceCommandEncoder** outEncoder) override;
+    encodeResourceCommands(IResourceCommandEncoder** outEncoder) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        encodeRayTracingCommands(IRayTracingCommandEncoder** outEncoder) override;
+    encodeRayTracingCommands(IRayTracingCommandEncoder** outEncoder) override;
     virtual SLANG_NO_THROW void SLANG_MCALL close() override;
     virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outHandle) override;
 };
diff --git a/tools/gfx/vulkan/vk-command-encoder.cpp b/tools/gfx/vulkan/vk-command-encoder.cpp
index 7f3110ea5..f9caff437 100644
--- a/tools/gfx/vulkan/vk-command-encoder.cpp
+++ b/tools/gfx/vulkan/vk-command-encoder.cpp
@@ -3,6 +3,7 @@
 
 #include "vk-buffer.h"
 #include "vk-command-buffer.h"
+#include "vk-helper-functions.h"
 #include "vk-query.h"
 #include "vk-render-pass.h"
 #include "vk-resource-views.h"
@@ -12,8 +13,6 @@
 #include "vk-texture.h"
 #include "vk-transient-heap.h"
 
-#include "vk-helper-functions.h"
-
 namespace gfx
 {
 
@@ -26,15 +25,10 @@ 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;
     }
 }
 
@@ -63,8 +57,8 @@ void PipelineCommandEncoder::_uploadBufferData(
     auto& api = buffer->m_renderer->m_api;
     IBufferResource* stagingBuffer = nullptr;
     Offset stagingBufferOffset = 0;
-    transientHeap->allocateStagingBuffer(
-        size, stagingBuffer, stagingBufferOffset, MemoryType::Upload);
+    transientHeap
+        ->allocateStagingBuffer(size, stagingBuffer, stagingBufferOffset, MemoryType::Upload);
 
     BufferResourceImpl* stagingBufferImpl = static_cast<BufferResourceImpl*>(stagingBuffer);
 
@@ -93,7 +87,10 @@ void PipelineCommandEncoder::_uploadBufferData(
 }
 
 void PipelineCommandEncoder::uploadBufferDataImpl(
-    IBufferResource* buffer, Offset offset, Size size, void* data)
+    IBufferResource* buffer,
+    Offset offset,
+    Size size,
+    void* data)
 {
     m_vkPreCommandBuffer = m_commandBuffer->getPreCommandBuffer();
     _uploadBufferData(
@@ -105,7 +102,9 @@ void PipelineCommandEncoder::uploadBufferDataImpl(
         data);
 }
 
-Result PipelineCommandEncoder::bindRootShaderObjectImpl(RootShaderObjectImpl* rootShaderObject, VkPipelineBindPoint bindPoint)
+Result PipelineCommandEncoder::bindRootShaderObjectImpl(
+    RootShaderObjectImpl* rootShaderObject,
+    VkPipelineBindPoint bindPoint)
 {
     // Obtain specialized root layout.
     auto specializedLayout = rootShaderObject->getSpecializedLayout();
@@ -162,7 +161,8 @@ Result PipelineCommandEncoder::bindRootShaderObjectImpl(RootShaderObjectImpl* ro
 }
 
 Result PipelineCommandEncoder::setPipelineStateImpl(
-    IPipelineState* state, IShaderObject** outRootObject)
+    IPipelineState* state,
+    IShaderObject** outRootObject)
 {
     m_currentPipeline = static_cast<PipelineStateImpl*>(state);
     m_commandBuffer->m_mutableRootShaderObject = nullptr;
@@ -174,10 +174,12 @@ Result PipelineCommandEncoder::setPipelineStateImpl(
 }
 
 Result PipelineCommandEncoder::setPipelineStateWithRootObjectImpl(
-    IPipelineState* state, IShaderObject* rootObject)
+    IPipelineState* state,
+    IShaderObject* rootObject)
 {
     m_currentPipeline = static_cast<PipelineStateImpl*>(state);
-    m_commandBuffer->m_mutableRootShaderObject = static_cast<MutableRootShaderObjectImpl*>(rootObject);
+    m_commandBuffer->m_mutableRootShaderObject =
+        static_cast<MutableRootShaderObjectImpl*>(rootObject);
     return SLANG_OK;
 }
 
@@ -188,11 +190,11 @@ Result PipelineCommandEncoder::bindRenderState(VkPipelineBindPoint pipelineBindP
     // Get specialized pipeline state and bind it.
     //
     RootShaderObjectImpl* rootObjectImpl = m_commandBuffer->m_mutableRootShaderObject
-        ? m_commandBuffer->m_mutableRootShaderObject.Ptr()
-        : &m_commandBuffer->m_rootObject;
+                                               ? m_commandBuffer->m_mutableRootShaderObject.Ptr()
+                                               : &m_commandBuffer->m_rootObject;
     RefPtr<PipelineStateBase> newPipeline;
-    SLANG_RETURN_ON_FAIL(m_device->maybeSpecializePipeline(
-        m_currentPipeline, rootObjectImpl, newPipeline));
+    SLANG_RETURN_ON_FAIL(
+        m_device->maybeSpecializePipeline(m_currentPipeline, rootObjectImpl, newPipeline));
     PipelineStateImpl* newPipelineImpl = static_cast<PipelineStateImpl*>(newPipeline.Ptr());
 
     SLANG_RETURN_ON_FAIL(newPipelineImpl->ensureAPIPipelineStateCreated());
@@ -206,12 +208,16 @@ Result PipelineCommandEncoder::bindRenderState(VkPipelineBindPoint pipelineBindP
         api.vkCmdBindPipeline(m_vkCommandBuffer, pipelineBindPoint, newPipelineImpl->m_pipeline);
         m_boundPipelines[pipelineBindPointId] = newPipelineImpl->m_pipeline;
     }
-    
+
     return SLANG_OK;
 }
 
 void ResourceCommandEncoder::copyBuffer(
-    IBufferResource* dst, Offset dstOffset, IBufferResource* src, Offset srcOffset, Size size)
+    IBufferResource* dst,
+    Offset dstOffset,
+    IBufferResource* src,
+    Offset srcOffset,
+    Size size)
 {
     auto& vkAPI = m_commandBuffer->m_renderer->m_api;
 
@@ -236,7 +242,10 @@ void ResourceCommandEncoder::copyBuffer(
 }
 
 void ResourceCommandEncoder::uploadBufferData(
-    IBufferResource* buffer, Offset offset, Size size, void* data)
+    IBufferResource* buffer,
+    Offset offset,
+    Size size,
+    void* data)
 {
     PipelineCommandEncoder::_uploadBufferData(
         m_commandBuffer->m_commandBuffer,
@@ -248,7 +257,10 @@ void ResourceCommandEncoder::uploadBufferData(
 }
 
 void ResourceCommandEncoder::textureBarrier(
-    GfxCount count, ITextureResource* const* textures, ResourceState src, ResourceState dst)
+    GfxCount count,
+    ITextureResource* const* textures,
+    ResourceState src,
+    ResourceState dst)
 {
     ShortList<VkImageMemoryBarrier, 16> barriers;
 
@@ -262,7 +274,8 @@ void ResourceCommandEncoder::textureBarrier(
         barrier.image = image->m_image;
         barrier.oldLayout = translateImageLayout(src);
         barrier.newLayout = translateImageLayout(dst);
-        barrier.subresourceRange.aspectMask = getAspectMaskFromFormat(VulkanUtil::getVkFormat(desc->format));
+        barrier.subresourceRange.aspectMask =
+            getAspectMaskFromFormat(VulkanUtil::getVkFormat(desc->format));
         barrier.subresourceRange.baseArrayLayer = 0;
         barrier.subresourceRange.baseMipLevel = 0;
         barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
@@ -291,7 +304,10 @@ void ResourceCommandEncoder::textureBarrier(
 
 // TODO: Change size_t to Count?
 void ResourceCommandEncoder::bufferBarrier(
-    GfxCount count, IBufferResource* const* buffers, ResourceState src, ResourceState dst)
+    GfxCount count,
+    IBufferResource* const* buffers,
+    ResourceState src,
+    ResourceState dst)
 {
     List<VkBufferMemoryBarrier> barriers;
     barriers.reserve(count);
@@ -352,7 +368,10 @@ void ResourceCommandEncoder::endEncoding()
 void ResourceCommandEncoder::writeTimestamp(IQueryPool* queryPool, GfxIndex index)
 {
     _writeTimestamp(
-        &m_commandBuffer->m_renderer->m_api, m_commandBuffer->m_commandBuffer, queryPool, index);
+        &m_commandBuffer->m_renderer->m_api,
+        m_commandBuffer->m_commandBuffer,
+        queryPool,
+        index);
 }
 
 void ResourceCommandEncoder::copyTexture(
@@ -389,12 +408,14 @@ void ResourceCommandEncoder::copyTexture(
         srcSubresource.mipLevelCount = dstDesc->numMipLevels;
     }
     VkImageCopy region = {};
-    region.srcSubresource.aspectMask = VulkanUtil::getAspectMask(srcSubresource.aspectMask, srcImage->m_vkformat);
+    region.srcSubresource.aspectMask =
+        VulkanUtil::getAspectMask(srcSubresource.aspectMask, srcImage->m_vkformat);
     region.srcSubresource.baseArrayLayer = srcSubresource.baseArrayLayer;
     region.srcSubresource.mipLevel = srcSubresource.mipLevel;
     region.srcSubresource.layerCount = srcSubresource.layerCount;
     region.srcOffset = {(int32_t)srcOffset.x, (int32_t)srcOffset.y, (int32_t)srcOffset.z};
-    region.dstSubresource.aspectMask = VulkanUtil::getAspectMask(dstSubresource.aspectMask, dstImage->m_vkformat);
+    region.dstSubresource.aspectMask =
+        VulkanUtil::getAspectMask(dstSubresource.aspectMask, dstImage->m_vkformat);
     region.dstSubresource.baseArrayLayer = dstSubresource.baseArrayLayer;
     region.dstSubresource.mipLevel = dstSubresource.mipLevel;
     region.dstSubresource.layerCount = dstSubresource.layerCount;
@@ -450,8 +471,8 @@ void ResourceCommandEncoder::uploadTextureData(
 
     IBufferResource* uploadBuffer = nullptr;
     Offset uploadBufferOffset = 0;
-    m_commandBuffer->m_transientHeap->allocateStagingBuffer(
-        bufferSize, uploadBuffer, uploadBufferOffset, MemoryType::Upload);
+    m_commandBuffer->m_transientHeap
+        ->allocateStagingBuffer(bufferSize, uploadBuffer, uploadBufferOffset, MemoryType::Upload);
 
     // Copy into upload buffer
     {
@@ -535,7 +556,9 @@ void ResourceCommandEncoder::uploadTextureData(
                 region.imageSubresource.layerCount = 1;
                 region.imageOffset = {0, 0, 0};
                 region.imageExtent = {
-                    uint32_t(mipSize.width), uint32_t(mipSize.height), uint32_t(mipSize.depth)};
+                    uint32_t(mipSize.width),
+                    uint32_t(mipSize.height),
+                    uint32_t(mipSize.depth)};
 
                 // Do the copy (do all depths in a single go)
                 vkApi.vkCmdCopyBufferToImage(
@@ -554,7 +577,8 @@ void ResourceCommandEncoder::uploadTextureData(
 }
 
 void ResourceCommandEncoder::_clearColorImage(
-    TextureResourceViewImpl* viewImpl, ClearValue* clearValue)
+    TextureResourceViewImpl* viewImpl,
+    ClearValue* clearValue)
 {
     auto& api = m_commandBuffer->m_renderer->m_api;
     auto layout = viewImpl->m_layout;
@@ -601,7 +625,9 @@ void ResourceCommandEncoder::_clearColorImage(
 }
 
 void ResourceCommandEncoder::_clearDepthImage(
-    TextureResourceViewImpl* viewImpl, ClearValue* clearValue, ClearResourceViewFlags::Enum flags)
+    TextureResourceViewImpl* viewImpl,
+    ClearValue* clearValue,
+    ClearResourceViewFlags::Enum flags)
 {
     auto& api = m_commandBuffer->m_renderer->m_api;
     auto layout = viewImpl->m_layout;
@@ -662,17 +688,26 @@ void ResourceCommandEncoder::_clearDepthImage(
 }
 
 void ResourceCommandEncoder::_clearBuffer(
-    VkBuffer buffer, uint64_t bufferSize, const IResourceView::Desc& desc, uint32_t clearValue)
+    VkBuffer buffer,
+    uint64_t bufferSize,
+    const IResourceView::Desc& desc,
+    uint32_t clearValue)
 {
     auto& api = m_commandBuffer->m_renderer->m_api;
     auto clearOffset = desc.bufferRange.offset;
     auto clearSize = desc.bufferRange.size == 0 ? bufferSize - clearOffset : desc.bufferRange.size;
     api.vkCmdFillBuffer(
-        m_commandBuffer->m_commandBuffer, buffer, clearOffset, clearSize, clearValue);
+        m_commandBuffer->m_commandBuffer,
+        buffer,
+        clearOffset,
+        clearSize,
+        clearValue);
 }
 
 void ResourceCommandEncoder::clearResourceView(
-    IResourceView* view, ClearValue* clearValue, ClearResourceViewFlags::Enum flags)
+    IResourceView* view,
+    ClearValue* clearValue,
+    ClearResourceViewFlags::Enum flags)
 {
     auto& api = m_commandBuffer->m_renderer->m_api;
     switch (view->getViewDesc()->type)
@@ -770,18 +805,22 @@ void ResourceCommandEncoder::resolveResource(
         for (GfxIndex mip = 0; mip < sourceRange.mipLevelCount; ++mip)
         {
             VkImageResolve region = {};
-            region.srcSubresource.aspectMask = VulkanUtil::getAspectMask(sourceRange.aspectMask, srcTexture->m_vkformat);
+            region.srcSubresource.aspectMask =
+                VulkanUtil::getAspectMask(sourceRange.aspectMask, srcTexture->m_vkformat);
             region.srcSubresource.baseArrayLayer = layer + sourceRange.baseArrayLayer;
             region.srcSubresource.layerCount = 1;
             region.srcSubresource.mipLevel = mip + sourceRange.mipLevel;
             region.srcOffset = {0, 0, 0};
-            region.dstSubresource.aspectMask = VulkanUtil::getAspectMask(destRange.aspectMask, dstTexture->m_vkformat);
+            region.dstSubresource.aspectMask =
+                VulkanUtil::getAspectMask(destRange.aspectMask, dstTexture->m_vkformat);
             region.dstSubresource.baseArrayLayer = layer + destRange.baseArrayLayer;
             region.dstSubresource.layerCount = 1;
             region.dstSubresource.mipLevel = mip + destRange.mipLevel;
             region.dstOffset = {0, 0, 0};
             region.extent = {
-                (uint32_t)srcExtent.width, (uint32_t)srcExtent.height, (uint32_t)srcExtent.depth};
+                (uint32_t)srcExtent.width,
+                (uint32_t)srcExtent.height,
+                (uint32_t)srcExtent.depth};
 
             auto& vkApi = m_commandBuffer->m_renderer->m_api;
             vkApi.vkCmdResolveImage(
@@ -797,7 +836,11 @@ void ResourceCommandEncoder::resolveResource(
 }
 
 void ResourceCommandEncoder::resolveQuery(
-    IQueryPool* queryPool, GfxIndex index, GfxCount count, IBufferResource* buffer, Offset offset)
+    IQueryPool* queryPool,
+    GfxIndex index,
+    GfxCount count,
+    IBufferResource* buffer,
+    Offset offset)
 {
     auto& vkApi = m_commandBuffer->m_renderer->m_api;
     auto poolImpl = static_cast<QueryPoolImpl*>(queryPool);
@@ -835,7 +878,8 @@ void ResourceCommandEncoder::copyTextureToBuffer(
     region.bufferOffset = dstOffset;
     region.bufferRowLength = 0;
     region.bufferImageHeight = 0;
-    region.imageSubresource.aspectMask = VulkanUtil::getAspectMask(srcSubresource.aspectMask, image->m_vkformat);
+    region.imageSubresource.aspectMask =
+        VulkanUtil::getAspectMask(srcSubresource.aspectMask, image->m_vkformat);
     region.imageSubresource.mipLevel = srcSubresource.mipLevel;
     region.imageSubresource.baseArrayLayer = srcSubresource.baseArrayLayer;
     region.imageSubresource.layerCount = srcSubresource.layerCount;
@@ -867,7 +911,8 @@ void ResourceCommandEncoder::textureSubresourceBarrier(
     barrier.image = image->m_image;
     barrier.oldLayout = translateImageLayout(src);
     barrier.newLayout = translateImageLayout(dst);
-    barrier.subresourceRange.aspectMask = VulkanUtil::getAspectMask(subresourceRange.aspectMask, image->m_vkformat);
+    barrier.subresourceRange.aspectMask =
+        VulkanUtil::getAspectMask(subresourceRange.aspectMask, image->m_vkformat);
     barrier.subresourceRange.baseArrayLayer = subresourceRange.baseArrayLayer;
     barrier.subresourceRange.baseMipLevel = subresourceRange.mipLevel;
     barrier.subresourceRange.layerCount = subresourceRange.layerCount;
@@ -948,13 +993,15 @@ void RenderCommandEncoder::endEncoding()
 }
 
 Result RenderCommandEncoder::bindPipeline(
-    IPipelineState* pipelineState, IShaderObject** outRootObject)
+    IPipelineState* pipelineState,
+    IShaderObject** outRootObject)
 {
     return setPipelineStateImpl(pipelineState, outRootObject);
 }
 
 Result RenderCommandEncoder::bindPipelineWithRootObject(
-    IPipelineState* pipelineState, IShaderObject* rootObject)
+    IPipelineState* pipelineState,
+    IShaderObject* rootObject)
 {
     return setPipelineStateWithRootObjectImpl(pipelineState, rootObject);
 }
@@ -1009,14 +1056,14 @@ void RenderCommandEncoder::setPrimitiveTopology(PrimitiveTopology topology)
     if (api.vkCmdSetPrimitiveTopologyEXT)
     {
         api.vkCmdSetPrimitiveTopologyEXT(
-            m_vkCommandBuffer, VulkanUtil::getVkPrimitiveTopology(topology));
+            m_vkCommandBuffer,
+            VulkanUtil::getVkPrimitiveTopology(topology));
     }
     else
     {
         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.
@@ -1043,31 +1090,35 @@ void RenderCommandEncoder::setVertexBuffers(
             VkDeviceSize offset = VkDeviceSize(offsets[i]);
 
             m_api->vkCmdBindVertexBuffers(
-                m_vkCommandBuffer, (uint32_t)slotIndex, 1, vertexBuffers, &offset);
+                m_vkCommandBuffer,
+                (uint32_t)slotIndex,
+                1,
+                vertexBuffers,
+                &offset);
         }
     }
 }
 
 void RenderCommandEncoder::setIndexBuffer(
-    IBufferResource* buffer, Format indexFormat, Offset offset)
+    IBufferResource* buffer,
+    Format indexFormat,
+    Offset offset)
 {
     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);
 
     m_api->vkCmdBindIndexBuffer(
-        m_vkCommandBuffer, bufferImpl->m_buffer.m_buffer, (VkDeviceSize)offset, indexType);
+        m_vkCommandBuffer,
+        bufferImpl->m_buffer.m_buffer,
+        (VkDeviceSize)offset,
+        indexType);
 }
 
 Result RenderCommandEncoder::prepareDraw()
@@ -1090,7 +1141,9 @@ Result RenderCommandEncoder::draw(GfxCount vertexCount, GfxIndex startVertex)
 }
 
 Result RenderCommandEncoder::drawIndexed(
-    GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex)
+    GfxCount indexCount,
+    GfxIndex startIndex,
+    GfxIndex baseVertex)
 {
     SLANG_RETURN_ON_FAIL(prepareDraw());
     auto& api = *m_api;
@@ -1152,7 +1205,9 @@ Result RenderCommandEncoder::drawIndexedIndirect(
 }
 
 Result RenderCommandEncoder::setSamplePositions(
-    GfxCount samplesPerPixel, GfxCount pixelCount, const SamplePosition* samplePositions)
+    GfxCount samplesPerPixel,
+    GfxCount pixelCount,
+    const SamplePosition* samplePositions)
 {
     if (m_api->vkCmdSetSampleLocationsEXT)
     {
@@ -1175,7 +1230,11 @@ Result RenderCommandEncoder::drawInstanced(
     SLANG_RETURN_ON_FAIL(prepareDraw());
     auto& api = *m_api;
     api.vkCmdDraw(
-        m_vkCommandBuffer, vertexCount, instanceCount, startVertex, startInstanceLocation);
+        m_vkCommandBuffer,
+        vertexCount,
+        instanceCount,
+        startVertex,
+        startInstanceLocation);
     return SLANG_OK;
 }
 
@@ -1206,16 +1265,21 @@ Result RenderCommandEncoder::drawMeshTasks(int x, int y, int z)
     return SLANG_OK;
 }
 
-void ComputeCommandEncoder::endEncoding() { endEncodingImpl(); }
+void ComputeCommandEncoder::endEncoding()
+{
+    endEncodingImpl();
+}
 
 Result ComputeCommandEncoder::bindPipeline(
-    IPipelineState* pipelineState, IShaderObject** outRootObject)
+    IPipelineState* pipelineState,
+    IShaderObject** outRootObject)
 {
     return setPipelineStateImpl(pipelineState, outRootObject);
 }
 
 Result ComputeCommandEncoder::bindPipelineWithRootObject(
-    IPipelineState* pipelineState, IShaderObject* rootObject)
+    IPipelineState* pipelineState,
+    IShaderObject* rootObject)
 {
     return setPipelineStateWithRootObjectImpl(pipelineState, rootObject);
 }
@@ -1303,8 +1367,7 @@ 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,
@@ -1362,7 +1425,10 @@ void RayTracingCommandEncoder::buildAccelerationStructure(
 
     auto rangeInfoPtr = rangeInfos.getBuffer();
     m_commandBuffer->m_renderer->m_api.vkCmdBuildAccelerationStructuresKHR(
-        m_commandBuffer->m_commandBuffer, 1, &geomInfoBuilder.buildInfo, &rangeInfoPtr);
+        m_commandBuffer->m_commandBuffer,
+        1,
+        &geomInfoBuilder.buildInfo,
+        &rangeInfoPtr);
 
     if (propertyQueryCount)
     {
@@ -1372,7 +1438,9 @@ void RayTracingCommandEncoder::buildAccelerationStructure(
 }
 
 void RayTracingCommandEncoder::copyAccelerationStructure(
-    IAccelerationStructure* dest, IAccelerationStructure* src, AccelerationStructureCopyMode mode)
+    IAccelerationStructure* dest,
+    IAccelerationStructure* src,
+    AccelerationStructureCopyMode mode)
 {
     VkCopyAccelerationStructureInfoKHR copyInfo = {
         VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR};
@@ -1394,7 +1462,8 @@ void RayTracingCommandEncoder::copyAccelerationStructure(
         return;
     }
     m_commandBuffer->m_renderer->m_api.vkCmdCopyAccelerationStructureKHR(
-        m_commandBuffer->m_commandBuffer, &copyInfo);
+        m_commandBuffer->m_commandBuffer,
+        &copyInfo);
 }
 
 void RayTracingCommandEncoder::queryAccelerationStructureProperties(
@@ -1404,11 +1473,15 @@ void RayTracingCommandEncoder::queryAccelerationStructureProperties(
     AccelerationStructureQueryDesc* queryDescs)
 {
     _queryAccelerationStructureProperties(
-        accelerationStructureCount, accelerationStructures, queryCount, queryDescs);
+        accelerationStructureCount,
+        accelerationStructures,
+        queryCount,
+        queryDescs);
 }
 
 void RayTracingCommandEncoder::serializeAccelerationStructure(
-    DeviceAddress dest, IAccelerationStructure* source)
+    DeviceAddress dest,
+    IAccelerationStructure* source)
 {
     VkCopyAccelerationStructureToMemoryInfoKHR copyInfo = {
         VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR};
@@ -1416,11 +1489,13 @@ void RayTracingCommandEncoder::serializeAccelerationStructure(
     copyInfo.dst.deviceAddress = dest;
     copyInfo.mode = VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR;
     m_commandBuffer->m_renderer->m_api.vkCmdCopyAccelerationStructureToMemoryKHR(
-        m_commandBuffer->m_commandBuffer, &copyInfo);
+        m_commandBuffer->m_commandBuffer,
+        &copyInfo);
 }
 
 void RayTracingCommandEncoder::deserializeAccelerationStructure(
-    IAccelerationStructure* dest, DeviceAddress source)
+    IAccelerationStructure* dest,
+    DeviceAddress source)
 {
     VkCopyMemoryToAccelerationStructureInfoKHR copyInfo = {
         VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR};
@@ -1428,16 +1503,20 @@ void RayTracingCommandEncoder::deserializeAccelerationStructure(
     copyInfo.dst = static_cast<AccelerationStructureImpl*>(dest)->m_vkHandle;
     copyInfo.mode = VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR;
     m_commandBuffer->m_renderer->m_api.vkCmdCopyMemoryToAccelerationStructureKHR(
-        m_commandBuffer->m_commandBuffer, &copyInfo);
+        m_commandBuffer->m_commandBuffer,
+        &copyInfo);
 }
 
-Result RayTracingCommandEncoder::bindPipeline(IPipelineState* pipeline, IShaderObject** outRootObject)
+Result RayTracingCommandEncoder::bindPipeline(
+    IPipelineState* pipeline,
+    IShaderObject** outRootObject)
 {
     return setPipelineStateImpl(pipeline, outRootObject);
 }
 
 Result RayTracingCommandEncoder::bindPipelineWithRootObject(
-    IPipelineState* pipelineState, IShaderObject* rootObject)
+    IPipelineState* pipelineState,
+    IShaderObject* rootObject)
 {
     return setPipelineStateWithRootObjectImpl(pipelineState, rootObject);
 }
@@ -1498,7 +1577,10 @@ Result RayTracingCommandEncoder::dispatchRays(
     return SLANG_OK;
 }
 
-void RayTracingCommandEncoder::endEncoding() { endEncodingImpl(); }
+void RayTracingCommandEncoder::endEncoding()
+{
+    endEncodingImpl();
+}
 
 } // namespace vk
 } // namespace gfx
diff --git a/tools/gfx/vulkan/vk-command-encoder.h b/tools/gfx/vulkan/vk-command-encoder.h
index 05c47920e..ec9854b30 100644
--- a/tools/gfx/vulkan/vk-command-encoder.h
+++ b/tools/gfx/vulkan/vk-command-encoder.h
@@ -40,7 +40,9 @@ public:
 
     void uploadBufferDataImpl(IBufferResource* buffer, Offset offset, Size size, void* data);
 
-    Result bindRootShaderObjectImpl(RootShaderObjectImpl* rootShaderObject, VkPipelineBindPoint bindPoint);
+    Result bindRootShaderObjectImpl(
+        RootShaderObjectImpl* rootShaderObject,
+        VkPipelineBindPoint bindPoint);
 
     Result setPipelineStateImpl(IPipelineState* state, IShaderObject** outRootObject);
 
@@ -49,9 +51,7 @@ public:
     Result bindRenderState(VkPipelineBindPoint pipelineBindPoint);
 };
 
-class ResourceCommandEncoder
-    : public IResourceCommandEncoder
-    , public PipelineCommandEncoder
+class ResourceCommandEncoder : public IResourceCommandEncoder, public PipelineCommandEncoder
 {
 public:
     virtual void* getInterface(SlangUUID const& guid)
@@ -61,7 +61,7 @@ public:
         return nullptr;
     }
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL
-        queryInterface(SlangUUID const& uuid, void** outObject) override
+    queryInterface(SlangUUID const& uuid, void** outObject) override
     {
         if (auto ptr = getInterface(uuid))
         {
@@ -80,7 +80,7 @@ public:
         Offset srcOffset,
         Size size) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        uploadBufferData(IBufferResource* buffer, Offset offset, Size size, void* data) override;
+    uploadBufferData(IBufferResource* buffer, Offset offset, Size size, void* data) override;
     virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
         GfxCount count,
         ITextureResource* const* textures,
@@ -94,7 +94,7 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        writeTimestamp(IQueryPool* queryPool, GfxIndex index) override;
+    writeTimestamp(IQueryPool* queryPool, GfxIndex index) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
         ITextureResource* dst,
@@ -123,10 +123,15 @@ public:
         ClearResourceViewFlags::Enum flags);
 
     void _clearBuffer(
-        VkBuffer buffer, uint64_t bufferSize, const IResourceView::Desc& desc, uint32_t clearValue);
+        VkBuffer buffer,
+        uint64_t bufferSize,
+        const IResourceView::Desc& desc,
+        uint32_t clearValue);
 
     virtual SLANG_NO_THROW void SLANG_MCALL clearResourceView(
-        IResourceView* view, ClearValue* clearValue, ClearResourceViewFlags::Enum flags) override;
+        IResourceView* view,
+        ClearValue* clearValue,
+        ClearResourceViewFlags::Enum flags) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
         ITextureResource* source,
@@ -161,18 +166,17 @@ public:
         ResourceState dst) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        beginDebugEvent(const char* name, float rgbColor[3]) override;
+    beginDebugEvent(const char* name, float rgbColor[3]) override;
     virtual SLANG_NO_THROW void SLANG_MCALL endDebugEvent() override;
 };
 
-class RenderCommandEncoder
-    : public IRenderCommandEncoder
-    , public ResourceCommandEncoder
+class RenderCommandEncoder : public IRenderCommandEncoder, public ResourceCommandEncoder
 {
     SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoder)
     virtual void* getInterface(SlangUUID const& uuid) override
     {
-        if (uuid == GfxGUID::IID_IResourceCommandEncoder || uuid == GfxGUID::IID_IRenderCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
+        if (uuid == GfxGUID::IID_IResourceCommandEncoder ||
+            uuid == GfxGUID::IID_IRenderCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
         {
             return this;
         }
@@ -189,19 +193,19 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        bindPipeline(IPipelineState* pipelineState, IShaderObject** outRootObject) override;
+    bindPipeline(IPipelineState* pipelineState, IShaderObject** outRootObject) override;
 
-    virtual SLANG_NO_THROW Result SLANG_MCALL bindPipelineWithRootObject(
-        IPipelineState* pipelineState, IShaderObject* rootObject) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+    bindPipelineWithRootObject(IPipelineState* pipelineState, IShaderObject* rootObject) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setViewports(GfxCount count, const Viewport* viewports) override;
+    setViewports(GfxCount count, const Viewport* viewports) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setScissorRects(GfxCount count, const ScissorRect* rects) override;
+    setScissorRects(GfxCount count, const ScissorRect* rects) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setPrimitiveTopology(PrimitiveTopology topology) override;
+    setPrimitiveTopology(PrimitiveTopology topology) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
         GfxIndex startSlot,
@@ -210,14 +214,14 @@ public:
         const Offset* offsets) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) override;
+    setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) override;
 
     Result prepareDraw();
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        draw(GfxCount vertexCount, GfxIndex startVertex = 0) override;
+    draw(GfxCount vertexCount, GfxIndex startVertex = 0) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) override;
+    drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) override;
 
@@ -253,19 +257,17 @@ public:
         GfxIndex baseVertexLocation,
         GfxIndex startInstanceLocation) override;
 
-    virtual SLANG_NO_THROW Result SLANG_MCALL
-        drawMeshTasks(int x, int y, int z) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL drawMeshTasks(int x, int y, int z) override;
 };
 
-class ComputeCommandEncoder
-    : public IComputeCommandEncoder
-    , public ResourceCommandEncoder
+class ComputeCommandEncoder : public IComputeCommandEncoder, public ResourceCommandEncoder
 {
 public:
     SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoder)
     virtual void* getInterface(SlangUUID const& uuid) override
     {
-        if (uuid == GfxGUID::IID_IResourceCommandEncoder || uuid == GfxGUID::IID_IComputeCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
+        if (uuid == GfxGUID::IID_IResourceCommandEncoder ||
+            uuid == GfxGUID::IID_IComputeCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
         {
             return this;
         }
@@ -275,33 +277,32 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        bindPipeline(IPipelineState* pipelineState, IShaderObject** outRootObject) override;
+    bindPipeline(IPipelineState* pipelineState, IShaderObject** outRootObject) override;
 
-    virtual SLANG_NO_THROW Result SLANG_MCALL bindPipelineWithRootObject(
-        IPipelineState* pipelineState, IShaderObject* rootObject) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+    bindPipelineWithRootObject(IPipelineState* pipelineState, IShaderObject* rootObject) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL dispatchCompute(int x, int y, int z) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset) override;
+    dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset) override;
 };
 
-class RayTracingCommandEncoder
-    : public IRayTracingCommandEncoder
-    , public ResourceCommandEncoder
+class RayTracingCommandEncoder : public IRayTracingCommandEncoder, public ResourceCommandEncoder
 {
 public:
     SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoder)
     virtual void* getInterface(SlangUUID const& uuid) override
     {
-        if (uuid == GfxGUID::IID_IResourceCommandEncoder || uuid == GfxGUID::IID_IRayTracingCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
+        if (uuid == GfxGUID::IID_IResourceCommandEncoder ||
+            uuid == GfxGUID::IID_IRayTracingCommandEncoder || uuid == ISlangUnknown::getTypeGuid())
         {
             return this;
         }
         return nullptr;
     }
-public:
 
+public:
     void _memoryBarrier(
         int count,
         IAccelerationStructure* const* structures,
@@ -331,16 +332,16 @@ public:
         AccelerationStructureQueryDesc* queryDescs) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure* source) override;
+    serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure* source) override;
 
-    virtual SLANG_NO_THROW void SLANG_MCALL deserializeAccelerationStructure(
-        IAccelerationStructure* dest, DeviceAddress source) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+    deserializeAccelerationStructure(IAccelerationStructure* dest, DeviceAddress source) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        bindPipeline(IPipelineState* pipeline, IShaderObject** outRootObject) override;
+    bindPipeline(IPipelineState* pipeline, IShaderObject** outRootObject) override;
 
-    virtual SLANG_NO_THROW Result SLANG_MCALL bindPipelineWithRootObject(
-        IPipelineState* pipelineState, IShaderObject* rootObject) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+    bindPipelineWithRootObject(IPipelineState* pipelineState, IShaderObject* rootObject) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL dispatchRays(
         GfxIndex raygenShaderIndex,
diff --git a/tools/gfx/vulkan/vk-command-queue.cpp b/tools/gfx/vulkan/vk-command-queue.cpp
index 58d4fa972..232e7f0b1 100644
--- a/tools/gfx/vulkan/vk-command-queue.cpp
+++ b/tools/gfx/vulkan/vk-command-queue.cpp
@@ -36,8 +36,8 @@ void CommandQueueImpl::init(DeviceImpl* renderer, VkQueue queue, uint32_t queueF
     VkSemaphoreCreateInfo semaphoreCreateInfo = {};
     semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
     semaphoreCreateInfo.flags = 0;
-    m_renderer->m_api.vkCreateSemaphore(
-        m_renderer->m_api.m_device, &semaphoreCreateInfo, nullptr, &m_semaphore);
+    m_renderer->m_api
+        .vkCreateSemaphore(m_renderer->m_api.m_device, &semaphoreCreateInfo, nullptr, &m_semaphore);
 }
 
 void CommandQueueImpl::waitOnHost()
@@ -53,10 +53,15 @@ Result CommandQueueImpl::getNativeHandle(InteropHandle* outHandle)
     return SLANG_OK;
 }
 
-const CommandQueueImpl::Desc& CommandQueueImpl::getDesc() { return m_desc; }
+const CommandQueueImpl::Desc& CommandQueueImpl::getDesc()
+{
+    return m_desc;
+}
 
 Result CommandQueueImpl::waitForFenceValuesOnDevice(
-    GfxCount fenceCount, IFence** fences, uint64_t* waitValues)
+    GfxCount fenceCount,
+    IFence** fences,
+    uint64_t* waitValues)
 {
     for (GfxIndex i = 0; i < fenceCount; ++i)
     {
@@ -69,7 +74,10 @@ Result CommandQueueImpl::waitForFenceValuesOnDevice(
 }
 
 void CommandQueueImpl::queueSubmitImpl(
-    uint32_t count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal)
+    uint32_t count,
+    ICommandBuffer* const* commandBuffers,
+    IFence* fence,
+    uint64_t valueToSignal)
 {
     auto& vkAPI = m_renderer->m_api;
     m_submitCommandBuffers.clear();
@@ -89,7 +97,8 @@ void CommandQueueImpl::queueSubmitImpl(
     VkSubmitInfo submitInfo = {};
     submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     VkPipelineStageFlags stageFlag[] = {
-        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT};
+        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT};
     submitInfo.pWaitDstStageMask = stageFlag;
     submitInfo.commandBufferCount = (uint32_t)m_submitCommandBuffers.getCount();
     submitInfo.pCommandBuffers = m_submitCommandBuffers.getBuffer();
@@ -144,7 +153,10 @@ void CommandQueueImpl::queueSubmitImpl(
 }
 
 void CommandQueueImpl::executeCommandBuffers(
-    GfxCount count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal)
+    GfxCount count,
+    ICommandBuffer* const* commandBuffers,
+    IFence* fence,
+    uint64_t valueToSignal)
 {
     if (count == 0 && fence == nullptr)
         return;
diff --git a/tools/gfx/vulkan/vk-command-queue.h b/tools/gfx/vulkan/vk-command-queue.h
index c7d4e3eb4..07b3e14e6 100644
--- a/tools/gfx/vulkan/vk-command-queue.h
+++ b/tools/gfx/vulkan/vk-command-queue.h
@@ -12,9 +12,7 @@ using namespace Slang;
 namespace vk
 {
 
-class CommandQueueImpl
-    : public ICommandQueue
-    , public ComObject
+class CommandQueueImpl : public ICommandQueue, public ComObject
 {
 public:
     SLANG_COM_OBJECT_IUNKNOWN_ALL
@@ -44,8 +42,8 @@ public:
 
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override;
 
-    virtual SLANG_NO_THROW Result SLANG_MCALL waitForFenceValuesOnDevice(
-        GfxCount fenceCount, IFence** fences, uint64_t* waitValues) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+    waitForFenceValuesOnDevice(GfxCount fenceCount, IFence** fences, uint64_t* waitValues) override;
 
     void queueSubmitImpl(
         uint32_t count,
diff --git a/tools/gfx/vulkan/vk-descriptor-allocator.cpp b/tools/gfx/vulkan/vk-descriptor-allocator.cpp
index 49199091d..afaa836ca 100644
--- a/tools/gfx/vulkan/vk-descriptor-allocator.cpp
+++ b/tools/gfx/vulkan/vk-descriptor-allocator.cpp
@@ -1,4 +1,5 @@
 #include "vk-descriptor-allocator.h"
+
 #include "vk-util.h"
 
 namespace gfx
@@ -31,13 +32,17 @@ VkDescriptorPool DescriptorSetAllocator::newPool()
     descriptorPoolInfo.pPoolSizes = poolSizes.getBuffer();
     descriptorPoolInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
 
-    VkDescriptorPoolInlineUniformBlockCreateInfo inlineUniformBlockInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO };
+    VkDescriptorPoolInlineUniformBlockCreateInfo inlineUniformBlockInfo = {
+        VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO};
     inlineUniformBlockInfo.maxInlineUniformBlockBindings = 16;
     descriptorPoolInfo.pNext = &inlineUniformBlockInfo;
 
     VkDescriptorPool descriptorPool = VK_NULL_HANDLE;
     SLANG_VK_CHECK(m_api->vkCreateDescriptorPool(
-        m_api->m_device, &descriptorPoolInfo, nullptr, &descriptorPool));
+        m_api->m_device,
+        &descriptorPoolInfo,
+        nullptr,
+        &descriptorPool));
     pools.add(descriptorPool);
     return descriptorPool;
 }
@@ -77,4 +82,4 @@ VulkanDescriptorSet DescriptorSetAllocator::allocate(VkDescriptorSetLayout layou
     assert(!"descriptor set allocation failed.");
     return rs;
 }
-}
+} // namespace gfx
diff --git a/tools/gfx/vulkan/vk-descriptor-allocator.h b/tools/gfx/vulkan/vk-descriptor-allocator.h
index 3d5c441ad..5be1cfae2 100644
--- a/tools/gfx/vulkan/vk-descriptor-allocator.h
+++ b/tools/gfx/vulkan/vk-descriptor-allocator.h
@@ -2,8 +2,8 @@
 
 #pragma once
 
-#include "vk-api.h"
 #include "core/slang-list.h"
+#include "vk-api.h"
 
 namespace gfx
 {
diff --git a/tools/gfx/vulkan/vk-device-queue.cpp b/tools/gfx/vulkan/vk-device-queue.cpp
index 1bcfe28c8..8a98d68ec 100644
--- a/tools/gfx/vulkan/vk-device-queue.cpp
+++ b/tools/gfx/vulkan/vk-device-queue.cpp
@@ -1,11 +1,12 @@
 // vk-device-queue.cpp
 #include "vk-device-queue.h"
 
-#include <stdlib.h>
-#include <stdio.h>
 #include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
 
-namespace gfx {
+namespace gfx
+{
 using namespace Slang;
 
 VulkanDeviceQueue::~VulkanDeviceQueue()
@@ -24,7 +25,8 @@ void VulkanDeviceQueue::destroy()
 
         for (int i = 0; i < m_numCommandBuffers; i++)
         {
-            m_api->vkFreeCommandBuffers(m_api->m_device, m_commandPools[i], 1, &m_commandBuffers[i]);
+            m_api
+                ->vkFreeCommandBuffers(m_api->m_device, m_commandPools[i], 1, &m_commandBuffers[i]);
             m_api->vkDestroyFence(m_api->m_device, m_fences[i].fence, nullptr);
             m_api->vkDestroyCommandPool(m_api->m_device, m_commandPools[i], nullptr);
         }
@@ -35,7 +37,7 @@ void VulkanDeviceQueue::destroy()
 SlangResult VulkanDeviceQueue::init(const VulkanApi& api, VkQueue queue, int queueIndex)
 {
     assert(m_api == nullptr);
-    
+
     for (int i = 0; i < int(EventType::CountOf); ++i)
     {
         m_semaphores[i] = VK_NULL_HANDLE;
@@ -135,7 +137,7 @@ void VulkanDeviceQueue::flushStepA()
     makeCompleted(EventType::EndFrame);
 }
 
-void VulkanDeviceQueue::_updateFenceAtIndex( int fenceIndex, bool blocking)
+void VulkanDeviceQueue::_updateFenceAtIndex(int fenceIndex, bool blocking)
 {
     Fence& fence = m_fences[fenceIndex];
 
@@ -143,7 +145,8 @@ void VulkanDeviceQueue::_updateFenceAtIndex( int fenceIndex, bool blocking)
     {
         uint64_t timeout = blocking ? ~uint64_t(0) : 0;
 
-        if (VK_SUCCESS == m_api->vkWaitForFences(m_api->m_device, 1, &fence.fence, VK_TRUE, timeout))
+        if (VK_SUCCESS ==
+            m_api->vkWaitForFences(m_api->m_device, 1, &fence.fence, VK_TRUE, timeout))
         {
             m_api->vkResetFences(m_api->m_device, 1, &fence.fence);
 
@@ -211,4 +214,4 @@ void VulkanDeviceQueue::makeCompleted(EventType eventType)
     m_currentSemaphores[int(eventType)] = VK_NULL_HANDLE;
 }
 
-} // renderer_test
+} // namespace gfx
diff --git a/tools/gfx/vulkan/vk-device-queue.h b/tools/gfx/vulkan/vk-device-queue.h
index 38d8f2bd6..174e20850 100644
--- a/tools/gfx/vulkan/vk-device-queue.h
+++ b/tools/gfx/vulkan/vk-device-queue.h
@@ -4,7 +4,8 @@
 #include "vk-api.h"
 #include "vk-descriptor-allocator.h"
 
-namespace gfx {
+namespace gfx
+{
 
 struct VulkanDeviceQueue
 {
@@ -20,53 +21,56 @@ struct VulkanDeviceQueue
         CountOf,
     };
 
-        /// Initialize - must be called before anything else can be done
+    /// Initialize - must be called before anything else can be done
     SlangResult init(const VulkanApi& api, VkQueue queue, int queueIndex);
 
-        /// Flushes the current command list, and steps to next (internally this is equivalent to a stepA followed by stepB)
+    /// Flushes the current command list, and steps to next (internally this is equivalent to a
+    /// stepA followed by stepB)
     void flush();
-        /// Performs a full flush, and then waits for idle.
+    /// Performs a full flush, and then waits for idle.
     void flushAndWait();
 
-        /// Blocks until all work submitted to GPU has completed
+    /// Blocks until all work submitted to GPU has completed
     void waitForIdle() { m_api->vkQueueWaitIdle(m_queue); }
 
-        /// Get the graphics queue index (as set on init)
+    /// Get the graphics queue index (as set on init)
     int getQueueIndex() const { return m_queueIndex; }
 
-        /// Make the specified event 'current' - meaning it's semaphore must be waited on
+    /// Make the specified event 'current' - meaning it's semaphore must be waited on
     VkSemaphore makeCurrent(EventType eventType);
     VkSemaphore getSemaphore(EventType eventType);
-        /// Makes the event no longer required to be waited on
+    /// Makes the event no longer required to be waited on
     void makeCompleted(EventType eventType);
-        /// Returns true if the event is already current
-    SLANG_FORCE_INLINE bool isCurrent(EventType eventType) const { return m_currentSemaphores[int(eventType)] != VK_NULL_HANDLE; }
+    /// Returns true if the event is already current
+    SLANG_FORCE_INLINE bool isCurrent(EventType eventType) const
+    {
+        return m_currentSemaphores[int(eventType)] != VK_NULL_HANDLE;
+    }
 
-        /// Get the command buffer
+    /// Get the command buffer
     VkCommandBuffer getCommandBuffer() const { return m_commandBuffer; }
 
-        /// Get the queue
+    /// Get the queue
     VkQueue getQueue() const { return m_queue; }
 
-        /// Get the API
+    /// Get the API
     const VulkanApi* getApi() const { return m_api; }
 
-        /// Flushes the current command list
+    /// Flushes the current command list
     void flushStepA();
-        /// Steps to next command buffer and opens. May block if command buffer is still in use
+    /// Steps to next command buffer and opens. May block if command buffer is still in use
     void flushStepB();
 
-        /// Destroy the device queue
+    /// Destroy the device queue
     void destroy();
 
-        /// True if the queue appears to be valid and has been initialized
+    /// True if the queue appears to be valid and has been initialized
     bool isValid() const { return m_api != nullptr; }
 
-        /// Dtor
+    /// Dtor
     ~VulkanDeviceQueue();
 
-    protected:
-
+protected:
     struct Fence
     {
         VkFence fence;
@@ -82,9 +86,9 @@ struct VulkanDeviceQueue
     int m_commandBufferIndex = 0;
     // There are the same amount of command buffers as fences
     VkCommandPool m_commandPools[kMaxCommandBuffers] = {VK_NULL_HANDLE};
-    VkCommandBuffer m_commandBuffers[kMaxCommandBuffers] = { VK_NULL_HANDLE };
+    VkCommandBuffer m_commandBuffers[kMaxCommandBuffers] = {VK_NULL_HANDLE};
 
-    Fence m_fences[kMaxCommandBuffers] = { {VK_NULL_HANDLE, 0, 0u} };
+    Fence m_fences[kMaxCommandBuffers] = {{VK_NULL_HANDLE, 0, 0u}};
 
     VkCommandBuffer m_commandBuffer = VK_NULL_HANDLE;
     VkCommandPool m_commandPool = VK_NULL_HANDLE;
@@ -99,4 +103,4 @@ struct VulkanDeviceQueue
     const VulkanApi* m_api = nullptr;
 };
 
-} // renderer_test
+} // namespace gfx
diff --git a/tools/gfx/vulkan/vk-device.cpp b/tools/gfx/vulkan/vk-device.cpp
index bc1641aff..68b8ba1db 100644
--- a/tools/gfx/vulkan/vk-device.cpp
+++ b/tools/gfx/vulkan/vk-device.cpp
@@ -1,30 +1,28 @@
 // vk-device.cpp
 #include "vk-device.h"
 
+#include "source/core/slang-platform.h"
 #include "vk-buffer.h"
 #include "vk-command-queue.h"
 #include "vk-fence.h"
+#include "vk-helper-functions.h"
+#include "vk-pipeline-dump-layer.h"
 #include "vk-query.h"
 #include "vk-render-pass.h"
 #include "vk-resource-views.h"
 #include "vk-sampler.h"
-#include "vk-shader-object.h"
 #include "vk-shader-object-layout.h"
+#include "vk-shader-object.h"
 #include "vk-shader-program.h"
 #include "vk-shader-table.h"
 #include "vk-swap-chain.h"
 #include "vk-transient-heap.h"
 #include "vk-vertex-layout.h"
-#include "vk-pipeline-dump-layer.h"
-
-#include "vk-helper-functions.h"
-
-#include "source/core/slang-platform.h"
 
 #ifdef GFX_NV_AFTERMATH
-#   include "GFSDK_Aftermath.h"
-#   include "GFSDK_Aftermath_Defines.h"
-#   include "GFSDK_Aftermath_GpuCrashDump.h"
+#include "GFSDK_Aftermath.h"
+#include "GFSDK_Aftermath_Defines.h"
+#include "GFSDK_Aftermath_GpuCrashDump.h"
 #endif
 
 namespace gfx
@@ -150,12 +148,14 @@ static bool _hasAnySetBits(const T& val, size_t offset)
 {
     const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&val);
     for (size_t i = offset; i < sizeof(val); i++)
-        if (ptr[i]) return true;
+        if (ptr[i])
+            return true;
     return false;
 }
 
 Result DeviceImpl::initVulkanInstanceAndDevice(
-    const InteropHandle* handles, bool useValidationLayer)
+    const InteropHandle* handles,
+    bool useValidationLayer)
 {
     m_features.clear();
 
@@ -171,7 +171,9 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
         switch (stype)
         {
         case StructType::RayTracingValidationDesc:
-            enableRayTracingValidation = static_cast<RayTracingValidationDesc*>(m_desc.extendedDescs[i])->enableRaytracingValidation;
+            enableRayTracingValidation =
+                static_cast<RayTracingValidationDesc*>(m_desc.extendedDescs[i])
+                    ->enableRaytracingValidation;
             break;
         }
     }
@@ -180,7 +182,7 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
     VkInstance instance = VK_NULL_HANDLE;
     if (handles[0].handleValue == 0)
     {
-        VkApplicationInfo applicationInfo = { VK_STRUCTURE_TYPE_APPLICATION_INFO };
+        VkApplicationInfo applicationInfo = {VK_STRUCTURE_TYPE_APPLICATION_INFO};
         applicationInfo.pApplicationName = "slang-gfx";
         applicationInfo.pEngineName = "slang-gfx";
         applicationInfo.apiVersion = VK_API_VERSION_1_1;
@@ -215,7 +217,7 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
         if (ENABLE_VALIDATION_LAYER || isGfxDebugLayerEnabled())
             instanceExtensions.add(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
 
-        VkInstanceCreateInfo instanceCreateInfo = { VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
+        VkInstanceCreateInfo instanceCreateInfo = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};
 #if SLANG_APPLE_FAMILY
         instanceCreateInfo.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
 #endif
@@ -223,10 +225,11 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
         instanceCreateInfo.enabledExtensionCount = (uint32_t)instanceExtensions.getCount();
         instanceCreateInfo.ppEnabledExtensionNames = &instanceExtensions[0];
 
-        const char* layerNames[] = { nullptr };
+        const char* layerNames[] = {nullptr};
 
         VkValidationFeaturesEXT validationFeatures = {};
-        VkValidationFeatureEnableEXT enabledValidationFeatures[1] = { VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT };
+        VkValidationFeatureEnableEXT enabledValidationFeatures[1] = {
+            VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT};
         if (useValidationLayer)
         {
             // Depending on driver version, validation layer may or may not exist.
@@ -245,9 +248,9 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
             for (auto& layer : availableLayers)
             {
                 if (strncmp(
-                    layer.layerName,
-                    "VK_LAYER_KHRONOS_validation",
-                    sizeof("VK_LAYER_KHRONOS_validation")) == 0)
+                        layer.layerName,
+                        "VK_LAYER_KHRONOS_validation",
+                        sizeof("VK_LAYER_KHRONOS_validation")) == 0)
                 {
                     layerNames[0] = "VK_LAYER_KHRONOS_validation";
                     break;
@@ -260,9 +263,9 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
                 for (auto& layer : availableLayers)
                 {
                     if (strncmp(
-                        layer.layerName,
-                        "VK_LAYER_LUNARG_standard_validation",
-                        sizeof("VK_LAYER_LUNARG_standard_validation")) == 0)
+                            layer.layerName,
+                            "VK_LAYER_LUNARG_standard_validation",
+                            sizeof("VK_LAYER_LUNARG_standard_validation")) == 0)
                     {
                         layerNames[0] = "VK_LAYER_LUNARG_standard_validation";
                         break;
@@ -281,7 +284,7 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
                 instanceCreateInfo.pNext = &validationFeatures;
             }
         }
-        uint32_t apiVersionsToTry[] = { VK_API_VERSION_1_2, VK_API_VERSION_1_1, VK_API_VERSION_1_0 };
+        uint32_t apiVersionsToTry[] = {VK_API_VERSION_1_2, VK_API_VERSION_1_1, VK_API_VERSION_1_0};
         for (auto apiVersion : apiVersionsToTry)
         {
             applicationInfo.apiVersion = apiVersion;
@@ -290,7 +293,7 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
             // the layer is known earlier). It might, for example, be absent
             // from the system library search path, and not referenced with an
             // absolute path in VkLayer_khronos_validation.json.
-            const auto r = m_api.vkCreateInstance(&instanceCreateInfo, nullptr, &instance) ;
+            const auto r = m_api.vkCreateInstance(&instanceCreateInfo, nullptr, &instance);
             if (r == VK_SUCCESS)
             {
                 break;
@@ -311,13 +314,16 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
             VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
 
         VkDebugReportCallbackCreateInfoEXT debugCreateInfo = {
-            VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT };
+            VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT};
         debugCreateInfo.pfnCallback = &debugMessageCallback;
         debugCreateInfo.pUserData = this;
         debugCreateInfo.flags = debugFlags;
 
         SLANG_VK_RETURN_ON_FAIL(m_api.vkCreateDebugReportCallbackEXT(
-            instance, &debugCreateInfo, nullptr, &m_debugReportCallback));
+            instance,
+            &debugCreateInfo,
+            nullptr,
+            &m_debugReportCallback));
     }
 
     VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
@@ -330,7 +336,9 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
         List<VkPhysicalDevice> physicalDevices;
         physicalDevices.setCount(numPhysicalDevices);
         SLANG_VK_RETURN_ON_FAIL(m_api.vkEnumeratePhysicalDevices(
-            instance, &numPhysicalDevices, physicalDevices.getBuffer()));
+            instance,
+            &numPhysicalDevices,
+            physicalDevices.getBuffer()));
 
         // Use first physical device by default.
         Index selectedDeviceIndex = 0;
@@ -373,12 +381,14 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
 
     // Query the available extensions
     uint32_t extensionCount = 0;
-    m_api.vkEnumerateDeviceExtensionProperties(
-        m_api.m_physicalDevice, NULL, &extensionCount, NULL);
+    m_api.vkEnumerateDeviceExtensionProperties(m_api.m_physicalDevice, NULL, &extensionCount, NULL);
     Slang::List<VkExtensionProperties> extensions;
     extensions.setCount(extensionCount);
     m_api.vkEnumerateDeviceExtensionProperties(
-        m_api.m_physicalDevice, NULL, &extensionCount, extensions.getBuffer());
+        m_api.m_physicalDevice,
+        NULL,
+        &extensionCount,
+        extensions.getBuffer());
     HashSet<String> extensionNames;
     for (const auto& e : extensions)
         extensionNames.add(e.extensionName);
@@ -390,7 +400,7 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
     deviceExtensions.add("VK_KHR_portability_subset");
 #endif
 
-    VkDeviceCreateInfo deviceCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
+    VkDeviceCreateInfo deviceCreateInfo = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO};
     deviceCreateInfo.queueCreateInfoCount = 1;
     deviceCreateInfo.pEnabledFeatures = &m_api.m_deviceFeatures;
 
@@ -480,7 +490,7 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
         // Variable pointer features.
         extendedFeatures.variablePointersFeatures.pNext = deviceFeatures2.pNext;
         deviceFeatures2.pNext = &extendedFeatures.variablePointersFeatures;
-        
+
         // Compute shader derivative features.
         extendedFeatures.computeShaderDerivativeFeatures.pNext = deviceFeatures2.pNext;
         deviceFeatures2.pNext = &extendedFeatures.computeShaderDerivativeFeatures;
@@ -501,7 +511,7 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
         extendedFeatures.clockFeatures.pNext = deviceFeatures2.pNext;
         deviceFeatures2.pNext = &extendedFeatures.clockFeatures;
 
-        // Atomic Float 
+        // Atomic Float
         // To detect atomic float we need
         // https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html
 
@@ -564,12 +574,14 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
             m_features.add("half");
         }
 
-        const auto addFeatureExtension = [&](const bool feature, auto& featureStruct, const char* extension = nullptr){
-            if(!feature)
+        const auto addFeatureExtension =
+            [&](const bool feature, auto& featureStruct, const char* extension = nullptr)
+        {
+            if (!feature)
                 return false;
-            if(extension)
+            if (extension)
             {
-                if(!extensionNames.contains(extension))
+                if (!extensionNames.contains(extension))
                     return false;
                 deviceExtensions.add(extension);
             }
@@ -585,51 +597,47 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
         // linked into the deviceCreateInfo chain and the features added to the
         // supported features list.
 #define SIMPLE_EXTENSION_FEATURE(s, m, e, ...) \
-        do{ \
-            const static auto fs = {__VA_ARGS__}; \
-            if(addFeatureExtension(s.m, s, e)) \
-                for(const auto& p : fs) \
-                    m_features.add(p); \
-        } while(0)
+    do                                         \
+    {                                          \
+        const static auto fs = {__VA_ARGS__};  \
+        if (addFeatureExtension(s.m, s, e))    \
+            for (const auto& p : fs)           \
+                m_features.add(p);             \
+    } while (0)
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.storage16BitFeatures,
             storageBuffer16BitAccess,
             VK_KHR_16BIT_STORAGE_EXTENSION_NAME,
-            "16-bit-storage"
-        );
+            "16-bit-storage");
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.atomicFloatFeatures,
             shaderBufferFloat32Atomics,
             VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME,
-            "atomic-float"
-        );
+            "atomic-float");
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.atomicFloat2Features,
             shaderBufferFloat16Atomics,
             VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME,
-            "atomic-float-2"
-        );
+            "atomic-float-2");
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.imageInt64AtomicFeatures,
             shaderImageInt64Atomics,
             VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME,
-            "image-atomic-int64"
-        );
+            "image-atomic-int64");
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.extendedDynamicStateFeatures,
             extendedDynamicState,
             VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME,
-            "extended-dynamic-states"
-        );
+            "extended-dynamic-states");
 
-        if (extendedFeatures.accelerationStructureFeatures.accelerationStructure
-            && extensionNames.contains(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME)
-            && extensionNames.contains(VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME))
+        if (extendedFeatures.accelerationStructureFeatures.accelerationStructure &&
+            extensionNames.contains(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME) &&
+            extensionNames.contains(VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME))
         {
             extendedFeatures.accelerationStructureFeatures.pNext = (void*)deviceCreateInfo.pNext;
             deviceCreateInfo.pNext = &extendedFeatures.accelerationStructureFeatures;
@@ -644,89 +652,78 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
                 rayQuery,
                 VK_KHR_RAY_QUERY_EXTENSION_NAME,
                 "ray-query",
-                "ray-tracing"
-            );
+                "ray-tracing");
 
             SIMPLE_EXTENSION_FEATURE(
                 extendedFeatures.rayTracingPipelineFeatures,
                 rayTracingPipeline,
                 VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME,
-                "ray-tracing-pipeline"
-            );
+                "ray-tracing-pipeline");
         }
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.inlineUniformBlockFeatures,
             inlineUniformBlock,
             VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME,
-            "inline-uniform-block",
-        );
+            "inline-uniform-block", );
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.robustness2Features,
             nullDescriptor,
             VK_EXT_ROBUSTNESS_2_EXTENSION_NAME,
-            "robustness2",
-        );
+            "robustness2", );
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.clockFeatures,
             shaderDeviceClock,
             VK_KHR_SHADER_CLOCK_EXTENSION_NAME,
-            "realtime-clock"
-        );
+            "realtime-clock");
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.meshShaderFeatures,
             meshShader,
             VK_EXT_MESH_SHADER_EXTENSION_NAME,
-            "mesh-shader"
-        );
+            "mesh-shader");
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.multiviewFeatures,
             multiview,
             VK_KHR_MULTIVIEW_EXTENSION_NAME,
-            "multiview"
-        );
+            "multiview");
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.fragmentShadingRateFeatures,
             primitiveFragmentShadingRate,
             VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME,
-            "fragment-shading-rate"
-        );
+            "fragment-shading-rate");
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.rayTracingInvocationReorderFeatures,
             rayTracingInvocationReorder,
             VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME,
-            "shader-execution-reorder"
-        );
+            "shader-execution-reorder");
 
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.variablePointersFeatures,
             variablePointers,
             VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME,
-            "variable-pointer"
-        );
-        
+            "variable-pointer");
+
         SIMPLE_EXTENSION_FEATURE(
             extendedFeatures.computeShaderDerivativeFeatures,
             computeDerivativeGroupLinear,
             VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME,
-            "computeDerivativeGroupLinear"
-        );
+            "computeDerivativeGroupLinear");
 
         // Only enable raytracing validation if both requested and supported
-        if(enableRayTracingValidation && extendedFeatures.rayTracingValidationFeatures.rayTracingValidation)
+        if (enableRayTracingValidation &&
+            extendedFeatures.rayTracingValidationFeatures.rayTracingValidation)
         {
             SIMPLE_EXTENSION_FEATURE(
                 extendedFeatures.rayTracingValidationFeatures,
                 rayTracingValidation,
                 VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME,
-                "ray-tracing-validation"
-            );
+                "ray-tracing-validation");
         }
 
 #undef SIMPLE_EXTENSION_FEATURE
@@ -752,11 +749,11 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
         }
 
         VkPhysicalDeviceProperties2 extendedProps = {
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 };
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2};
         VkPhysicalDeviceRayTracingPipelinePropertiesKHR rtProps = {
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR };
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR};
         VkPhysicalDeviceSubgroupProperties subgroupProps = {
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES };
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES};
 
         rtProps.pNext = extendedProps.pNext;
         extendedProps.pNext = &rtProps;
@@ -767,16 +764,12 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
         m_api.m_rtProperties = rtProps;
 
         // Approximate DX12's WaveOps boolean
-        if(subgroupProps.supportedOperations &
-           ( VK_SUBGROUP_FEATURE_BASIC_BIT
-           | VK_SUBGROUP_FEATURE_VOTE_BIT
-           | VK_SUBGROUP_FEATURE_ARITHMETIC_BIT
-           | VK_SUBGROUP_FEATURE_BALLOT_BIT
-           | VK_SUBGROUP_FEATURE_SHUFFLE_BIT
-           | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT
-           | VK_SUBGROUP_FEATURE_CLUSTERED_BIT
-           | VK_SUBGROUP_FEATURE_QUAD_BIT
-           | VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV))
+        if (subgroupProps.supportedOperations &
+            (VK_SUBGROUP_FEATURE_BASIC_BIT | VK_SUBGROUP_FEATURE_VOTE_BIT |
+             VK_SUBGROUP_FEATURE_ARITHMETIC_BIT | VK_SUBGROUP_FEATURE_BALLOT_BIT |
+             VK_SUBGROUP_FEATURE_SHUFFLE_BIT | VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT |
+             VK_SUBGROUP_FEATURE_CLUSTERED_BIT | VK_SUBGROUP_FEATURE_QUAD_BIT |
+             VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV))
         {
             m_features.add("wave-ops");
         }
@@ -860,13 +853,32 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
 
         // Derive approximate DX12 shader model.
         const char* featureTable[] = {
-            "sm_6_0", "wave-ops", "atomic-int64", nullptr,
-            "sm_6_1", "barycentrics", "multiview", nullptr,
-            "sm_6_2", "half", nullptr,
-            "sm_6_3", "ray-tracing-pipeline", nullptr,
-            "sm_6_4", "fragment-shading-rate", nullptr,
-            "sm_6_5", "ray-query", "mesh-shader", nullptr,
-            "sm_6_6", "wave-ops", "atomic-float", "atomic-int64", nullptr,
+            "sm_6_0",
+            "wave-ops",
+            "atomic-int64",
+            nullptr,
+            "sm_6_1",
+            "barycentrics",
+            "multiview",
+            nullptr,
+            "sm_6_2",
+            "half",
+            nullptr,
+            "sm_6_3",
+            "ray-tracing-pipeline",
+            nullptr,
+            "sm_6_4",
+            "fragment-shading-rate",
+            nullptr,
+            "sm_6_5",
+            "ray-query",
+            "mesh-shader",
+            nullptr,
+            "sm_6_6",
+            "wave-ops",
+            "atomic-float",
+            "atomic-int64",
+            nullptr,
             nullptr,
         };
 
@@ -924,11 +936,17 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
 
         // Set up device creation info for Aftermath feature flag configuration.
         VkDeviceDiagnosticsConfigFlagsNV aftermathFlags =
-            VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV |  // Enable automatic call stack checkpoints.
-            VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV |      // Enable tracking of resources.
-            VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV;       // Generate debug information for shaders.
-            // Not available on the version of Vulkan currently building with.
-            //VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV;  // Enable additional runtime shader error reporting.
+            VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV | // Enable automatic
+                                                                               // call stack
+                                                                               // checkpoints.
+            VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV |     // Enable tracking of
+                                                                               // resources.
+            VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV;      // Generate debug
+                                                                               // information for
+                                                                               // shaders.
+        // Not available on the version of Vulkan currently building with.
+        // VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV;  // Enable additional
+        // runtime shader error reporting.
 
         aftermathInfo.sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
         aftermathInfo.flags = aftermathFlags;
@@ -941,7 +959,7 @@ Result DeviceImpl::initVulkanInstanceAndDevice(
     if (handles[2].handleValue == 0)
     {
         float queuePriority = 0.0f;
-        VkDeviceQueueCreateInfo queueCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO };
+        VkDeviceQueueCreateInfo queueCreateInfo = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO};
         queueCreateInfo.queueFamilyIndex = m_queueFamilyIndex;
         queueCreateInfo.queueCount = 1;
         queueCreateInfo.pQueuePriorities = &queuePriority;
@@ -978,7 +996,7 @@ SlangResult DeviceImpl::initialize(const Desc& desc)
         m_info.bindingStyle = BindingStyle::Vulkan;
         m_info.projectionStyle = ProjectionStyle::Vulkan;
         m_info.deviceType = DeviceType::Vulkan;
-        static const float kIdentity[] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
+        static const float kIdentity[] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
         ::memcpy(m_info.identityProjectionMatrix, kIdentity, sizeof(kIdentity));
     }
 
@@ -997,7 +1015,8 @@ SlangResult DeviceImpl::initialize(const Desc& desc)
             continue;
         descriptorSetAllocator.m_api = &m_api;
         initDeviceResult = initVulkanInstanceAndDevice(
-            desc.existingDeviceHandles.handles, ENABLE_VALIDATION_LAYER != 0 || isGfxDebugLayerEnabled());
+            desc.existingDeviceHandles.handles,
+            ENABLE_VALIDATION_LAYER != 0 || isGfxDebugLayerEnabled());
         if (initDeviceResult == SLANG_OK)
             break;
     }
@@ -1015,11 +1034,11 @@ SlangResult DeviceImpl::initialize(const Desc& desc)
         desc.extendedDescs,
         SLANG_SPIRV,
         "sm_5_1",
-        makeArray(slang::PreprocessorMacroDesc{ "__VK__", "1" }).getView()));
+        makeArray(slang::PreprocessorMacroDesc{"__VK__", "1"}).getView()));
 
     // Create default sampler.
     {
-        VkSamplerCreateInfo samplerInfo = { VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
+        VkSamplerCreateInfo samplerInfo = {VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
         samplerInfo.magFilter = VK_FILTER_NEAREST;
         samplerInfo.minFilter = VK_FILTER_NEAREST;
         samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
@@ -1056,12 +1075,19 @@ SlangResult DeviceImpl::initialize(const Desc& desc)
     return SLANG_OK;
 }
 
-void DeviceImpl::waitForGpu() { m_deviceQueue.flushAndWait(); }
+void DeviceImpl::waitForGpu()
+{
+    m_deviceQueue.flushAndWait();
+}
 
-SLANG_NO_THROW const DeviceInfo& SLANG_MCALL DeviceImpl::getDeviceInfo() const { return m_info; }
+SLANG_NO_THROW const DeviceInfo& SLANG_MCALL DeviceImpl::getDeviceInfo() const
+{
+    return m_info;
+}
 
 Result DeviceImpl::createTransientResourceHeap(
-    const ITransientResourceHeap::Desc& desc, ITransientResourceHeap** outHeap)
+    const ITransientResourceHeap::Desc& desc,
+    ITransientResourceHeap** outHeap)
 {
     RefPtr<TransientResourceHeapImpl> result = new TransientResourceHeapImpl();
     SLANG_RETURN_ON_FAIL(result->init(desc, this));
@@ -1085,7 +1111,9 @@ Result DeviceImpl::createCommandQueue(const ICommandQueue::Desc& desc, ICommandQ
 }
 
 Result DeviceImpl::createSwapchain(
-    const ISwapchain::Desc& desc, WindowHandle window, ISwapchain** outSwapchain)
+    const ISwapchain::Desc& desc,
+    WindowHandle window,
+    ISwapchain** outSwapchain)
 {
 #if !defined(SLANG_ENABLE_XLIB)
     if (window.type == WindowHandle::Type::XLibHandle)
@@ -1101,7 +1129,8 @@ Result DeviceImpl::createSwapchain(
 }
 
 Result DeviceImpl::createFramebufferLayout(
-    const IFramebufferLayout::Desc& desc, IFramebufferLayout** outLayout)
+    const IFramebufferLayout::Desc& desc,
+    IFramebufferLayout** outLayout)
 {
     RefPtr<FramebufferLayoutImpl> layout = new FramebufferLayoutImpl();
     SLANG_RETURN_ON_FAIL(layout->init(this, desc));
@@ -1110,7 +1139,8 @@ Result DeviceImpl::createFramebufferLayout(
 }
 
 Result DeviceImpl::createRenderPassLayout(
-    const IRenderPassLayout::Desc& desc, IRenderPassLayout** outRenderPassLayout)
+    const IRenderPassLayout::Desc& desc,
+    IRenderPassLayout** outRenderPassLayout)
 {
     RefPtr<RenderPassLayoutImpl> result = new RenderPassLayoutImpl();
     SLANG_RETURN_ON_FAIL(result->init(this, desc));
@@ -1196,16 +1226,24 @@ SlangResult DeviceImpl::readTextureResource(
             region.bufferRowLength = 0;
             region.bufferImageHeight = 0;
 
-            region.imageSubresource.aspectMask = getAspectMaskFromFormat(VulkanUtil::getVkFormat(desc->format));
+            region.imageSubresource.aspectMask =
+                getAspectMaskFromFormat(VulkanUtil::getVkFormat(desc->format));
             region.imageSubresource.mipLevel = uint32_t(j);
             region.imageSubresource.baseArrayLayer = i;
             region.imageSubresource.layerCount = 1;
-            region.imageOffset = { 0, 0, 0 };
+            region.imageOffset = {0, 0, 0};
             region.imageExtent = {
-                uint32_t(mipSize.width), uint32_t(mipSize.height), uint32_t(mipSize.depth) };
+                uint32_t(mipSize.width),
+                uint32_t(mipSize.height),
+                uint32_t(mipSize.depth)};
 
             m_api.vkCmdCopyImageToBuffer(
-                commandBuffer, srcImage, srcImageLayout, staging.m_buffer, 1, &region);
+                commandBuffer,
+                srcImage,
+                srcImageLayout,
+                staging.m_buffer,
+                1,
+                &region);
 
             dstOffset += rowSizeInBytes * numRows * mipSize.depth;
         }
@@ -1231,7 +1269,10 @@ SlangResult DeviceImpl::readTextureResource(
 }
 
 SlangResult DeviceImpl::readBufferResource(
-    IBufferResource* inBuffer, Offset offset, Size size, ISlangBlob** outBlob)
+    IBufferResource* inBuffer,
+    Offset offset,
+    Size size,
+    ISlangBlob** outBlob)
 {
     BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(inBuffer);
 
@@ -1280,7 +1321,7 @@ Result DeviceImpl::getAccelerationStructurePrebuildInfo(
         return SLANG_E_NOT_AVAILABLE;
     }
     VkAccelerationStructureBuildSizesInfoKHR sizeInfo = {
-        VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR };
+        VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR};
     AccelerationStructureBuildGeometryInfoBuilder geomInfoBuilder;
     SLANG_RETURN_ON_FAIL(geomInfoBuilder.build(buildInputs, getDebugCallback()));
     m_api.vkGetAccelerationStructureBuildSizesKHR(
@@ -1296,7 +1337,8 @@ Result DeviceImpl::getAccelerationStructurePrebuildInfo(
 }
 
 Result DeviceImpl::createAccelerationStructure(
-    const IAccelerationStructure::CreateDesc& desc, IAccelerationStructure** outAS)
+    const IAccelerationStructure::CreateDesc& desc,
+    IAccelerationStructure** outAS)
 {
     if (!m_api.vkCreateAccelerationStructureKHR)
     {
@@ -1309,7 +1351,7 @@ Result DeviceImpl::createAccelerationStructure(
     resultAS->m_device = this;
     resultAS->m_desc.type = IResourceView::Type::AccelerationStructure;
     VkAccelerationStructureCreateInfoKHR createInfo = {
-        VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR };
+        VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR};
     createInfo.buffer = resultAS->m_buffer->m_buffer.m_buffer;
     createInfo.offset = desc.offset;
     createInfo.size = desc.size;
@@ -1330,7 +1372,10 @@ Result DeviceImpl::createAccelerationStructure(
     }
 
     SLANG_VK_RETURN_ON_FAIL(m_api.vkCreateAccelerationStructureKHR(
-        m_api.m_device, &createInfo, nullptr, &resultAS->m_vkHandle));
+        m_api.m_device,
+        &createInfo,
+        nullptr,
+        &resultAS->m_vkHandle));
     returnComPtr(outAS, resultAS);
     return SLANG_OK;
 }
@@ -1367,7 +1412,16 @@ void DeviceImpl::_transitionImageLayout(
     VkPipelineStageFlags destinationStage = calcPipelineStageFlagsFromImageLayout(newLayout);
 
     m_api.vkCmdPipelineBarrier(
-        commandBuffer, sourceStage, destinationStage, 0, 0, nullptr, 0, nullptr, 1, &barrier);
+        commandBuffer,
+        sourceStage,
+        destinationStage,
+        0,
+        0,
+        nullptr,
+        0,
+        nullptr,
+        1,
+        &barrier);
 }
 
 uint32_t DeviceImpl::getQueueFamilyIndex(ICommandQueue::QueueType queueType)
@@ -1375,8 +1429,7 @@ uint32_t DeviceImpl::getQueueFamilyIndex(ICommandQueue::QueueType queueType)
     switch (queueType)
     {
     case ICommandQueue::QueueType::Graphics:
-    default:
-        return m_queueFamilyIndex;
+    default:                                 return m_queueFamilyIndex;
     }
 }
 
@@ -1392,7 +1445,9 @@ void DeviceImpl::_transitionImageLayout(
 }
 
 Result DeviceImpl::getTextureAllocationInfo(
-    const ITextureResource::Desc& descIn, Size* outSize, Size* outAlignment)
+    const ITextureResource::Desc& descIn,
+    Size* outSize,
+    Size* outAlignment)
 {
     TextureResource::Desc desc = fixupTextureDesc(descIn);
 
@@ -1404,47 +1459,47 @@ Result DeviceImpl::getTextureAllocationInfo(
     }
     const int arraySize = calcEffectiveArraySize(desc);
 
-    VkImageCreateInfo imageInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+    VkImageCreateInfo imageInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
     switch (desc.type)
     {
     case IResource::Type::Texture1D:
-    {
-        imageInfo.imageType = VK_IMAGE_TYPE_1D;
-        imageInfo.extent = VkExtent3D{ uint32_t(descIn.size.width), 1, 1 };
-        break;
-    }
+        {
+            imageInfo.imageType = VK_IMAGE_TYPE_1D;
+            imageInfo.extent = VkExtent3D{uint32_t(descIn.size.width), 1, 1};
+            break;
+        }
     case IResource::Type::Texture2D:
-    {
-        imageInfo.imageType = VK_IMAGE_TYPE_2D;
-        imageInfo.extent =
-            VkExtent3D{ uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1 };
-        break;
-    }
+        {
+            imageInfo.imageType = VK_IMAGE_TYPE_2D;
+            imageInfo.extent =
+                VkExtent3D{uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1};
+            break;
+        }
     case IResource::Type::TextureCube:
-    {
-        imageInfo.imageType = VK_IMAGE_TYPE_2D;
-        imageInfo.extent =
-            VkExtent3D{ uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1 };
-        imageInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
-        break;
-    }
+        {
+            imageInfo.imageType = VK_IMAGE_TYPE_2D;
+            imageInfo.extent =
+                VkExtent3D{uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1};
+            imageInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
+            break;
+        }
     case IResource::Type::Texture3D:
-    {
-        // Can't have an array and 3d texture
-        assert(desc.arraySize <= 1);
-
-        imageInfo.imageType = VK_IMAGE_TYPE_3D;
-        imageInfo.extent = VkExtent3D{
-            uint32_t(descIn.size.width),
-            uint32_t(descIn.size.height),
-            uint32_t(descIn.size.depth) };
-        break;
-    }
+        {
+            // Can't have an array and 3d texture
+            assert(desc.arraySize <= 1);
+
+            imageInfo.imageType = VK_IMAGE_TYPE_3D;
+            imageInfo.extent = VkExtent3D{
+                uint32_t(descIn.size.width),
+                uint32_t(descIn.size.height),
+                uint32_t(descIn.size.depth)};
+            break;
+        }
     default:
-    {
-        assert(!"Unhandled type");
-        return SLANG_FAIL;
-    }
+        {
+            assert(!"Unhandled type");
+            return SLANG_FAIL;
+        }
     }
 
     imageInfo.mipLevels = desc.numMipLevels;
@@ -1497,47 +1552,47 @@ Result DeviceImpl::createTextureResource(
     texture->m_vkformat = format;
     // Create the image
 
-    VkImageCreateInfo imageInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
+    VkImageCreateInfo imageInfo = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
     switch (desc.type)
     {
     case IResource::Type::Texture1D:
-    {
-        imageInfo.imageType = VK_IMAGE_TYPE_1D;
-        imageInfo.extent = VkExtent3D{ uint32_t(descIn.size.width), 1, 1 };
-        break;
-    }
+        {
+            imageInfo.imageType = VK_IMAGE_TYPE_1D;
+            imageInfo.extent = VkExtent3D{uint32_t(descIn.size.width), 1, 1};
+            break;
+        }
     case IResource::Type::Texture2D:
-    {
-        imageInfo.imageType = VK_IMAGE_TYPE_2D;
-        imageInfo.extent =
-            VkExtent3D{ uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1 };
-        break;
-    }
+        {
+            imageInfo.imageType = VK_IMAGE_TYPE_2D;
+            imageInfo.extent =
+                VkExtent3D{uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1};
+            break;
+        }
     case IResource::Type::TextureCube:
-    {
-        imageInfo.imageType = VK_IMAGE_TYPE_2D;
-        imageInfo.extent =
-            VkExtent3D{ uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1 };
-        imageInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
-        break;
-    }
+        {
+            imageInfo.imageType = VK_IMAGE_TYPE_2D;
+            imageInfo.extent =
+                VkExtent3D{uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1};
+            imageInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
+            break;
+        }
     case IResource::Type::Texture3D:
-    {
-        // Can't have an array and 3d texture
-        assert(desc.arraySize <= 1);
-
-        imageInfo.imageType = VK_IMAGE_TYPE_3D;
-        imageInfo.extent = VkExtent3D{
-            uint32_t(descIn.size.width),
-            uint32_t(descIn.size.height),
-            uint32_t(descIn.size.depth) };
-        break;
-    }
+        {
+            // Can't have an array and 3d texture
+            assert(desc.arraySize <= 1);
+
+            imageInfo.imageType = VK_IMAGE_TYPE_3D;
+            imageInfo.extent = VkExtent3D{
+                uint32_t(descIn.size.width),
+                uint32_t(descIn.size.height),
+                uint32_t(descIn.size.depth)};
+            break;
+        }
     default:
-    {
-        assert(!"Unhandled type");
-        return SLANG_FAIL;
-    }
+        {
+            assert(!"Unhandled type");
+            return SLANG_FAIL;
+        }
     }
 
     imageInfo.mipLevels = desc.numMipLevels;
@@ -1552,7 +1607,7 @@ Result DeviceImpl::createTextureResource(
     imageInfo.samples = (VkSampleCountFlagBits)desc.sampleDesc.numSamples;
 
     VkExternalMemoryImageCreateInfo externalMemoryImageCreateInfo = {
-        VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO };
+        VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO};
     VkExternalMemoryHandleTypeFlags extMemoryHandleType =
 #if SLANG_WINDOWS_FAMILY
         VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
@@ -1578,15 +1633,15 @@ Result DeviceImpl::createTextureResource(
 
     VkMemoryPropertyFlags actualMemoryProperites =
         m_api.m_deviceMemoryProperties.memoryTypes[memoryTypeIndex].propertyFlags;
-    VkMemoryAllocateInfo allocInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
+    VkMemoryAllocateInfo allocInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
     allocInfo.allocationSize = memRequirements.size;
     allocInfo.memoryTypeIndex = memoryTypeIndex;
 #if SLANG_WINDOWS_FAMILY
     VkExportMemoryWin32HandleInfoKHR exportMemoryWin32HandleInfo = {
-        VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR };
+        VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR};
 #endif
     VkExportMemoryAllocateInfoKHR exportMemoryAllocateInfo = {
-        VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR };
+        VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR};
     if (descIn.isShared)
     {
 #if SLANG_WINDOWS_FAMILY
@@ -1598,8 +1653,8 @@ Result DeviceImpl::createTextureResource(
 
         exportMemoryAllocateInfo.pNext =
             extMemoryHandleType & VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
-            ? &exportMemoryWin32HandleInfo
-            : nullptr;
+                ? &exportMemoryWin32HandleInfo
+                : nullptr;
 #endif
         exportMemoryAllocateInfo.handleTypes = extMemoryHandleType;
         allocInfo.pNext = &exportMemoryAllocateInfo;
@@ -1705,7 +1760,7 @@ Result DeviceImpl::createTextureResource(
             VK_IMAGE_LAYOUT_UNDEFINED,
             VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
 
-        if(desc.sampleDesc.numSamples != 1)
+        if (desc.sampleDesc.numSamples != 1)
         {
             // Handle senario where texture is sampled. We cannot use
             // a simple buffer copy for sampled textures. ClearColorImage
@@ -1714,70 +1769,81 @@ Result DeviceImpl::createTextureResource(
             gfxGetFormatInfo(desc.format, &formatInfo);
             uint32_t data = 0;
             VkClearColorValue clearColor;
-            switch(formatInfo.channelType)
+            switch (formatInfo.channelType)
             {
             case SLANG_SCALAR_TYPE_INT32:
-                for(int i = 0; i < 4; i++)
-                    clearColor.int32[i] = *reinterpret_cast<int32_t*>(const_cast<void*>(initData->data));
+                for (int i = 0; i < 4; i++)
+                    clearColor.int32[i] =
+                        *reinterpret_cast<int32_t*>(const_cast<void*>(initData->data));
                 break;
             case SLANG_SCALAR_TYPE_UINT32:
-                for(int i = 0; i < 4; i++)
-                    clearColor.uint32[i] = *reinterpret_cast<uint32_t*>(const_cast<void*>(initData->data));
+                for (int i = 0; i < 4; i++)
+                    clearColor.uint32[i] =
+                        *reinterpret_cast<uint32_t*>(const_cast<void*>(initData->data));
                 break;
             case SLANG_SCALAR_TYPE_INT64:
-            {
-                for(int i = 0; i < 4; i++)
-                    clearColor.int32[i] = int32_t(*reinterpret_cast<int64_t*>(const_cast<void*>(initData->data)));
-                break;
-            }
+                {
+                    for (int i = 0; i < 4; i++)
+                        clearColor.int32[i] =
+                            int32_t(*reinterpret_cast<int64_t*>(const_cast<void*>(initData->data)));
+                    break;
+                }
             case SLANG_SCALAR_TYPE_UINT64:
-            {
-                for(int i = 0; i < 4; i++)
-                    clearColor.uint32[i] = uint32_t(*reinterpret_cast<uint64_t*>(const_cast<void*>(initData->data)));
-                break;
-            }
+                {
+                    for (int i = 0; i < 4; i++)
+                        clearColor.uint32[i] = uint32_t(
+                            *reinterpret_cast<uint64_t*>(const_cast<void*>(initData->data)));
+                    break;
+                }
             case SLANG_SCALAR_TYPE_FLOAT16:
-            {
-                for(int i = 0; i < 4; i++)
-                    clearColor.float32[i] = HalfToFloat(*reinterpret_cast<uint16_t*>(const_cast<void*>(initData->data)));
-                break;
-            }
+                {
+                    for (int i = 0; i < 4; i++)
+                        clearColor.float32[i] = HalfToFloat(
+                            *reinterpret_cast<uint16_t*>(const_cast<void*>(initData->data)));
+                    break;
+                }
             case SLANG_SCALAR_TYPE_FLOAT32:
-            {
-                for(int i = 0; i < 4; i++)
-                    clearColor.float32[i] = (*reinterpret_cast<float*>(const_cast<void*>(initData->data)));
-                break;
-            }
+                {
+                    for (int i = 0; i < 4; i++)
+                        clearColor.float32[i] =
+                            (*reinterpret_cast<float*>(const_cast<void*>(initData->data)));
+                    break;
+                }
             case SLANG_SCALAR_TYPE_FLOAT64:
-            {
-                for(int i = 0; i < 4; i++)
-                    clearColor.float32[i] = float(*reinterpret_cast<double*>(const_cast<void*>(initData->data)));
-                break;
-            }
+                {
+                    for (int i = 0; i < 4; i++)
+                        clearColor.float32[i] =
+                            float(*reinterpret_cast<double*>(const_cast<void*>(initData->data)));
+                    break;
+                }
             case SLANG_SCALAR_TYPE_INT8:
-            {
-                for(int i = 0; i < 4; i++)
-                    clearColor.int32[i] = int32_t(*reinterpret_cast<int8_t*>(const_cast<void*>(initData->data)));
-                break;
-            }
+                {
+                    for (int i = 0; i < 4; i++)
+                        clearColor.int32[i] =
+                            int32_t(*reinterpret_cast<int8_t*>(const_cast<void*>(initData->data)));
+                    break;
+                }
             case SLANG_SCALAR_TYPE_UINT8:
-            {
-                for(int i = 0; i < 4; i++)
-                    clearColor.uint32[i] = uint32_t(*reinterpret_cast<uint8_t*>(const_cast<void*>(initData->data)));
-                break;
-            }
+                {
+                    for (int i = 0; i < 4; i++)
+                        clearColor.uint32[i] = uint32_t(
+                            *reinterpret_cast<uint8_t*>(const_cast<void*>(initData->data)));
+                    break;
+                }
             case SLANG_SCALAR_TYPE_INT16:
-            {
-                for(int i = 0; i < 4; i++)
-                    clearColor.int32[i] = int32_t(*reinterpret_cast<int16_t*>(const_cast<void*>(initData->data)));
-                break;
-            }
+                {
+                    for (int i = 0; i < 4; i++)
+                        clearColor.int32[i] =
+                            int32_t(*reinterpret_cast<int16_t*>(const_cast<void*>(initData->data)));
+                    break;
+                }
             case SLANG_SCALAR_TYPE_UINT16:
-            {
-                for(int i = 0; i < 4; i++)
-                    clearColor.uint32[i] = uint32_t(*reinterpret_cast<uint16_t*>(const_cast<void*>(initData->data)));
-                break;
-            }
+                {
+                    for (int i = 0; i < 4; i++)
+                        clearColor.uint32[i] = uint32_t(
+                            *reinterpret_cast<uint16_t*>(const_cast<void*>(initData->data)));
+                    break;
+                }
             };
 
             VkImageSubresourceRange range{};
@@ -1824,9 +1890,11 @@ Result DeviceImpl::createTextureResource(
                     region.imageSubresource.mipLevel = uint32_t(j);
                     region.imageSubresource.baseArrayLayer = i;
                     region.imageSubresource.layerCount = 1;
-                    region.imageOffset = { 0, 0, 0 };
+                    region.imageOffset = {0, 0, 0};
                     region.imageExtent = {
-                        uint32_t(mipSize.width), uint32_t(mipSize.height), uint32_t(mipSize.depth) };
+                        uint32_t(mipSize.width),
+                        uint32_t(mipSize.height),
+                        uint32_t(mipSize.depth)};
 
                     // Do the copy (do all depths in a single go)
                     m_api.vkCmdCopyBufferToImage(
@@ -1869,7 +1937,9 @@ Result DeviceImpl::createTextureResource(
 }
 
 Result DeviceImpl::createBufferResource(
-    const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource)
+    const IBufferResource::Desc& descIn,
+    const void* initData,
+    IBufferResource** outResource)
 {
     return createBufferResourceImpl(descIn, 0, initData, outResource);
 }
@@ -1947,7 +2017,12 @@ Result DeviceImpl::createBufferResourceImpl(
             // Copy into staging buffer
             void* mappedData = nullptr;
             SLANG_VK_CHECK(m_api.vkMapMemory(
-                m_device, buffer->m_uploadBuffer.m_memory, 0, bufferSize, 0, &mappedData));
+                m_device,
+                buffer->m_uploadBuffer.m_memory,
+                0,
+                bufferSize,
+                0,
+                &mappedData));
             ::memcpy(mappedData, initData, bufferSize);
             m_api.vkUnmapMemory(m_device, buffer->m_uploadBuffer.m_memory);
 
@@ -1969,7 +2044,12 @@ Result DeviceImpl::createBufferResourceImpl(
             // Copy into mapped buffer directly
             void* mappedData = nullptr;
             SLANG_VK_CHECK(m_api.vkMapMemory(
-                m_device, buffer->m_buffer.m_memory, 0, bufferSize, 0, &mappedData));
+                m_device,
+                buffer->m_buffer.m_memory,
+                0,
+                bufferSize,
+                0,
+                &mappedData));
             ::memcpy(mappedData, initData, bufferSize);
             m_api.vkUnmapMemory(m_device, buffer->m_buffer.m_memory);
         }
@@ -1980,7 +2060,9 @@ Result DeviceImpl::createBufferResourceImpl(
 }
 
 Result DeviceImpl::createBufferFromNativeHandle(
-    InteropHandle handle, const IBufferResource::Desc& srcDesc, IBufferResource** outResource)
+    InteropHandle handle,
+    const IBufferResource::Desc& srcDesc,
+    IBufferResource** outResource)
 {
     RefPtr<BufferResourceImpl> buffer(new BufferResourceImpl(srcDesc, this));
 
@@ -1999,7 +2081,7 @@ Result DeviceImpl::createBufferFromNativeHandle(
 
 Result DeviceImpl::createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler)
 {
-    VkSamplerCreateInfo samplerInfo = { VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
+    VkSamplerCreateInfo samplerInfo = {VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
 
     samplerInfo.magFilter = VulkanUtil::translateFilterMode(desc.minFilter);
     samplerInfo.minFilter = VulkanUtil::translateFilterMode(desc.magFilter);
@@ -2021,7 +2103,8 @@ Result DeviceImpl::createSamplerState(ISamplerState::Desc const& desc, ISamplerS
     samplerInfo.minLod = Math::Max(0.0f, desc.minLOD);
     samplerInfo.maxLod = Math::Clamp(desc.maxLOD, samplerInfo.minLod, VK_LOD_CLAMP_NONE);
 
-    VkSamplerReductionModeCreateInfo reductionInfo = { VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO };
+    VkSamplerReductionModeCreateInfo reductionInfo = {
+        VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO};
     reductionInfo.reductionMode = VulkanUtil::translateReductionOp(desc.reductionOp);
     samplerInfo.pNext = &reductionInfo;
 
@@ -2035,7 +2118,9 @@ Result DeviceImpl::createSamplerState(ISamplerState::Desc const& desc, ISamplerS
 }
 
 Result DeviceImpl::createTextureView(
-    ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView)
+    ITextureResource* texture,
+    IResourceView::Desc const& desc,
+    IResourceView** outView)
 {
     auto resourceImpl = static_cast<TextureResourceImpl*>(texture);
     RefPtr<TextureResourceViewImpl> view = new TextureResourceViewImpl(this);
@@ -2053,14 +2138,14 @@ Result DeviceImpl::createTextureView(
     createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
     createInfo.flags = 0;
     createInfo.format = gfxIsTypelessFormat(texture->getDesc()->format)
-        ? VulkanUtil::getVkFormat(desc.format)
-        : resourceImpl->m_vkformat;
+                            ? VulkanUtil::getVkFormat(desc.format)
+                            : resourceImpl->m_vkformat;
     createInfo.image = resourceImpl->m_image;
     createInfo.components = VkComponentMapping{
         VK_COMPONENT_SWIZZLE_R,
         VK_COMPONENT_SWIZZLE_G,
         VK_COMPONENT_SWIZZLE_B,
-        VK_COMPONENT_SWIZZLE_A };
+        VK_COMPONENT_SWIZZLE_A};
     switch (resourceImpl->getType())
     {
     case IResource::Type::Texture1D:
@@ -2069,15 +2154,11 @@ 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);
@@ -2094,8 +2175,8 @@ Result DeviceImpl::createTextureView(
         }
     }
     createInfo.subresourceRange.levelCount = desc.subresourceRange.mipLevelCount == 0
-        ? VK_REMAINING_MIP_LEVELS
-        : desc.subresourceRange.mipLevelCount;
+                                                 ? VK_REMAINING_MIP_LEVELS
+                                                 : desc.subresourceRange.mipLevelCount;
     switch (desc.type)
     {
     case IResourceView::Type::DepthStencil:
@@ -2109,12 +2190,8 @@ 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);
@@ -2129,7 +2206,9 @@ Result DeviceImpl::getFormatSupportedResourceStates(Format format, ResourceState
 
     VkFormatProperties supportedProperties = {};
     m_api.vkGetPhysicalDeviceFormatProperties(
-        m_api.m_physicalDevice, vkFormat, &supportedProperties);
+        m_api.m_physicalDevice,
+        vkFormat,
+        &supportedProperties);
 
     HashSet<VkFormat> presentableFormats;
     // TODO: enable this once we have VK_GOOGLE_surfaceless_query.
@@ -2147,8 +2226,8 @@ Result DeviceImpl::getFormatSupportedResourceStates(Format format, ResourceState
         presentableFormats.add(surfaceFormat.format);
     }
 #else
-// Until we have a solution to query presentable formats without needing a surface,
-// hard code presentable formats that is supported by most drivers.
+    // Until we have a solution to query presentable formats without needing a surface,
+    // hard code presentable formats that is supported by most drivers.
     presentableFormats.add(VK_FORMAT_R8G8B8A8_UNORM);
     presentableFormats.add(VK_FORMAT_B8G8R8A8_UNORM);
     presentableFormats.add(VK_FORMAT_R8G8B8A8_SRGB);
@@ -2167,11 +2246,8 @@ 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);
@@ -2186,7 +2262,7 @@ Result DeviceImpl::getFormatSupportedResourceStates(Format format, ResourceState
         (VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT))
         allowedStates.add(ResourceState::UnorderedAccess);
     if (bufferFeatures & (VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT |
-        VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT))
+                          VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT))
         allowedStates.add(ResourceState::UnorderedAccess);
     // RenderTarget
     if (imageFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)
@@ -2235,8 +2311,8 @@ Result DeviceImpl::createBufferView(
 
     VkDeviceSize offset = (VkDeviceSize)desc.bufferRange.offset;
     VkDeviceSize size = desc.bufferRange.size == 0
-        ? (buffer ? resourceImpl->getDesc()->sizeInBytes : 0)
-        : (VkDeviceSize)desc.bufferRange.size;
+                            ? (buffer ? resourceImpl->getDesc()->sizeInBytes : 0)
+                            : (VkDeviceSize)desc.bufferRange.size;
 
     // There are two different cases we need to think about for buffers.
     //
@@ -2259,9 +2335,7 @@ 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:
@@ -2286,7 +2360,7 @@ Result DeviceImpl::createBufferView(
         //
         // FALLTHROUGH
         {
-            VkBufferViewCreateInfo info = { VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO };
+            VkBufferViewCreateInfo info = {VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO};
 
             VkBufferView view = VK_NULL_HANDLE;
 
@@ -2352,8 +2426,8 @@ Result DeviceImpl::createInputLayout(IInputLayout::Desc const& desc, IInputLayou
         dstStream.stride = (uint32_t)srcStream.stride;
         dstStream.binding = (uint32_t)i;
         dstStream.inputRate = (srcStream.slotClass == InputSlotClass::PerInstance)
-            ? VK_VERTEX_INPUT_RATE_INSTANCE
-            : VK_VERTEX_INPUT_RATE_VERTEX;
+                                  ? VK_VERTEX_INPUT_RATE_INSTANCE
+                                  : VK_VERTEX_INPUT_RATE_VERTEX;
     }
 
     for (Int i = 0; i < numElements; ++i)
@@ -2380,7 +2454,9 @@ Result DeviceImpl::createInputLayout(IInputLayout::Desc const& desc, IInputLayou
 }
 
 Result DeviceImpl::createProgram(
-    const IShaderProgram::Desc& desc, IShaderProgram** outProgram, ISlangBlob** outDiagnosticBlob)
+    const IShaderProgram::Desc& desc,
+    IShaderProgram** outProgram,
+    ISlangBlob** outDiagnosticBlob)
 {
     RefPtr<ShaderProgramImpl> shaderProgram = new ShaderProgramImpl(this);
     shaderProgram->init(desc);
@@ -2418,13 +2494,16 @@ Result DeviceImpl::createShaderObject(ShaderObjectLayoutBase* layout, IShaderObj
 {
     RefPtr<ShaderObjectImpl> shaderObject;
     SLANG_RETURN_ON_FAIL(ShaderObjectImpl::create(
-        this, static_cast<ShaderObjectLayoutImpl*>(layout), shaderObject.writeRef()));
+        this,
+        static_cast<ShaderObjectLayoutImpl*>(layout),
+        shaderObject.writeRef()));
     returnComPtr(outObject, shaderObject);
     return SLANG_OK;
 }
 
 Result DeviceImpl::createMutableShaderObject(
-    ShaderObjectLayoutBase* layout, IShaderObject** outObject)
+    ShaderObjectLayoutBase* layout,
+    IShaderObject** outObject)
 {
     auto layoutImpl = static_cast<ShaderObjectLayoutImpl*>(layout);
 
@@ -2454,7 +2533,8 @@ Result DeviceImpl::createShaderTable(const IShaderTable::Desc& desc, IShaderTabl
 }
 
 Result DeviceImpl::createGraphicsPipelineState(
-    const GraphicsPipelineStateDesc& inDesc, IPipelineState** outState)
+    const GraphicsPipelineStateDesc& inDesc,
+    IPipelineState** outState)
 {
     GraphicsPipelineStateDesc desc = inDesc;
     RefPtr<PipelineStateImpl> pipelineStateImpl = new PipelineStateImpl(this);
@@ -2467,7 +2547,8 @@ Result DeviceImpl::createGraphicsPipelineState(
 }
 
 Result DeviceImpl::createComputePipelineState(
-    const ComputePipelineStateDesc& inDesc, IPipelineState** outState)
+    const ComputePipelineStateDesc& inDesc,
+    IPipelineState** outState)
 {
     ComputePipelineStateDesc desc = inDesc;
     RefPtr<PipelineStateImpl> pipelineStateImpl = new PipelineStateImpl(this);
@@ -2479,7 +2560,8 @@ Result DeviceImpl::createComputePipelineState(
 }
 
 Result DeviceImpl::createRayTracingPipelineState(
-    const RayTracingPipelineStateDesc& desc, IPipelineState** outState)
+    const RayTracingPipelineStateDesc& desc,
+    IPipelineState** outState)
 {
     RefPtr<RayTracingPipelineStateImpl> pipelineStateImpl = new RayTracingPipelineStateImpl(this);
     pipelineStateImpl->init(desc);
@@ -2506,7 +2588,11 @@ Result DeviceImpl::createFence(const IFence::Desc& desc, IFence** outFence)
 }
 
 Result DeviceImpl::waitForFences(
-    GfxCount fenceCount, IFence** fences, uint64_t* fenceValues, bool waitForAll, uint64_t timeout)
+    GfxCount fenceCount,
+    IFence** fences,
+    uint64_t* fenceValues,
+    bool waitForAll,
+    uint64_t timeout)
 {
     ShortList<VkSemaphore> semaphores;
     for (GfxIndex i = 0; i < fenceCount; ++i)
diff --git a/tools/gfx/vulkan/vk-device.h b/tools/gfx/vulkan/vk-device.h
index 89c7aa103..3b6c83103 100644
--- a/tools/gfx/vulkan/vk-device.h
+++ b/tools/gfx/vulkan/vk-device.h
@@ -19,19 +19,24 @@ public:
     Result initVulkanInstanceAndDevice(const InteropHandle* handles, bool useValidationLayer);
     virtual SLANG_NO_THROW Result SLANG_MCALL initialize(const Desc& desc) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getFormatSupportedResourceStates(Format format, ResourceStateSet* outStates) override;
+    getFormatSupportedResourceStates(Format format, ResourceStateSet* outStates) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createTransientResourceHeap(
-        const ITransientResourceHeap::Desc& desc, ITransientResourceHeap** outHeap) override;
+        const ITransientResourceHeap::Desc& desc,
+        ITransientResourceHeap** outHeap) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createCommandQueue(const ICommandQueue::Desc& desc, ICommandQueue** outQueue) override;
+    createCommandQueue(const ICommandQueue::Desc& desc, ICommandQueue** outQueue) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createSwapchain(
-        const ISwapchain::Desc& desc, WindowHandle window, ISwapchain** outSwapchain) override;
+        const ISwapchain::Desc& desc,
+        WindowHandle window,
+        ISwapchain** outSwapchain) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createFramebufferLayout(
-        const IFramebufferLayout::Desc& desc, IFramebufferLayout** outLayout) override;
+        const IFramebufferLayout::Desc& desc,
+        IFramebufferLayout** outLayout) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createFramebuffer(const IFramebuffer::Desc& desc, IFramebuffer** outFramebuffer) override;
+    createFramebuffer(const IFramebuffer::Desc& desc, IFramebuffer** outFramebuffer) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createRenderPassLayout(
-        const IRenderPassLayout::Desc& desc, IRenderPassLayout** outRenderPassLayout) override;
+        const IRenderPassLayout::Desc& desc,
+        IRenderPassLayout** outRenderPassLayout) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
         const ITextureResource::Desc& desc,
         const ITextureResource::SubresourceData* initData,
@@ -50,7 +55,7 @@ public:
         const IBufferResource::Desc& srcDesc,
         IBufferResource** outResource) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) override;
+    createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView(
         ITextureResource* texture,
@@ -63,33 +68,37 @@ public:
         IResourceView** outView) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createInputLayout(IInputLayout::Desc const& desc, IInputLayout** outLayout) override;
+    createInputLayout(IInputLayout::Desc const& desc, IInputLayout** outLayout) override;
 
     virtual Result createShaderObjectLayout(
         slang::ISession* session,
         slang::TypeLayoutReflection* typeLayout,
         ShaderObjectLayoutBase** outLayout) override;
-    virtual Result createShaderObject(
-        ShaderObjectLayoutBase* layout, IShaderObject** outObject) override;
+    virtual Result createShaderObject(ShaderObjectLayoutBase* layout, IShaderObject** outObject)
+        override;
     virtual Result createMutableShaderObject(
-        ShaderObjectLayoutBase* layout, IShaderObject** outObject) override;
+        ShaderObjectLayoutBase* layout,
+        IShaderObject** outObject) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createMutableRootShaderObject(IShaderProgram* program, IShaderObject** outObject) override;
+    createMutableRootShaderObject(IShaderProgram* program, IShaderObject** outObject) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createShaderTable(const IShaderTable::Desc& desc, IShaderTable** outShaderTable) override;
+    createShaderTable(const IShaderTable::Desc& desc, IShaderTable** outShaderTable) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createProgram(
         const IShaderProgram::Desc& desc,
         IShaderProgram** outProgram,
         ISlangBlob** outDiagnosticBlob) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
-        const GraphicsPipelineStateDesc& desc, IPipelineState** outState) override;
+        const GraphicsPipelineStateDesc& desc,
+        IPipelineState** outState) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
-        const ComputePipelineStateDesc& desc, IPipelineState** outState) override;
+        const ComputePipelineStateDesc& desc,
+        IPipelineState** outState) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createRayTracingPipelineState(
-        const RayTracingPipelineStateDesc& desc, IPipelineState** outState) override;
+        const RayTracingPipelineStateDesc& desc,
+        IPipelineState** outState) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createQueryPool(const IQueryPool::Desc& desc, IQueryPool** outPool) override;
+    createQueryPool(const IQueryPool::Desc& desc, IQueryPool** outPool) override;
 
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL readTextureResource(
         ITextureResource* texture,
@@ -99,22 +108,28 @@ public:
         Size* outPixelSize) override;
 
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL readBufferResource(
-        IBufferResource* buffer, Offset offset, Size size, ISlangBlob** outBlob) override;
+        IBufferResource* buffer,
+        Offset offset,
+        Size size,
+        ISlangBlob** outBlob) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL getAccelerationStructurePrebuildInfo(
         const IAccelerationStructure::BuildInputs& buildInputs,
         IAccelerationStructure::PrebuildInfo* outPrebuildInfo) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createAccelerationStructure(
-        const IAccelerationStructure::CreateDesc& desc, IAccelerationStructure** outView) override;
+        const IAccelerationStructure::CreateDesc& desc,
+        IAccelerationStructure** outView) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL getTextureAllocationInfo(
-        const ITextureResource::Desc& desc, Size* outSize, Size* outAlignment) override;
+        const ITextureResource::Desc& desc,
+        Size* outSize,
+        Size* outAlignment) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL getTextureRowAlignment(Size* outAlignment) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createFence(const IFence::Desc& desc, IFence** outFence) override;
+    createFence(const IFence::Desc& desc, IFence** outFence) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL waitForFences(
         GfxCount fenceCount,
@@ -128,7 +143,7 @@ public:
     virtual SLANG_NO_THROW const DeviceInfo& SLANG_MCALL getDeviceInfo() const override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getNativeDeviceHandles(InteropHandles* outHandles) override;
+    getNativeDeviceHandles(InteropHandles* outHandles) override;
 
     ~DeviceImpl();
 
@@ -146,7 +161,8 @@ public:
         VkDebugReportFlagsEXT flags,
         VkDebugReportObjectTypeEXT objType,
         uint64_t srcObject,
-        Size location, // TODO: Is "location" still needed? Calls handleDebugMessage() which doesn't use it
+        Size location, // TODO: Is "location" still needed? Calls handleDebugMessage() which doesn't
+                       // use it
         int32_t msgCode,
         const char* pLayerPrefix,
         const char* pMsg,
diff --git a/tools/gfx/vulkan/vk-fence.cpp b/tools/gfx/vulkan/vk-fence.cpp
index d71847dcb..9ecbcb712 100644
--- a/tools/gfx/vulkan/vk-fence.cpp
+++ b/tools/gfx/vulkan/vk-fence.cpp
@@ -18,7 +18,8 @@ namespace vk
 
 FenceImpl::FenceImpl(DeviceImpl* device)
     : m_device(device)
-{}
+{
+}
 
 FenceImpl::~FenceImpl()
 {
@@ -51,11 +52,12 @@ Result FenceImpl::init(const IFence::Desc& desc)
     if (desc.isShared)
     {
 #if SLANG_WINDOWS_FAMILY
-        exportSemaphoreWin32HandleInfoKHR.sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
+        exportSemaphoreWin32HandleInfoKHR.sType =
+            VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
         exportSemaphoreWin32HandleInfoKHR.pNext = timelineCreateInfo.pNext;
         exportSemaphoreWin32HandleInfoKHR.pAttributes = nullptr;
         exportSemaphoreWin32HandleInfoKHR.dwAccess = GENERIC_ALL;
-        exportSemaphoreWin32HandleInfoKHR.name = (LPCWSTR)nullptr;
+        exportSemaphoreWin32HandleInfoKHR.name = (LPCWSTR) nullptr;
 #endif
         exportSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR;
 #if SLANG_WINDOWS_FAMILY
@@ -69,7 +71,10 @@ Result FenceImpl::init(const IFence::Desc& desc)
     }
 
     SLANG_VK_RETURN_ON_FAIL(m_device->m_api.vkCreateSemaphore(
-        m_device->m_api.m_device, &createInfo, nullptr, &m_semaphore));
+        m_device->m_api.m_device,
+        &createInfo,
+        nullptr,
+        &m_semaphore));
 
     return SLANG_OK;
 }
@@ -77,7 +82,9 @@ Result FenceImpl::init(const IFence::Desc& desc)
 Result FenceImpl::getCurrentValue(uint64_t* outValue)
 {
     SLANG_VK_RETURN_ON_FAIL(m_device->m_api.vkGetSemaphoreCounterValue(
-        m_device->m_api.m_device, m_semaphore, outValue));
+        m_device->m_api.m_device,
+        m_semaphore,
+        outValue));
     return SLANG_OK;
 }
 
@@ -85,7 +92,9 @@ Result FenceImpl::setCurrentValue(uint64_t value)
 {
     uint64_t currentValue = 0;
     SLANG_VK_RETURN_ON_FAIL(m_device->m_api.vkGetSemaphoreCounterValue(
-        m_device->m_api.m_device, m_semaphore, &currentValue));
+        m_device->m_api.m_device,
+        m_semaphore,
+        &currentValue));
     if (currentValue < value)
     {
         VkSemaphoreSignalInfo signalInfo;
@@ -117,16 +126,19 @@ Result FenceImpl::getSharedHandle(InteropHandle* outHandle)
     handleInfo.handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
 
     SLANG_VK_RETURN_ON_FAIL(m_device->m_api.vkGetSemaphoreWin32HandleKHR(
-        m_device->m_api.m_device, &handleInfo, (HANDLE*)&sharedHandle.handleValue));
+        m_device->m_api.m_device,
+        &handleInfo,
+        (HANDLE*)&sharedHandle.handleValue));
 #else
-    VkSemaphoreGetFdInfoKHR fdInfo = {
-        VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR};
+    VkSemaphoreGetFdInfoKHR fdInfo = {VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR};
     fdInfo.pNext = nullptr;
     fdInfo.semaphore = m_semaphore;
     fdInfo.handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
 
     SLANG_VK_RETURN_ON_FAIL(m_device->m_api.vkGetSemaphoreFdKHR(
-        m_device->m_api.m_device, &fdInfo, (int*)&sharedHandle.handleValue));
+        m_device->m_api.m_device,
+        &fdInfo,
+        (int*)&sharedHandle.handleValue));
 #endif
 
     sharedHandle.api = InteropHandleAPI::Vulkan;
diff --git a/tools/gfx/vulkan/vk-fence.h b/tools/gfx/vulkan/vk-fence.h
index 46b0ebc2b..a70334ac2 100644
--- a/tools/gfx/vulkan/vk-fence.h
+++ b/tools/gfx/vulkan/vk-fence.h
@@ -30,7 +30,7 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL getSharedHandle(InteropHandle* outHandle) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getNativeHandle(InteropHandle* outNativeHandle) override;
+    getNativeHandle(InteropHandle* outNativeHandle) override;
 };
 
 } // namespace vk
diff --git a/tools/gfx/vulkan/vk-framebuffer.cpp b/tools/gfx/vulkan/vk-framebuffer.cpp
index 7f91b0d19..3eef533fa 100644
--- a/tools/gfx/vulkan/vk-framebuffer.cpp
+++ b/tools/gfx/vulkan/vk-framebuffer.cpp
@@ -2,9 +2,8 @@
 #include "vk-framebuffer.h"
 
 #include "vk-device.h"
-#include "vk-resource-views.h"
-
 #include "vk-helper-functions.h"
+#include "vk-resource-views.h"
 
 namespace gfx
 {
@@ -106,7 +105,10 @@ Result FramebufferLayoutImpl::init(DeviceImpl* renderer, const IFramebufferLayou
     renderPassCreateInfo.subpassCount = 1;
     renderPassCreateInfo.pSubpasses = &subpassDesc;
     SLANG_VK_RETURN_ON_FAIL(m_renderer->m_api.vkCreateRenderPass(
-        m_renderer->m_api.m_device, &renderPassCreateInfo, nullptr, &m_renderPass));
+        m_renderer->m_api.m_device,
+        &renderPassCreateInfo,
+        nullptr,
+        &m_renderPass));
     return SLANG_OK;
 }
 
@@ -142,7 +144,9 @@ Result FramebufferImpl::init(DeviceImpl* renderer, const IFramebuffer::Desc& des
         auto size = resourceDesc->size;
         m_width = getMipLevelSize(viewDesc->subresourceRange.mipLevel, size.width);
         m_height = getMipLevelSize(viewDesc->subresourceRange.mipLevel, size.height);
-        layerCount = (resourceDesc->type == IResource::Type::Texture3D) ? size.depth : viewDesc->subresourceRange.layerCount;
+        layerCount = (resourceDesc->type == IResource::Type::Texture3D)
+                         ? size.depth
+                         : viewDesc->subresourceRange.layerCount;
     }
     else
     {
@@ -200,7 +204,10 @@ Result FramebufferImpl::init(DeviceImpl* renderer, const IFramebuffer::Desc& des
     framebufferInfo.layers = layerCount;
 
     SLANG_VK_RETURN_ON_FAIL(m_renderer->m_api.vkCreateFramebuffer(
-        m_renderer->m_api.m_device, &framebufferInfo, nullptr, &m_handle));
+        m_renderer->m_api.m_device,
+        &framebufferInfo,
+        nullptr,
+        &m_handle));
     return SLANG_OK;
 }
 
diff --git a/tools/gfx/vulkan/vk-helper-functions.cpp b/tools/gfx/vulkan/vk-helper-functions.cpp
index 1f7c6b6ff..b7bbeec2b 100644
--- a/tools/gfx/vulkan/vk-helper-functions.cpp
+++ b/tools/gfx/vulkan/vk-helper-functions.cpp
@@ -31,12 +31,9 @@ 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;
     }
 }
 
@@ -44,10 +41,8 @@ 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;
     }
 }
 
@@ -71,33 +66,21 @@ 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;
     }
 }
 
@@ -107,37 +90,28 @@ 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 |
@@ -146,9 +120,7 @@ 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);
     }
 }
 
@@ -157,12 +129,9 @@ 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(
@@ -173,27 +142,22 @@ 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);
+                         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::AccelerationStructure:
         return VkPipelineStageFlagBits(
             VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
@@ -204,9 +168,7 @@ 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);
     }
 }
 
@@ -215,7 +177,7 @@ VkAccessFlags translateAccelerationStructureAccessFlag(AccessFlag access)
     VkAccessFlags result = 0;
     if ((uint32_t)access & (uint32_t)AccessFlag::Read)
         result |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR | VK_ACCESS_SHADER_READ_BIT |
-        VK_ACCESS_TRANSFER_READ_BIT;
+                  VK_ACCESS_TRANSFER_READ_BIT;
     if ((uint32_t)access & (uint32_t)AccessFlag::Write)
         result |= VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
     return result;
@@ -225,41 +187,33 @@ 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:
-    {
-        assert(!"Invalid resource state for buffer resource.");
-        return VkBufferUsageFlagBits(0);
-    }
+        {
+            assert(!"Invalid resource state for buffer resource.");
+            return VkBufferUsageFlagBits(0);
+        }
     case ResourceState::UnorderedAccess:
-        return (
-            VkBufferUsageFlagBits)(VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
+        return (VkBufferUsageFlagBits)(VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT |
+                                       VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
     case ResourceState::ShaderResource:
     case ResourceState::NonPixelShaderResource:
     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;
+        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::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);
     }
 }
 
@@ -279,36 +233,25 @@ 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");
-        return VkImageUsageFlagBits(0);
-    }
+        {
+            assert(!"Unsupported");
+            return VkImageUsageFlagBits(0);
+        }
     }
 }
 
@@ -323,17 +266,16 @@ VkImageViewType _calcImageViewType(ITextureResource::Type type, const ITextureRe
     case IResource::Type::TextureCube:
         return desc.arraySize > 1 ? VK_IMAGE_VIEW_TYPE_CUBE_ARRAY : VK_IMAGE_VIEW_TYPE_CUBE;
     case IResource::Type::Texture3D:
-    {
-        // Can't have an array and 3d texture
-        assert(desc.arraySize <= 1);
-        if (desc.arraySize <= 1)
         {
-            return VK_IMAGE_VIEW_TYPE_3D;
+            // Can't have an array and 3d texture
+            assert(desc.arraySize <= 1);
+            if (desc.arraySize <= 1)
+            {
+                return VK_IMAGE_VIEW_TYPE_3D;
+            }
+            break;
         }
-        break;
-    }
-    default:
-        break;
+    default: break;
     }
 
     return VK_IMAGE_VIEW_TYPE_MAX_ENUM;
@@ -352,7 +294,9 @@ VkImageUsageFlagBits _calcImageUsageFlags(ResourceStateSet states)
 }
 
 VkImageUsageFlags _calcImageUsageFlags(
-    ResourceStateSet states, MemoryType memoryType, const void* initData)
+    ResourceStateSet states,
+    MemoryType memoryType,
+    const void* initData)
 {
     VkImageUsageFlags usage = _calcImageUsageFlags(states);
 
@@ -387,12 +331,9 @@ 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);
@@ -406,16 +347,13 @@ 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:
@@ -426,9 +364,7 @@ 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;
     }
 }
 
@@ -442,12 +378,9 @@ 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;
     }
 }
 
@@ -455,8 +388,8 @@ AdapterLUID getAdapterLUID(VulkanApi api, VkPhysicalDevice physicalDevice)
 {
     AdapterLUID luid = {};
 
-    VkPhysicalDeviceIDPropertiesKHR idProps = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR };
-    VkPhysicalDeviceProperties2 props = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 };
+    VkPhysicalDeviceIDPropertiesKHR idProps = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR};
+    VkPhysicalDeviceProperties2 props = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2};
     props.pNext = &idProps;
     SLANG_ASSERT(api.vkGetPhysicalDeviceFeatures2);
     api.vkGetPhysicalDeviceProperties2(physicalDevice, &props);
@@ -487,7 +420,7 @@ Result SLANG_MCALL getVKAdapters(List<AdapterInfo>& outAdapters)
         if (api.initGlobalProcs(module) != SLANG_OK)
             continue;
 
-        VkInstanceCreateInfo instanceCreateInfo = { VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
+        VkInstanceCreateInfo instanceCreateInfo = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};
         const char* instanceExtensions[] = {
             VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
 #if SLANG_APPLE_FAMILY
@@ -509,18 +442,25 @@ Result SLANG_MCALL getVKAdapters(List<AdapterInfo>& outAdapters)
         if (api.vkEnumeratePhysicalDevices || api.vkGetPhysicalDeviceProperties)
         {
             uint32_t numPhysicalDevices = 0;
-            SLANG_VK_RETURN_ON_FAIL(api.vkEnumeratePhysicalDevices(instance, &numPhysicalDevices, nullptr));
+            SLANG_VK_RETURN_ON_FAIL(
+                api.vkEnumeratePhysicalDevices(instance, &numPhysicalDevices, nullptr));
 
             List<VkPhysicalDevice> physicalDevices;
             physicalDevices.setCount(numPhysicalDevices);
-            SLANG_VK_RETURN_ON_FAIL(api.vkEnumeratePhysicalDevices(instance, &numPhysicalDevices, physicalDevices.getBuffer()));
+            SLANG_VK_RETURN_ON_FAIL(api.vkEnumeratePhysicalDevices(
+                instance,
+                &numPhysicalDevices,
+                physicalDevices.getBuffer()));
 
             for (const auto& physicalDevice : physicalDevices)
             {
                 VkPhysicalDeviceProperties props;
                 api.vkGetPhysicalDeviceProperties(physicalDevice, &props);
                 AdapterInfo info = {};
-                memcpy(info.name, props.deviceName, Math::Min(strlen(props.deviceName), sizeof(AdapterInfo::name) - 1));
+                memcpy(
+                    info.name,
+                    props.deviceName,
+                    Math::Min(strlen(props.deviceName), sizeof(AdapterInfo::name) - 1));
                 info.vendorID = props.vendorID;
                 info.deviceID = props.deviceID;
                 info.luid = vk::getAdapterLUID(api, physicalDevice);
diff --git a/tools/gfx/vulkan/vk-helper-functions.h b/tools/gfx/vulkan/vk-helper-functions.h
index 8eab863f4..59dc61230 100644
--- a/tools/gfx/vulkan/vk-helper-functions.h
+++ b/tools/gfx/vulkan/vk-helper-functions.h
@@ -1,30 +1,30 @@
 // vk-helper-functions.h
 #pragma once
 
-#include "vk-base.h"
 #include "core/slang-blob.h"
+#include "vk-base.h"
 #include "vk-util.h"
 
 // Vulkan has a different coordinate system to ogl
 // http://anki3d.org/vulkan-coordinate-system/
 #ifndef ENABLE_VALIDATION_LAYER
-#    if _DEBUG
-#        define ENABLE_VALIDATION_LAYER 1
-#    else
-#        define ENABLE_VALIDATION_LAYER 0
-#    endif
+#if _DEBUG
+#define ENABLE_VALIDATION_LAYER 1
+#else
+#define ENABLE_VALIDATION_LAYER 0
+#endif
 #endif
 
 #ifdef _MSC_VER
-#    include <stddef.h>
-#    pragma warning(disable : 4996)
-#    if (_MSC_VER < 1900)
-#        define snprintf sprintf_s
-#    endif
+#include <stddef.h>
+#pragma warning(disable : 4996)
+#if (_MSC_VER < 1900)
+#define snprintf sprintf_s
+#endif
 #endif
 
 #if SLANG_WINDOWS_FAMILY
-#    include <dxgi1_2.h>
+#include <dxgi1_2.h>
 #endif
 
 namespace gfx
@@ -108,13 +108,14 @@ struct BindingOffset : SimpleBindingOffset
     /// Create an offset from a simple offset
     explicit BindingOffset(SimpleBindingOffset const& offset)
         : SimpleBindingOffset(offset)
-    {}
+    {
+    }
 
     /// Create an offset based on offset information in the given Slang `varLayout`
     BindingOffset(slang::VariableLayoutReflection* varLayout)
-        : SimpleBindingOffset(varLayout)
-        , pending(varLayout->getPendingDataLayout())
-    {}
+        : SimpleBindingOffset(varLayout), pending(varLayout->getPendingDataLayout())
+    {
+    }
 
     /// Add any values in the given `offset`
     void operator+=(SimpleBindingOffset const& offset) { SimpleBindingOffset::operator+=(offset); }
@@ -166,7 +167,9 @@ VkImageUsageFlagBits _calcImageUsageFlags(ResourceState state);
 VkImageViewType _calcImageViewType(ITextureResource::Type type, const ITextureResource::Desc& desc);
 VkImageUsageFlagBits _calcImageUsageFlags(ResourceStateSet states);
 VkImageUsageFlags _calcImageUsageFlags(
-    ResourceStateSet states, MemoryType memoryType, const void* initData);
+    ResourceStateSet states,
+    MemoryType memoryType,
+    const void* initData);
 
 VkAccessFlags calcAccessFlagsFromImageLayout(VkImageLayout layout);
 VkPipelineStageFlags calcPipelineStageFlagsFromImageLayout(VkImageLayout layout);
diff --git a/tools/gfx/vulkan/vk-module.cpp b/tools/gfx/vulkan/vk-module.cpp
index 0e4df8e7f..6a3d4e095 100644
--- a/tools/gfx/vulkan/vk-module.cpp
+++ b/tools/gfx/vulkan/vk-module.cpp
@@ -1,19 +1,20 @@
 // module.cpp
 #include "vk-module.h"
 
-#include <stdlib.h>
-#include <stdio.h>
 #include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
 
 #if SLANG_WINDOWS_FAMILY
-#   include <windows.h>
+#include <windows.h>
 #else
-#   include <dlfcn.h>
+#include <dlfcn.h>
 #endif
 
 #include "../renderer-shared.h"
 
-namespace gfx {
+namespace gfx
+{
 using namespace Slang;
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! VulkanModule !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -81,4 +82,4 @@ void VulkanModule::destroy()
     m_module = nullptr;
 }
 
-} // renderer_test
+} // namespace gfx
diff --git a/tools/gfx/vulkan/vk-module.h b/tools/gfx/vulkan/vk-module.h
index 062c953f6..4ee04dbc8 100644
--- a/tools/gfx/vulkan/vk-module.h
+++ b/tools/gfx/vulkan/vk-module.h
@@ -1,18 +1,17 @@
 // vk-module.h
 #pragma once
 
-#include "slang.h"
-
 #include "slang-com-helper.h"
+#include "slang.h"
 
 #if SLANG_WINDOWS_FAMILY
-#   define VK_USE_PLATFORM_WIN32_KHR 1
+#define VK_USE_PLATFORM_WIN32_KHR 1
 #elif SLANG_APPLE_FAMILY
-#   define VK_USE_PLATFORM_METAL_EXT 1
+#define VK_USE_PLATFORM_METAL_EXT 1
 #else
-#   if SLANG_ENABLE_XLIB
-#       define VK_USE_PLATFORM_XLIB_KHR 1
-#   endif
+#if SLANG_ENABLE_XLIB
+#define VK_USE_PLATFORM_XLIB_KHR 1
+#endif
 #endif
 
 #define VK_NO_PROTOTYPES
@@ -21,36 +20,37 @@
 
 // Undef xlib macros
 #ifdef Always
-#    undef Always
+#undef Always
 #endif
 #ifdef None
-#    undef None
+#undef None
 #endif
 
-namespace gfx {
+namespace gfx
+{
 
 struct VulkanModule
 {
-        /// true if has been initialized
+    /// true if has been initialized
     SLANG_FORCE_INLINE bool isInitialized() const { return m_module != nullptr; }
 
-        /// Get a function by name
+    /// Get a function by name
     PFN_vkVoidFunction getFunction(const char* name) const;
 
-        /// true if using a software Vulkan implementation.
+    /// true if using a software Vulkan implementation.
     bool isSoftware() const { return m_isSoftware; }
 
-        /// Initialize
+    /// Initialize
     Slang::Result init(bool useSoftwareImpl);
-        /// Destroy
+    /// Destroy
     void destroy();
 
-        /// Dtor
+    /// Dtor
     ~VulkanModule() { destroy(); }
 
- protected:
-     void* m_module = nullptr;
-     bool m_isSoftware = false;
+protected:
+    void* m_module = nullptr;
+    bool m_isSoftware = false;
 };
 
-} // renderer_test
+} // namespace gfx
diff --git a/tools/gfx/vulkan/vk-pipeline-dump-layer.cpp b/tools/gfx/vulkan/vk-pipeline-dump-layer.cpp
index 959eee15d..e17dea1f9 100644
--- a/tools/gfx/vulkan/vk-pipeline-dump-layer.cpp
+++ b/tools/gfx/vulkan/vk-pipeline-dump-layer.cpp
@@ -1,152 +1,182 @@
 #include "vk-pipeline-dump-layer.h"
+
 #include "core/slang-basic.h"
 #include "core/slang-stream.h"
-namespace gfx {
-    using namespace Slang;
-
-    struct PipelineDumpContext
-    {
-        Dictionary<VkPipelineLayout, Index> pipelineLayouts;
-        Dictionary<VkShaderModule, Index> shaderModules;
-        Dictionary<VkDescriptorSetLayout, Index> descriptorSets;
-        Dictionary<VkPipeline, Index> computePipelines;
-        
-        List<uint8_t> serializedBytes;
-
-        VulkanApi api;
-
-        template<typename T>
-        void writeRaw(T v)
-        {
-            auto startIndex = serializedBytes.getCount();
-            serializedBytes.growToCount(startIndex + sizeof(T));
-            memcpy(serializedBytes.getBuffer() + startIndex, &v, sizeof(T));
-        }
-
-        template<typename T>
-        void writeArray(uint32_t elementCount, const T* data)
-        {
-            writeRaw(elementCount);
-
-            auto startIndex = serializedBytes.getCount();
-            serializedBytes.growToCount(startIndex + sizeof(T) * elementCount);
-            memcpy(serializedBytes.getBuffer() + startIndex, data, sizeof(T) * elementCount);
-        }
-
-        void writeStr(const char* str)
-        {
-            auto len = (uint32_t)strlen(str) + 1;
-            writeRaw(len);
-
-            auto startIndex = serializedBytes.getCount();
-            serializedBytes.growToCount(startIndex + len);
-            memcpy(serializedBytes.getBuffer() + startIndex, str, len - 1);
-            serializedBytes[startIndex + len - 1] = 0;
-        }
+namespace gfx
+{
+using namespace Slang;
 
-        void writePipelineLayout(VkPipelineLayout layout, const VkPipelineLayoutCreateInfo* createInfo)
-        {
-            auto startIndex = serializedBytes.getCount();
-            writeRaw(createInfo->sType);
-            writeRaw(createInfo->flags);
-            writeRaw(createInfo->setLayoutCount);
-            for (uint32_t i = 0; i < createInfo->setLayoutCount; i++)
-                writeRaw(descriptorSets.getValue(createInfo->pSetLayouts[i]));
-            writeArray(createInfo->pushConstantRangeCount, createInfo->pPushConstantRanges);
-            pipelineLayouts[layout] = startIndex;
-        }
+struct PipelineDumpContext
+{
+    Dictionary<VkPipelineLayout, Index> pipelineLayouts;
+    Dictionary<VkShaderModule, Index> shaderModules;
+    Dictionary<VkDescriptorSetLayout, Index> descriptorSets;
+    Dictionary<VkPipeline, Index> computePipelines;
 
-        void writeShaderModule(VkShaderModule module, const VkShaderModuleCreateInfo* createInfo)
-        {
-            auto startIndex = serializedBytes.getCount();
-            writeRaw(createInfo->sType);
-            writeRaw(createInfo->flags);
-            writeArray((uint32_t)(createInfo->codeSize/sizeof(uint32_t)), createInfo->pCode);
-            shaderModules[module] = startIndex;
-        }
+    List<uint8_t> serializedBytes;
 
-        void writeDescriptorSetLayout(VkDescriptorSetLayout layout, const VkDescriptorSetLayoutCreateInfo* createInfo)
-        {
-            auto startIndex = serializedBytes.getCount();
-            writeRaw(createInfo->sType);
-            writeRaw(createInfo->flags);
-            writeArray(createInfo->bindingCount, createInfo->pBindings);
-            descriptorSets[layout] = startIndex;
-        }
+    VulkanApi api;
 
-        void writePipeline(VkPipeline pipeline, const VkComputePipelineCreateInfo* createInfo)
-        {
-            auto startIndex = serializedBytes.getCount();
-            writeRaw(createInfo->sType);
-            writeRaw(createInfo->flags);
-            writeRaw(createInfo->stage.sType);
-            writeRaw(createInfo->stage.flags);
-            writeRaw(createInfo->stage.stage);
-            writeRaw(shaderModules.getValue(createInfo->stage.module));
-            writeStr(createInfo->stage.pName);
-            writeRaw(pipelineLayouts.getValue(createInfo->layout));
-            computePipelines[pipeline] = startIndex;
-        }
+    template<typename T>
+    void writeRaw(T v)
+    {
+        auto startIndex = serializedBytes.getCount();
+        serializedBytes.growToCount(startIndex + sizeof(T));
+        memcpy(serializedBytes.getBuffer() + startIndex, &v, sizeof(T));
+    }
 
-        void writeToFile(UnownedStringSlice path)
-        {
-            RefPtr<FileStream> fs = new FileStream();
-            fs->init(path, FileMode::Create);
-            uint32_t pipelineCount = (uint32_t)computePipelines.getCount();
-            fs->write(&pipelineCount, sizeof(uint32_t));
-            for (auto& pair : computePipelines)
-            {
-                fs->write(KeyValueDetail::getValue(&pair), sizeof(Index));
-            }
-            Index blobSize = serializedBytes.getCount();
-            fs->write(&blobSize, sizeof(blobSize));
-            fs->write(serializedBytes.getBuffer(), serializedBytes.getCount());
-            fs->close();
-        }
-    };
+    template<typename T>
+    void writeArray(uint32_t elementCount, const T* data)
+    {
+        writeRaw(elementCount);
 
-    PipelineDumpContext dumpContext;
+        auto startIndex = serializedBytes.getCount();
+        serializedBytes.growToCount(startIndex + sizeof(T) * elementCount);
+        memcpy(serializedBytes.getBuffer() + startIndex, data, sizeof(T) * elementCount);
+    }
 
-    VkResult SLANG_MCALL createPipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* createInfo, const VkAllocationCallbacks* callbacks, VkPipelineLayout* outLayout)
+    void writeStr(const char* str)
     {
-        auto result = dumpContext.api.vkCreatePipelineLayout(device, createInfo, callbacks, outLayout);
-        dumpContext.writePipelineLayout(*outLayout, createInfo);
-        return result;
+        auto len = (uint32_t)strlen(str) + 1;
+        writeRaw(len);
+
+        auto startIndex = serializedBytes.getCount();
+        serializedBytes.growToCount(startIndex + len);
+        memcpy(serializedBytes.getBuffer() + startIndex, str, len - 1);
+        serializedBytes[startIndex + len - 1] = 0;
     }
 
-    VkResult SLANG_MCALL createComputePipelines(VkDevice device, VkPipelineCache cache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* createInfos, const VkAllocationCallbacks* callbacks, VkPipeline* outPipelines)
+    void writePipelineLayout(VkPipelineLayout layout, const VkPipelineLayoutCreateInfo* createInfo)
     {
-        auto result = dumpContext.api.vkCreateComputePipelines(device, cache, createInfoCount, createInfos, callbacks, outPipelines);
-        for (uint32_t i = 0; i < createInfoCount; i++)
-            dumpContext.writePipeline(outPipelines[i], createInfos + i);
-        return result;
+        auto startIndex = serializedBytes.getCount();
+        writeRaw(createInfo->sType);
+        writeRaw(createInfo->flags);
+        writeRaw(createInfo->setLayoutCount);
+        for (uint32_t i = 0; i < createInfo->setLayoutCount; i++)
+            writeRaw(descriptorSets.getValue(createInfo->pSetLayouts[i]));
+        writeArray(createInfo->pushConstantRangeCount, createInfo->pPushConstantRanges);
+        pipelineLayouts[layout] = startIndex;
     }
 
-    VkResult SLANG_MCALL createShaderModule(VkDevice device, const VkShaderModuleCreateInfo* createInfo, const VkAllocationCallbacks* callbacks, VkShaderModule* outShaderModule)
+    void writeShaderModule(VkShaderModule module, const VkShaderModuleCreateInfo* createInfo)
     {
-        auto result = dumpContext.api.vkCreateShaderModule(device, createInfo, callbacks, outShaderModule);
-        dumpContext.writeShaderModule(*outShaderModule, createInfo);
-        return result;
+        auto startIndex = serializedBytes.getCount();
+        writeRaw(createInfo->sType);
+        writeRaw(createInfo->flags);
+        writeArray((uint32_t)(createInfo->codeSize / sizeof(uint32_t)), createInfo->pCode);
+        shaderModules[module] = startIndex;
     }
 
-    VkResult SLANG_MCALL createDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* createInfo, const VkAllocationCallbacks* callbacks, VkDescriptorSetLayout* outDescSetLayout)
+    void writeDescriptorSetLayout(
+        VkDescriptorSetLayout layout,
+        const VkDescriptorSetLayoutCreateInfo* createInfo)
     {
-        auto result = dumpContext.api.vkCreateDescriptorSetLayout(device, createInfo, callbacks, outDescSetLayout);
-        dumpContext.writeDescriptorSetLayout(*outDescSetLayout, createInfo);
-        return result;
+        auto startIndex = serializedBytes.getCount();
+        writeRaw(createInfo->sType);
+        writeRaw(createInfo->flags);
+        writeArray(createInfo->bindingCount, createInfo->pBindings);
+        descriptorSets[layout] = startIndex;
     }
 
-    void installPipelineDumpLayer(VulkanApi& api)
+    void writePipeline(VkPipeline pipeline, const VkComputePipelineCreateInfo* createInfo)
     {
-        dumpContext.api = api;
-        api.vkCreatePipelineLayout = createPipelineLayout;
-        api.vkCreateComputePipelines = createComputePipelines;
-        api.vkCreateShaderModule = createShaderModule;
-        api.vkCreateDescriptorSetLayout = createDescriptorSetLayout;
+        auto startIndex = serializedBytes.getCount();
+        writeRaw(createInfo->sType);
+        writeRaw(createInfo->flags);
+        writeRaw(createInfo->stage.sType);
+        writeRaw(createInfo->stage.flags);
+        writeRaw(createInfo->stage.stage);
+        writeRaw(shaderModules.getValue(createInfo->stage.module));
+        writeStr(createInfo->stage.pName);
+        writeRaw(pipelineLayouts.getValue(createInfo->layout));
+        computePipelines[pipeline] = startIndex;
     }
 
-    void writePipelineDump(UnownedStringSlice path)
+    void writeToFile(UnownedStringSlice path)
     {
-        dumpContext.writeToFile(path);
+        RefPtr<FileStream> fs = new FileStream();
+        fs->init(path, FileMode::Create);
+        uint32_t pipelineCount = (uint32_t)computePipelines.getCount();
+        fs->write(&pipelineCount, sizeof(uint32_t));
+        for (auto& pair : computePipelines)
+        {
+            fs->write(KeyValueDetail::getValue(&pair), sizeof(Index));
+        }
+        Index blobSize = serializedBytes.getCount();
+        fs->write(&blobSize, sizeof(blobSize));
+        fs->write(serializedBytes.getBuffer(), serializedBytes.getCount());
+        fs->close();
     }
-} // renderer_test
+};
+
+PipelineDumpContext dumpContext;
+
+VkResult SLANG_MCALL createPipelineLayout(
+    VkDevice device,
+    const VkPipelineLayoutCreateInfo* createInfo,
+    const VkAllocationCallbacks* callbacks,
+    VkPipelineLayout* outLayout)
+{
+    auto result = dumpContext.api.vkCreatePipelineLayout(device, createInfo, callbacks, outLayout);
+    dumpContext.writePipelineLayout(*outLayout, createInfo);
+    return result;
+}
+
+VkResult SLANG_MCALL createComputePipelines(
+    VkDevice device,
+    VkPipelineCache cache,
+    uint32_t createInfoCount,
+    const VkComputePipelineCreateInfo* createInfos,
+    const VkAllocationCallbacks* callbacks,
+    VkPipeline* outPipelines)
+{
+    auto result = dumpContext.api.vkCreateComputePipelines(
+        device,
+        cache,
+        createInfoCount,
+        createInfos,
+        callbacks,
+        outPipelines);
+    for (uint32_t i = 0; i < createInfoCount; i++)
+        dumpContext.writePipeline(outPipelines[i], createInfos + i);
+    return result;
+}
+
+VkResult SLANG_MCALL createShaderModule(
+    VkDevice device,
+    const VkShaderModuleCreateInfo* createInfo,
+    const VkAllocationCallbacks* callbacks,
+    VkShaderModule* outShaderModule)
+{
+    auto result =
+        dumpContext.api.vkCreateShaderModule(device, createInfo, callbacks, outShaderModule);
+    dumpContext.writeShaderModule(*outShaderModule, createInfo);
+    return result;
+}
+
+VkResult SLANG_MCALL createDescriptorSetLayout(
+    VkDevice device,
+    const VkDescriptorSetLayoutCreateInfo* createInfo,
+    const VkAllocationCallbacks* callbacks,
+    VkDescriptorSetLayout* outDescSetLayout)
+{
+    auto result = dumpContext.api
+                      .vkCreateDescriptorSetLayout(device, createInfo, callbacks, outDescSetLayout);
+    dumpContext.writeDescriptorSetLayout(*outDescSetLayout, createInfo);
+    return result;
+}
+
+void installPipelineDumpLayer(VulkanApi& api)
+{
+    dumpContext.api = api;
+    api.vkCreatePipelineLayout = createPipelineLayout;
+    api.vkCreateComputePipelines = createComputePipelines;
+    api.vkCreateShaderModule = createShaderModule;
+    api.vkCreateDescriptorSetLayout = createDescriptorSetLayout;
+}
+
+void writePipelineDump(UnownedStringSlice path)
+{
+    dumpContext.writeToFile(path);
+}
+} // namespace gfx
diff --git a/tools/gfx/vulkan/vk-pipeline-dump-layer.h b/tools/gfx/vulkan/vk-pipeline-dump-layer.h
index c514f7f3e..75f4b32cc 100644
--- a/tools/gfx/vulkan/vk-pipeline-dump-layer.h
+++ b/tools/gfx/vulkan/vk-pipeline-dump-layer.h
@@ -1,11 +1,11 @@
 // vk-api.cpp
-#include "vk-api.h"
-
 #include "core/slang-string.h"
+#include "vk-api.h"
 
-namespace gfx {
+namespace gfx
+{
 
 void installPipelineDumpLayer(VulkanApi& api);
 void writePipelineDump(Slang::UnownedStringSlice path);
 
-} // renderer_test
+} // namespace gfx
diff --git a/tools/gfx/vulkan/vk-pipeline-state.cpp b/tools/gfx/vulkan/vk-pipeline-state.cpp
index 2e7bb1c0a..8fd0c5680 100644
--- a/tools/gfx/vulkan/vk-pipeline-state.cpp
+++ b/tools/gfx/vulkan/vk-pipeline-state.cpp
@@ -2,12 +2,11 @@
 #include "vk-pipeline-state.h"
 
 #include "vk-device.h"
-#include "vk-shader-program.h"
+#include "vk-helper-functions.h"
 #include "vk-shader-object-layout.h"
+#include "vk-shader-program.h"
 #include "vk-vertex-layout.h"
 
-#include "vk-helper-functions.h"
-
 namespace gfx
 {
 
@@ -35,9 +34,15 @@ PipelineStateImpl::~PipelineStateImpl()
     }
 }
 
-void PipelineStateImpl::establishStrongDeviceReference() { m_device.establishStrongReference(); }
+void PipelineStateImpl::establishStrongDeviceReference()
+{
+    m_device.establishStrongReference();
+}
 
-void PipelineStateImpl::comFree() { m_device.breakStrongReference(); }
+void PipelineStateImpl::comFree()
+{
+    m_device.breakStrongReference();
+}
 
 void PipelineStateImpl::init(const GraphicsPipelineStateDesc& inDesc)
 {
@@ -159,8 +164,8 @@ Result PipelineStateImpl::createVKGraphicsPipelineState()
     multisampling.alphaToCoverageEnable = blendDesc.alphaToCoverageEnable;
     multisampling.alphaToOneEnable = VK_FALSE;
 
-    auto targetCount =
-        GfxCount(Math::Min(framebufferLayoutImpl->m_renderTargetCount, (uint32_t)blendDesc.targetCount));
+    auto targetCount = GfxCount(
+        Math::Min(framebufferLayoutImpl->m_renderTargetCount, (uint32_t)blendDesc.targetCount));
     List<VkPipelineColorBlendAttachmentState> colorBlendTargets;
 
     // Regardless of whether blending is enabled, Vulkan always applies the color write mask
@@ -222,7 +227,8 @@ Result PipelineStateImpl::createVKGraphicsPipelineState()
     dynamicStates.add(VK_DYNAMIC_STATE_BLEND_CONSTANTS);
     // It's not valid to specify VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT when
     // the pipeline contains a mesh shader.
-    if (!m_program->isMeshShaderProgram() && m_device->m_api.m_extendedFeatures.extendedDynamicStateFeatures.extendedDynamicState)
+    if (!m_program->isMeshShaderProgram() &&
+        m_device->m_api.m_extendedFeatures.extendedDynamicStateFeatures.extendedDynamicState)
 
     {
         dynamicStates.add(VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT);
@@ -275,17 +281,21 @@ Result PipelineStateImpl::createVKGraphicsPipelineState()
 
     if (m_device->m_pipelineCreationAPIDispatcher)
     {
-        SLANG_RETURN_ON_FAIL(
-            m_device->m_pipelineCreationAPIDispatcher->createGraphicsPipelineState(
-                m_device,
-                programImpl->linkedProgram.get(),
-                &pipelineInfo,
-                (void**)&m_pipeline));
+        SLANG_RETURN_ON_FAIL(m_device->m_pipelineCreationAPIDispatcher->createGraphicsPipelineState(
+            m_device,
+            programImpl->linkedProgram.get(),
+            &pipelineInfo,
+            (void**)&m_pipeline));
     }
     else
     {
         SLANG_VK_RETURN_ON_FAIL(m_device->m_api.vkCreateGraphicsPipelines(
-            m_device->m_device, pipelineCache, 1, &pipelineInfo, nullptr, &m_pipeline));
+            m_device->m_device,
+            pipelineCache,
+            1,
+            &pipelineInfo,
+            nullptr,
+            &m_pipeline));
     }
 
     return SLANG_OK;
@@ -300,24 +310,28 @@ Result PipelineStateImpl::createVKComputePipelineState()
     }
 
     VkComputePipelineCreateInfo computePipelineInfo = {
-            VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
+        VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
     computePipelineInfo.stage = programImpl->m_stageCreateInfos[0];
     computePipelineInfo.layout = programImpl->m_rootObjectLayout->m_pipelineLayout;
 
     if (m_device->m_pipelineCreationAPIDispatcher)
     {
-        SLANG_RETURN_ON_FAIL(
-            m_device->m_pipelineCreationAPIDispatcher->createComputePipelineState(
-                m_device,
-                programImpl->linkedProgram.get(),
-                &computePipelineInfo,
-                (void**)&m_pipeline));
+        SLANG_RETURN_ON_FAIL(m_device->m_pipelineCreationAPIDispatcher->createComputePipelineState(
+            m_device,
+            programImpl->linkedProgram.get(),
+            &computePipelineInfo,
+            (void**)&m_pipeline));
     }
     else
     {
         VkPipelineCache pipelineCache = VK_NULL_HANDLE;
         SLANG_VK_RETURN_ON_FAIL(m_device->m_api.vkCreateComputePipelines(
-            m_device->m_device, pipelineCache, 1, &computePipelineInfo, nullptr, &m_pipeline));
+            m_device->m_device,
+            pipelineCache,
+            1,
+            &computePipelineInfo,
+            nullptr,
+            &m_pipeline));
     }
     return SLANG_OK;
 }
@@ -329,13 +343,9 @@ 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)
@@ -349,9 +359,11 @@ SLANG_NO_THROW Result SLANG_MCALL PipelineStateImpl::getNativeHandle(InteropHand
 
 RayTracingPipelineStateImpl::RayTracingPipelineStateImpl(DeviceImpl* device)
     : PipelineStateImpl(device)
-{}
+{
+}
 uint32_t RayTracingPipelineStateImpl::findEntryPointIndexByName(
-    const Dictionary<String, Index>& entryPointNameToIndex, const char* name)
+    const Dictionary<String, Index>& entryPointNameToIndex,
+    const char* name)
 {
     if (!name)
         return VK_SHADER_UNUSED_KHR;
@@ -451,7 +463,8 @@ Result RayTracingPipelineStateImpl::createVKRayTracingPipelineState()
     if (m_device->m_pipelineCreationAPIDispatcher)
     {
         m_device->m_pipelineCreationAPIDispatcher->beforeCreateRayTracingState(
-            m_device, programImpl->linkedProgram.get());
+            m_device,
+            programImpl->linkedProgram.get());
     }
 
     VkPipelineCache pipelineCache = VK_NULL_HANDLE;
@@ -468,7 +481,8 @@ Result RayTracingPipelineStateImpl::createVKRayTracingPipelineState()
     if (m_device->m_pipelineCreationAPIDispatcher)
     {
         m_device->m_pipelineCreationAPIDispatcher->afterCreateRayTracingState(
-            m_device, programImpl->linkedProgram.get());
+            m_device,
+            programImpl->linkedProgram.get());
     }
     return SLANG_OK;
 }
@@ -479,11 +493,8 @@ 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-pipeline-state.h b/tools/gfx/vulkan/vk-pipeline-state.h
index 3e84ca158..4bf585d7e 100644
--- a/tools/gfx/vulkan/vk-pipeline-state.h
+++ b/tools/gfx/vulkan/vk-pipeline-state.h
@@ -50,7 +50,8 @@ public:
     RayTracingPipelineStateImpl(DeviceImpl* device);
 
     uint32_t findEntryPointIndexByName(
-        const Dictionary<String, Index>& entryPointNameToIndex, const char* name);
+        const Dictionary<String, Index>& entryPointNameToIndex,
+        const char* name);
 
     Result createVKRayTracingPipelineState();
 
diff --git a/tools/gfx/vulkan/vk-query.cpp b/tools/gfx/vulkan/vk-query.cpp
index ccdb84647..694896966 100644
--- a/tools/gfx/vulkan/vk-query.cpp
+++ b/tools/gfx/vulkan/vk-query.cpp
@@ -19,9 +19,7 @@ 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;
@@ -31,8 +29,7 @@ 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));
@@ -67,12 +64,18 @@ Result QueryPoolImpl::getResult(GfxIndex index, GfxCount count, uint64_t* data)
 }
 
 void _writeTimestamp(
-    VulkanApi* api, VkCommandBuffer vkCmdBuffer, IQueryPool* queryPool, SlangInt index)
+    VulkanApi* api,
+    VkCommandBuffer vkCmdBuffer,
+    IQueryPool* queryPool,
+    SlangInt index)
 {
     auto queryPoolImpl = static_cast<QueryPoolImpl*>(queryPool);
     api->vkCmdResetQueryPool(vkCmdBuffer, queryPoolImpl->m_pool, (uint32_t)index, 1);
     api->vkCmdWriteTimestamp(
-        vkCmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, queryPoolImpl->m_pool, (uint32_t)index);
+        vkCmdBuffer,
+        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+        queryPoolImpl->m_pool,
+        (uint32_t)index);
 }
 
 } // namespace vk
diff --git a/tools/gfx/vulkan/vk-query.h b/tools/gfx/vulkan/vk-query.h
index b9cda2557..2ff20d5ab 100644
--- a/tools/gfx/vulkan/vk-query.h
+++ b/tools/gfx/vulkan/vk-query.h
@@ -20,7 +20,7 @@ public:
 
 public:
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getResult(GfxIndex index, GfxCount count, uint64_t* data) override;
+    getResult(GfxIndex index, GfxCount count, uint64_t* data) override;
 
 public:
     VkQueryPool m_pool;
@@ -28,7 +28,10 @@ public:
 };
 
 void _writeTimestamp(
-    VulkanApi* api, VkCommandBuffer vkCmdBuffer, IQueryPool* queryPool, SlangInt index);
+    VulkanApi* api,
+    VkCommandBuffer vkCmdBuffer,
+    IQueryPool* queryPool,
+    SlangInt index);
 
 } // namespace vk
 } // namespace gfx
diff --git a/tools/gfx/vulkan/vk-render-pass.cpp b/tools/gfx/vulkan/vk-render-pass.cpp
index 25a39c58a..10453fadb 100644
--- a/tools/gfx/vulkan/vk-render-pass.cpp
+++ b/tools/gfx/vulkan/vk-render-pass.cpp
@@ -67,9 +67,8 @@ Result RenderPassLayoutImpl::init(DeviceImpl* renderer, const IRenderPassLayout:
     subpassDesc.colorAttachmentCount = desc.renderTargetCount;
     subpassDesc.pColorAttachments = framebufferLayout->m_colorReferences.getBuffer();
     subpassDesc.pResolveAttachments = nullptr;
-    subpassDesc.pDepthStencilAttachment = framebufferLayout->m_hasDepthStencilTarget
-                                              ? &framebufferLayout->m_depthReference
-                                              : nullptr;
+    subpassDesc.pDepthStencilAttachment =
+        framebufferLayout->m_hasDepthStencilTarget ? &framebufferLayout->m_depthReference : nullptr;
     subpassDesc.preserveAttachmentCount = 0u;
     subpassDesc.pPreserveAttachments = nullptr;
 
@@ -80,7 +79,10 @@ Result RenderPassLayoutImpl::init(DeviceImpl* renderer, const IRenderPassLayout:
     renderPassCreateInfo.subpassCount = 1;
     renderPassCreateInfo.pSubpasses = &subpassDesc;
     SLANG_VK_RETURN_ON_FAIL(m_renderer->m_api.vkCreateRenderPass(
-        m_renderer->m_api.m_device, &renderPassCreateInfo, nullptr, &m_renderPass));
+        m_renderer->m_api.m_device,
+        &renderPassCreateInfo,
+        nullptr,
+        &m_renderPass));
     return SLANG_OK;
 }
 
diff --git a/tools/gfx/vulkan/vk-render-pass.h b/tools/gfx/vulkan/vk-render-pass.h
index 7cc1a581f..9fa3808c3 100644
--- a/tools/gfx/vulkan/vk-render-pass.h
+++ b/tools/gfx/vulkan/vk-render-pass.h
@@ -12,9 +12,7 @@ using namespace Slang;
 namespace vk
 {
 
-class RenderPassLayoutImpl
-    : public IRenderPassLayout
-    , public ComObject
+class RenderPassLayoutImpl : public IRenderPassLayout, public ComObject
 {
 public:
     SLANG_COM_OBJECT_IUNKNOWN_ALL
diff --git a/tools/gfx/vulkan/vk-resource-views.cpp b/tools/gfx/vulkan/vk-resource-views.cpp
index 10d96ed54..b6b97b9f5 100644
--- a/tools/gfx/vulkan/vk-resource-views.cpp
+++ b/tools/gfx/vulkan/vk-resource-views.cpp
@@ -23,7 +23,8 @@ Result TextureResourceViewImpl::getNativeHandle(InteropHandle* outHandle)
 
 TexelBufferResourceViewImpl::TexelBufferResourceViewImpl(DeviceImpl* device)
     : ResourceViewImpl(ViewType::TexelBuffer, device)
-{}
+{
+}
 
 TexelBufferResourceViewImpl::~TexelBufferResourceViewImpl()
 {
@@ -39,7 +40,8 @@ Result TexelBufferResourceViewImpl::getNativeHandle(InteropHandle* outHandle)
 
 PlainBufferResourceViewImpl::PlainBufferResourceViewImpl(DeviceImpl* device)
     : ResourceViewImpl(ViewType::PlainBuffer, device)
-{}
+{
+}
 
 Result PlainBufferResourceViewImpl::getNativeHandle(InteropHandle* outHandle)
 {
@@ -63,7 +65,9 @@ AccelerationStructureImpl::~AccelerationStructureImpl()
     if (m_device)
     {
         m_device->m_api.vkDestroyAccelerationStructureKHR(
-            m_device->m_api.m_device, m_vkHandle, nullptr);
+            m_device->m_api.m_device,
+            m_vkHandle,
+            nullptr);
     }
 }
 
diff --git a/tools/gfx/vulkan/vk-resource-views.h b/tools/gfx/vulkan/vk-resource-views.h
index bba99f704..e8b4fbb0a 100644
--- a/tools/gfx/vulkan/vk-resource-views.h
+++ b/tools/gfx/vulkan/vk-resource-views.h
@@ -26,9 +26,9 @@ public:
 
 public:
     ResourceViewImpl(ViewType viewType, DeviceImpl* device)
-        : m_type(viewType)
-        , m_device(device)
-    {}
+        : m_type(viewType), m_device(device)
+    {
+    }
     ViewType m_type;
     RefPtr<DeviceImpl> m_device;
 };
@@ -38,7 +38,8 @@ class TextureResourceViewImpl : public ResourceViewImpl
 public:
     TextureResourceViewImpl(DeviceImpl* device)
         : ResourceViewImpl(ViewType::Texture, device)
-    {}
+    {
+    }
     ~TextureResourceViewImpl();
     RefPtr<TextureResourceImpl> m_texture;
     VkImageView m_view;
diff --git a/tools/gfx/vulkan/vk-sampler.cpp b/tools/gfx/vulkan/vk-sampler.cpp
index e07cff753..ee9357609 100644
--- a/tools/gfx/vulkan/vk-sampler.cpp
+++ b/tools/gfx/vulkan/vk-sampler.cpp
@@ -11,7 +11,8 @@ namespace vk
 
 SamplerStateImpl::SamplerStateImpl(DeviceImpl* device)
     : m_device(device)
-{}
+{
+}
 
 SamplerStateImpl::~SamplerStateImpl()
 {
diff --git a/tools/gfx/vulkan/vk-shader-object-layout.cpp b/tools/gfx/vulkan/vk-shader-object-layout.cpp
index d84627e86..6129246cb 100644
--- a/tools/gfx/vulkan/vk-shader-object-layout.cpp
+++ b/tools/gfx/vulkan/vk-shader-object-layout.cpp
@@ -31,33 +31,22 @@ 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;
     }
 }
 
@@ -65,7 +54,8 @@ VkDescriptorType ShaderObjectLayoutImpl::Builder::_mapDescriptorType(
 /// sub-object described by `typeLayout`, at the given `offset`.
 
 void ShaderObjectLayoutImpl::Builder::_addDescriptorRangesAsValue(
-    slang::TypeLayoutReflection* typeLayout, BindingOffset const& offset)
+    slang::TypeLayoutReflection* typeLayout,
+    BindingOffset const& offset)
 {
     // First we will scan through all the descriptor sets that the Slang reflection
     // information believes go into making up the given type.
@@ -94,8 +84,7 @@ 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.
@@ -103,8 +92,7 @@ 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
@@ -126,7 +114,8 @@ void ShaderObjectLayoutImpl::Builder::_addDescriptorRangesAsValue(
         {
             Index descriptorRangeIndex = firstDescriptorRangeIndex + j;
             auto slangDescriptorType = typeLayout->getDescriptorSetDescriptorRangeType(
-                slangDescriptorSetIndex, descriptorRangeIndex);
+                slangDescriptorSetIndex,
+                descriptorRangeIndex);
 
             // Certain kinds of descriptor ranges reflected by Slang do not
             // manifest as descriptors at the Vulkan level, so we will skip those.
@@ -135,20 +124,20 @@ 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);
             VkDescriptorSetLayoutBinding vkBindingRangeDesc = {};
             vkBindingRangeDesc.binding =
                 offset.binding + (uint32_t)typeLayout->getDescriptorSetDescriptorRangeIndexOffset(
-                                     slangDescriptorSetIndex, descriptorRangeIndex);
+                                     slangDescriptorSetIndex,
+                                     descriptorRangeIndex);
             vkBindingRangeDesc.descriptorCount =
                 (uint32_t)typeLayout->getDescriptorSetDescriptorRangeDescriptorCount(
-                    slangDescriptorSetIndex, descriptorRangeIndex);
+                    slangDescriptorSetIndex,
+                    descriptorRangeIndex);
             vkBindingRangeDesc.descriptorType = vkDescriptorType;
             vkBindingRangeDesc.stageFlags = VK_SHADER_STAGE_ALL;
 
@@ -181,8 +170,7 @@ 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
@@ -221,7 +209,9 @@ void ShaderObjectLayoutImpl::Builder::_addDescriptorRangesAsValue(
                 elementOffset += BindingOffset(elementVarLayout);
 
                 _addDescriptorRangesAsConstantBuffer(
-                    elementTypeLayout, containerOffset, elementOffset);
+                    elementTypeLayout,
+                    containerOffset,
+                    elementOffset);
             }
             break;
 
@@ -252,7 +242,9 @@ void ShaderObjectLayoutImpl::Builder::_addDescriptorRangesAsValue(
                 elementOffset += BindingOffset(elementVarLayout);
 
                 _addDescriptorRangesAsPushConstantBuffer(
-                    elementTypeLayout, containerOffset, elementOffset);
+                    elementTypeLayout,
+                    containerOffset,
+                    elementOffset);
             }
             break;
         }
@@ -416,7 +408,8 @@ void ShaderObjectLayoutImpl::Builder::addBindingRanges(slang::TypeLayoutReflecti
 
             auto set = typeLayout->getDescriptorSetSpaceOffset(descriptorSetIndex);
             auto bindingOffset = typeLayout->getDescriptorSetDescriptorRangeIndexOffset(
-                descriptorSetIndex, descriptorRangeIndex);
+                descriptorSetIndex,
+                descriptorRangeIndex);
 
             bindingRangeInfo.setOffset = uint32_t(set);
             bindingRangeInfo.bindingOffset = uint32_t(bindingOffset);
@@ -449,7 +442,10 @@ void ShaderObjectLayoutImpl::Builder::addBindingRanges(slang::TypeLayoutReflecti
                 auto varLayout = slangLeafTypeLayout->getElementVarLayout();
                 auto subTypeLayout = varLayout->getTypeLayout();
                 ShaderObjectLayoutImpl::createForElementType(
-                    m_renderer, m_session, subTypeLayout, subObjectLayout.writeRef());
+                    m_renderer,
+                    m_session,
+                    subTypeLayout,
+                    subObjectLayout.writeRef());
             }
             break;
 
@@ -457,7 +453,10 @@ void ShaderObjectLayoutImpl::Builder::addBindingRanges(slang::TypeLayoutReflecti
             if (auto pendingTypeLayout = slangLeafTypeLayout->getPendingDataTypeLayout())
             {
                 ShaderObjectLayoutImpl::createForElementType(
-                    m_renderer, m_session, pendingTypeLayout, subObjectLayout.writeRef());
+                    m_renderer,
+                    m_session,
+                    pendingTypeLayout,
+                    subObjectLayout.writeRef());
             }
             break;
         }
@@ -509,8 +508,7 @@ void ShaderObjectLayoutImpl::Builder::addBindingRanges(slang::TypeLayoutReflecti
             }
             break;
 
-        default:
-            break;
+        default: break;
         }
 
         m_subObjectRanges.add(subObjectRange);
@@ -602,7 +600,9 @@ Result ShaderObjectLayoutImpl::createForElementType(
     // since that is how things will be laid out inside the parameter block.
     //
     builder._addDescriptorRangesAsConstantBuffer(
-        builder.m_elementTypeLayout, containerOffset, elementOffset);
+        builder.m_elementTypeLayout,
+        containerOffset,
+        elementOffset);
     return builder.build(outLayout);
 }
 
@@ -611,7 +611,9 @@ ShaderObjectLayoutImpl::~ShaderObjectLayoutImpl()
     for (auto& descSetInfo : m_descriptorSetInfos)
     {
         getDevice()->m_api.vkDestroyDescriptorSetLayout(
-            getDevice()->m_api.m_device, descSetInfo.descriptorSetLayout, nullptr);
+            getDevice()->m_api.m_device,
+            descSetInfo.descriptorSetLayout,
+            nullptr);
     }
 }
 
@@ -645,7 +647,10 @@ Result ShaderObjectLayoutImpl::_init(Builder const* builder)
         createInfo.bindingCount = (uint32_t)descriptorSetInfo.vkBindings.getCount();
         VkDescriptorSetLayout vkDescSetLayout;
         SLANG_RETURN_ON_FAIL(renderer->m_api.vkCreateDescriptorSetLayout(
-            renderer->m_api.m_device, &createInfo, nullptr, &vkDescSetLayout));
+            renderer->m_api.m_device,
+            &createInfo,
+            nullptr,
+            &vkDescSetLayout));
         descriptorSetInfo.descriptorSetLayout = vkDescSetLayout;
     }
     return SLANG_OK;
@@ -693,7 +698,9 @@ RootShaderObjectLayout::~RootShaderObjectLayout()
     if (m_pipelineLayout)
     {
         m_renderer->m_api.vkDestroyPipelineLayout(
-            m_renderer->m_api.m_device, m_pipelineLayout, nullptr);
+            m_renderer->m_api.m_device,
+            m_pipelineLayout,
+            nullptr);
     }
 }
 
@@ -790,7 +797,10 @@ Result RootShaderObjectLayout::_init(Builder const* builder)
         pipelineLayoutCreateInfo.pPushConstantRanges = m_allPushConstantRanges.getBuffer();
     }
     SLANG_RETURN_ON_FAIL(m_renderer->m_api.vkCreatePipelineLayout(
-        m_renderer->m_api.m_device, &pipelineLayoutCreateInfo, nullptr, &m_pipelineLayout));
+        m_renderer->m_api.m_device,
+        &pipelineLayoutCreateInfo,
+        nullptr,
+        &m_pipelineLayout));
     return SLANG_OK;
 }
 
diff --git a/tools/gfx/vulkan/vk-shader-object-layout.h b/tools/gfx/vulkan/vk-shader-object-layout.h
index 3f60e6b89..bc95097f8 100644
--- a/tools/gfx/vulkan/vk-shader-object-layout.h
+++ b/tools/gfx/vulkan/vk-shader-object-layout.h
@@ -136,7 +136,8 @@ public:
     public:
         Builder(DeviceImpl* renderer, slang::ISession* session)
             : m_renderer(renderer), m_session(session)
-        {}
+        {
+        }
 
         DeviceImpl* m_renderer;
         slang::ISession* m_session;
@@ -180,7 +181,8 @@ public:
         /// Add any descriptor ranges implied by this object containing a leaf
         /// sub-object described by `typeLayout`, at the given `offset`.
         void _addDescriptorRangesAsValue(
-            slang::TypeLayoutReflection* typeLayout, BindingOffset const& offset);
+            slang::TypeLayoutReflection* typeLayout,
+            BindingOffset const& offset);
 
         /// Add the descriptor ranges implied by a `ConstantBuffer<X>` where `X` is
         /// described by `elementTypeLayout`.
@@ -325,7 +327,8 @@ public:
     {
         Builder(DeviceImpl* device, slang::ISession* session)
             : Super::Builder(device, session)
-        {}
+        {
+        }
 
         Result build(EntryPointLayout** outLayout);
 
@@ -372,7 +375,8 @@ public:
             : Super::Builder(renderer, program->getSession())
             , m_program(program)
             , m_programLayout(programLayout)
-        {}
+        {
+        }
 
         Result build(RootShaderObjectLayout** outLayout);
 
diff --git a/tools/gfx/vulkan/vk-shader-object.cpp b/tools/gfx/vulkan/vk-shader-object.cpp
index 37edd8efa..862f6137a 100644
--- a/tools/gfx/vulkan/vk-shader-object.cpp
+++ b/tools/gfx/vulkan/vk-shader-object.cpp
@@ -14,7 +14,9 @@ namespace vk
 {
 
 Result ShaderObjectImpl::create(
-    IDevice* device, ShaderObjectLayoutImpl* layout, ShaderObjectImpl** outShaderObject)
+    IDevice* device,
+    ShaderObjectLayoutImpl* layout,
+    ShaderObjectImpl** outShaderObject)
 {
     auto object = RefPtr<ShaderObjectImpl>(new ShaderObjectImpl());
     SLANG_RETURN_ON_FAIL(object->init(device, layout));
@@ -23,9 +25,15 @@ Result ShaderObjectImpl::create(
     return SLANG_OK;
 }
 
-RendererBase* ShaderObjectImpl::getDevice() { return m_layout->getDevice(); }
+RendererBase* ShaderObjectImpl::getDevice()
+{
+    return m_layout->getDevice();
+}
 
-GfxCount ShaderObjectImpl::getEntryPointCount() { return 0; }
+GfxCount ShaderObjectImpl::getEntryPointCount()
+{
+    return 0;
+}
 
 Result ShaderObjectImpl::getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint)
 {
@@ -33,9 +41,15 @@ Result ShaderObjectImpl::getEntryPoint(GfxIndex index, IShaderObject** outEntryP
     return SLANG_OK;
 }
 
-const void* ShaderObjectImpl::getRawData() { return m_data.getBuffer(); }
+const void* ShaderObjectImpl::getRawData()
+{
+    return m_data.getBuffer();
+}
 
-Size ShaderObjectImpl::getSize() { return (Size)m_data.getCount(); }
+Size ShaderObjectImpl::getSize()
+{
+    return (Size)m_data.getCount();
+}
 
 // TODO: Change size_t and Index to Size?
 Result ShaderObjectImpl::setData(ShaderOffset const& inOffset, void const* data, size_t inSize)
@@ -110,7 +124,9 @@ Result ShaderObjectImpl::setSampler(ShaderOffset const& offset, ISamplerState* s
 }
 
 Result ShaderObjectImpl::setCombinedTextureSampler(
-    ShaderOffset const& offset, IResourceView* textureView, ISamplerState* sampler)
+    ShaderOffset const& offset,
+    IResourceView* textureView,
+    ISamplerState* sampler)
 {
     if (offset.bindingRangeIndex < 0)
         return SLANG_E_INVALID_ARG;
@@ -307,7 +323,8 @@ Result ShaderObjectImpl::_writeOrdinaryData(
 }
 
 void ShaderObjectImpl::writeDescriptor(
-    RootBindingContext& context, VkWriteDescriptorSet const& write)
+    RootBindingContext& context,
+    VkWriteDescriptorSet const& write)
 {
     auto device = context.device;
     device->m_api.vkUpdateDescriptorSets(device->m_device, 1, &write, 0, nullptr);
@@ -350,7 +367,12 @@ void ShaderObjectImpl::writeBufferDescriptor(
     BufferResourceImpl* buffer)
 {
     writeBufferDescriptor(
-        context, offset, descriptorType, buffer, 0, buffer->getDesc()->sizeInBytes);
+        context,
+        offset,
+        descriptorType,
+        buffer,
+        0,
+        buffer->getDesc()->sizeInBytes);
 }
 
 void ShaderObjectImpl::writePlainBufferDescriptor(
@@ -586,7 +608,8 @@ bool ShaderObjectImpl::shouldAllocateConstantBuffer(TransientResourceHeapImpl* t
 }
 
 Result ShaderObjectImpl::_ensureOrdinaryDataBufferCreatedIfNeeded(
-    PipelineCommandEncoder* encoder, ShaderObjectLayoutImpl* specializedLayout)
+    PipelineCommandEncoder* encoder,
+    ShaderObjectLayoutImpl* specializedLayout)
 {
     // If data has been changed since last allocation/filling of constant buffer,
     // we will need to allocate a new one.
@@ -609,7 +632,9 @@ Result ShaderObjectImpl::_ensureOrdinaryDataBufferCreatedIfNeeded(
     // it from the transient resource heap.
     //
     SLANG_RETURN_ON_FAIL(encoder->m_commandBuffer->m_transientHeap->allocateConstantBuffer(
-        m_constantBufferSize, m_constantBuffer, m_constantBufferOffset));
+        m_constantBufferSize,
+        m_constantBuffer,
+        m_constantBufferOffset));
 
     // Once the buffer is allocated, we can use `_writeOrdinaryData` to fill it in.
     //
@@ -647,8 +672,7 @@ 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;
@@ -727,8 +751,7 @@ 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");
@@ -824,8 +847,8 @@ Result ShaderObjectImpl::bindAsValue(
                     // already.
                     //
                     ShaderObjectImpl* subObject = m_objects[subObjectIndex + i];
-                    subObject->bindAsValue(
-                        encoder, context, BindingOffset(objOffset), subObjectLayout);
+                    subObject
+                        ->bindAsValue(encoder, context, BindingOffset(objOffset), subObjectLayout);
                     objOffset += objStride;
                 }
             }
@@ -987,7 +1010,9 @@ Result ShaderObjectImpl::_createSpecializedLayout(ShaderObjectLayoutImpl** outLa
 }
 
 Result EntryPointShaderObject::create(
-    IDevice* device, EntryPointLayout* layout, EntryPointShaderObject** outShaderObject)
+    IDevice* device,
+    EntryPointLayout* layout,
+    EntryPointShaderObject** outShaderObject)
 {
     RefPtr<EntryPointShaderObject> object = new EntryPointShaderObject();
     SLANG_RETURN_ON_FAIL(object->init(device, layout));
@@ -1080,7 +1105,10 @@ List<RefPtr<EntryPointShaderObject>> const& RootShaderObjectImpl::getEntryPoints
     return m_entryPoints;
 }
 
-GfxCount RootShaderObjectImpl::getEntryPointCount() { return (GfxCount)m_entryPoints.getCount(); }
+GfxCount RootShaderObjectImpl::getEntryPointCount()
+{
+    return (GfxCount)m_entryPoints.getCount();
+}
 
 Result RootShaderObjectImpl::getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint)
 {
@@ -1103,7 +1131,9 @@ Result RootShaderObjectImpl::copyFrom(IShaderObject* object, ITransientResourceH
 }
 
 Result RootShaderObjectImpl::bindAsRoot(
-    PipelineCommandEncoder* encoder, RootBindingContext& context, RootShaderObjectLayout* layout)
+    PipelineCommandEncoder* encoder,
+    RootBindingContext& context,
+    RootShaderObjectLayout* layout)
 {
     BindingOffset offset = {};
     offset.pending = layout->getPendingDataOffset();
@@ -1141,8 +1171,8 @@ Result RootShaderObjectImpl::bindAsRoot(
         // `RootShaderObjectLayout` has already baked any offsets
         // from the global layout into the `entryPointInfo`.
 
-        entryPoint->bindAsEntryPoint(
-            encoder, context, entryPointInfo.offset, entryPointInfo.layout);
+        entryPoint
+            ->bindAsEntryPoint(encoder, context, entryPointInfo.offset, entryPointInfo.layout);
     }
 
     return SLANG_OK;
diff --git a/tools/gfx/vulkan/vk-shader-object.h b/tools/gfx/vulkan/vk-shader-object.h
index efd8842cb..fafeb67f1 100644
--- a/tools/gfx/vulkan/vk-shader-object.h
+++ b/tools/gfx/vulkan/vk-shader-object.h
@@ -2,10 +2,10 @@
 #pragma once
 
 #include "vk-base.h"
+#include "vk-helper-functions.h"
 #include "vk-resource-views.h"
 #include "vk-sampler.h"
 #include "vk-shader-object-layout.h"
-#include "vk-helper-functions.h"
 
 namespace gfx
 {
@@ -27,14 +27,16 @@ class ShaderObjectImpl
 {
 public:
     static Result create(
-        IDevice* device, ShaderObjectLayoutImpl* layout, ShaderObjectImpl** outShaderObject);
+        IDevice* device,
+        ShaderObjectLayoutImpl* layout,
+        ShaderObjectImpl** outShaderObject);
 
     RendererBase* getDevice();
 
     virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override;
+    getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override;
 
     virtual SLANG_NO_THROW const void* SLANG_MCALL getRawData() override;
 
@@ -42,16 +44,18 @@ public:
 
     // TODO: Changed size_t to Size? inSize assigned to an Index variable inside implementation
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        setData(ShaderOffset const& inOffset, void const* data, size_t inSize) override;
+    setData(ShaderOffset const& inOffset, void const* data, size_t inSize) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        setResource(ShaderOffset const& offset, IResourceView* resourceView) override;
+    setResource(ShaderOffset const& offset, IResourceView* resourceView) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        setSampler(ShaderOffset const& offset, ISamplerState* sampler) override;
+    setSampler(ShaderOffset const& offset, ISamplerState* sampler) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL setCombinedTextureSampler(
-        ShaderOffset const& offset, IResourceView* textureView, ISamplerState* sampler) override;
+        ShaderOffset const& offset,
+        IResourceView* textureView,
+        ISamplerState* sampler) override;
 
 protected:
     friend class RootShaderObjectLayout;
@@ -125,7 +129,8 @@ public:
 
     /// Ensure that the `m_ordinaryDataBuffer` has been created, if it is needed
     Result _ensureOrdinaryDataBufferCreatedIfNeeded(
-        PipelineCommandEncoder* encoder, ShaderObjectLayoutImpl* specializedLayout);
+        PipelineCommandEncoder* encoder,
+        ShaderObjectLayoutImpl* specializedLayout);
 
 public:
     /// Bind this shader object as a "value"
@@ -211,7 +216,9 @@ class EntryPointShaderObject : public ShaderObjectImpl
 
 public:
     static Result create(
-        IDevice* device, EntryPointLayout* layout, EntryPointShaderObject** outShaderObject);
+        IDevice* device,
+        EntryPointLayout* layout,
+        EntryPointShaderObject** outShaderObject);
 
     EntryPointLayout* getLayout();
 
@@ -244,10 +251,11 @@ public:
     List<RefPtr<EntryPointShaderObject>> const& getEntryPoints() const;
 
     virtual GfxCount SLANG_MCALL getEntryPointCount() override;
-    virtual Result SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override;
+    virtual Result SLANG_MCALL
+    getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        copyFrom(IShaderObject* object, ITransientResourceHeap* transientHeap) override;
+    copyFrom(IShaderObject* object, ITransientResourceHeap* transientHeap) override;
 
     /// Bind this object as a root shader object
     Result bindAsRoot(
diff --git a/tools/gfx/vulkan/vk-shader-program.cpp b/tools/gfx/vulkan/vk-shader-program.cpp
index 4159561d1..43a295786 100644
--- a/tools/gfx/vulkan/vk-shader-program.cpp
+++ b/tools/gfx/vulkan/vk-shader-program.cpp
@@ -30,7 +30,10 @@ ShaderProgramImpl::~ShaderProgramImpl()
     }
 }
 
-void ShaderProgramImpl::comFree() { m_device.breakStrongReference(); }
+void ShaderProgramImpl::comFree()
+{
+    m_device.breakStrongReference();
+}
 
 VkPipelineShaderStageCreateInfo ShaderProgramImpl::compileEntryPoint(
     const char* entryPointName,
@@ -50,7 +53,10 @@ VkPipelineShaderStageCreateInfo ShaderProgramImpl::compileEntryPoint(
 
     VkShaderModule module;
     SLANG_VK_CHECK(m_device->m_api.vkCreateShaderModule(
-        m_device->m_device, &moduleCreateInfo, nullptr, &module));
+        m_device->m_device,
+        &moduleCreateInfo,
+        nullptr,
+        &module));
     outShaderModule = module;
 
     VkPipelineShaderStageCreateInfo shaderStageCreateInfo = {
@@ -64,7 +70,8 @@ VkPipelineShaderStageCreateInfo ShaderProgramImpl::compileEntryPoint(
 }
 
 Result ShaderProgramImpl::createShaderModule(
-    slang::EntryPointReflection* entryPointInfo, ComPtr<ISlangBlob> kernelCode)
+    slang::EntryPointReflection* entryPointInfo,
+    ComPtr<ISlangBlob> kernelCode)
 {
     m_codeBlobs.add(kernelCode);
     VkShaderModule shaderModule;
diff --git a/tools/gfx/vulkan/vk-shader-program.h b/tools/gfx/vulkan/vk-shader-program.h
index 49fd6d256..3fd56669a 100644
--- a/tools/gfx/vulkan/vk-shader-program.h
+++ b/tools/gfx/vulkan/vk-shader-program.h
@@ -36,7 +36,8 @@ public:
         VkShaderModule& outShaderModule);
 
     virtual Result createShaderModule(
-        slang::EntryPointReflection* entryPointInfo, ComPtr<ISlangBlob> kernelCode) override;
+        slang::EntryPointReflection* entryPointInfo,
+        ComPtr<ISlangBlob> kernelCode) override;
 };
 
 
diff --git a/tools/gfx/vulkan/vk-shader-table.cpp b/tools/gfx/vulkan/vk-shader-table.cpp
index beb826111..4d47a2b96 100644
--- a/tools/gfx/vulkan/vk-shader-table.cpp
+++ b/tools/gfx/vulkan/vk-shader-table.cpp
@@ -2,9 +2,8 @@
 #include "vk-shader-table.h"
 
 #include "vk-device.h"
-#include "vk-transient-heap.h"
-
 #include "vk-helper-functions.h"
+#include "vk-transient-heap.h"
 
 namespace gfx
 {
@@ -24,11 +23,14 @@ RefPtr<BufferResource> ShaderTableImpl::createDeviceBuffer(
     uint32_t handleSize = rtProps.shaderGroupHandleSize;
     m_raygenTableSize = m_rayGenShaderCount * rtProps.shaderGroupBaseAlignment;
     m_missTableSize = (uint32_t)VulkanUtil::calcAligned(
-        m_missShaderCount * handleSize, rtProps.shaderGroupBaseAlignment);
+        m_missShaderCount * handleSize,
+        rtProps.shaderGroupBaseAlignment);
     m_hitTableSize = (uint32_t)VulkanUtil::calcAligned(
-        m_hitGroupCount * handleSize, rtProps.shaderGroupBaseAlignment);
+        m_hitGroupCount * handleSize,
+        rtProps.shaderGroupBaseAlignment);
     m_callableTableSize = (uint32_t)VulkanUtil::calcAligned(
-        m_callableShaderCount * handleSize, rtProps.shaderGroupBaseAlignment);
+        m_callableShaderCount * handleSize,
+        rtProps.shaderGroupBaseAlignment);
     uint32_t tableSize = m_raygenTableSize + m_missTableSize + m_hitTableSize + m_callableTableSize;
 
     auto pipelineImpl = static_cast<RayTracingPipelineStateImpl*>(pipeline);
@@ -51,8 +53,8 @@ RefPtr<BufferResource> ShaderTableImpl::createDeviceBuffer(
 
     IBufferResource* stagingBuffer = nullptr;
     Offset stagingBufferOffset = 0;
-    transientHeapImpl->allocateStagingBuffer(
-        tableSize, stagingBuffer, stagingBufferOffset, MemoryType::Upload);
+    transientHeapImpl
+        ->allocateStagingBuffer(tableSize, stagingBuffer, stagingBufferOffset, MemoryType::Upload);
 
     assert(stagingBuffer);
     void* stagingPtr = nullptr;
diff --git a/tools/gfx/vulkan/vk-swap-chain.cpp b/tools/gfx/vulkan/vk-swap-chain.cpp
index 7580e01b3..4f9bd3ca2 100644
--- a/tools/gfx/vulkan/vk-swap-chain.cpp
+++ b/tools/gfx/vulkan/vk-swap-chain.cpp
@@ -1,8 +1,8 @@
 // vk-swap-chain.cpp
 #include "vk-swap-chain.h"
 
-#include "vk-util.h"
 #include "../apple/cocoa-util.h"
+#include "vk-util.h"
 
 namespace gfx
 {
@@ -44,7 +44,9 @@ void SwapchainImpl::getWindowSize(int* widthOut, int* heightOut) const
 #elif defined(SLANG_ENABLE_XLIB)
     XWindowAttributes winAttr = {};
     XGetWindowAttributes(
-        (Display*)m_windowHandle.handleValues[0], (Window)m_windowHandle.handleValues[1], &winAttr);
+        (Display*)m_windowHandle.handleValues[0],
+        (Window)m_windowHandle.handleValues[1],
+        &winAttr);
 
     *widthOut = winAttr.width;
     *heightOut = winAttr.height;
@@ -78,22 +80,32 @@ Result SwapchainImpl::createSwapchainAndImages()
         VkSurfaceCapabilitiesKHR surfaceCaps;
 
         SLANG_VK_RETURN_ON_FAIL(m_api->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-            m_api->m_physicalDevice, m_surface, &surfaceCaps));
+            m_api->m_physicalDevice,
+            m_surface,
+            &surfaceCaps));
     }
 
     VkPresentModeKHR presentMode;
     List<VkPresentModeKHR> presentModes;
     uint32_t numPresentModes = 0;
     m_api->vkGetPhysicalDeviceSurfacePresentModesKHR(
-        m_api->m_physicalDevice, m_surface, &numPresentModes, nullptr);
+        m_api->m_physicalDevice,
+        m_surface,
+        &numPresentModes,
+        nullptr);
     presentModes.setCount(numPresentModes);
     m_api->vkGetPhysicalDeviceSurfacePresentModesKHR(
-        m_api->m_physicalDevice, m_surface, &numPresentModes, presentModes.getBuffer());
+        m_api->m_physicalDevice,
+        m_surface,
+        &numPresentModes,
+        presentModes.getBuffer());
 
     {
         int numCheckPresentOptions = 3;
         VkPresentModeKHR presentOptions[] = {
-            VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR};
+            VK_PRESENT_MODE_IMMEDIATE_KHR,
+            VK_PRESENT_MODE_MAILBOX_KHR,
+            VK_PRESENT_MODE_FIFO_KHR};
         if (m_desc.enableVSync)
         {
             presentOptions[0] = VK_PRESENT_MODE_FIFO_KHR;
@@ -147,14 +159,19 @@ Result SwapchainImpl::createSwapchainAndImages()
     {
         vkImages.setCount(numSwapChainImages);
         m_api->vkGetSwapchainImagesKHR(
-            m_api->m_device, m_swapChain, &numSwapChainImages, vkImages.getBuffer());
+            m_api->m_device,
+            m_swapChain,
+            &numSwapChainImages,
+            vkImages.getBuffer());
     }
 
     for (GfxIndex i = 0; i < m_desc.imageCount; i++)
     {
         ITextureResource::Desc imageDesc = {};
         imageDesc.allowedStates = ResourceStateSet(
-            ResourceState::Present, ResourceState::RenderTarget, ResourceState::CopyDestination);
+            ResourceState::Present,
+            ResourceState::RenderTarget,
+            ResourceState::CopyDestination);
         imageDesc.type = IResource::Type::Texture2D;
         imageDesc.arraySize = 0;
         imageDesc.format = m_desc.format;
@@ -213,7 +230,10 @@ Result SwapchainImpl::init(DeviceImpl* renderer, const ISwapchain::Desc& desc, W
     VkSemaphoreCreateInfo semaphoreCreateInfo = {};
     semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
     SLANG_VK_RETURN_ON_FAIL(renderer->m_api.vkCreateSemaphore(
-        renderer->m_api.m_device, &semaphoreCreateInfo, nullptr, &m_nextImageSemaphore));
+        renderer->m_api.m_device,
+        &semaphoreCreateInfo,
+        nullptr,
+        &m_nextImageSemaphore));
 
     m_queue = static_cast<CommandQueueImpl*>(desc.queue);
 
@@ -247,15 +267,24 @@ Result SwapchainImpl::init(DeviceImpl* renderer, const ISwapchain::Desc& desc, W
 
     VkBool32 supported = false;
     m_api->vkGetPhysicalDeviceSurfaceSupportKHR(
-        m_api->m_physicalDevice, renderer->m_queueFamilyIndex, m_surface, &supported);
+        m_api->m_physicalDevice,
+        renderer->m_queueFamilyIndex,
+        m_surface,
+        &supported);
 
     uint32_t numSurfaceFormats = 0;
     List<VkSurfaceFormatKHR> surfaceFormats;
     m_api->vkGetPhysicalDeviceSurfaceFormatsKHR(
-        m_api->m_physicalDevice, m_surface, &numSurfaceFormats, nullptr);
+        m_api->m_physicalDevice,
+        m_surface,
+        &numSurfaceFormats,
+        nullptr);
     surfaceFormats.setCount(int(numSurfaceFormats));
     m_api->vkGetPhysicalDeviceSurfaceFormatsKHR(
-        m_api->m_physicalDevice, m_surface, &numSurfaceFormats, surfaceFormats.getBuffer());
+        m_api->m_physicalDevice,
+        m_surface,
+        &numSurfaceFormats,
+        surfaceFormats.getBuffer());
 
     // Look for a suitable format
     List<VkFormat> formats;
@@ -360,8 +389,7 @@ int SwapchainImpl::acquireNextImage()
         VK_NULL_HANDLE,
         (uint32_t*)&m_currentImageIndex);
 
-    if (
-        result != VK_SUCCESS
+    if (result != VK_SUCCESS
 #if SLANG_APPLE_FAMILY
         && result != VK_SUBOPTIMAL_KHR
 #endif
@@ -376,7 +404,10 @@ int SwapchainImpl::acquireNextImage()
     return m_currentImageIndex;
 }
 
-Result SwapchainImpl::setFullScreenMode(bool mode) { return SLANG_FAIL; }
+Result SwapchainImpl::setFullScreenMode(bool mode)
+{
+    return SLANG_FAIL;
+}
 
 } // namespace vk
 } // namespace gfx
diff --git a/tools/gfx/vulkan/vk-swap-chain.h b/tools/gfx/vulkan/vk-swap-chain.h
index 50878cd7b..166140cce 100644
--- a/tools/gfx/vulkan/vk-swap-chain.h
+++ b/tools/gfx/vulkan/vk-swap-chain.h
@@ -14,9 +14,7 @@ using namespace Slang;
 namespace vk
 {
 
-class SwapchainImpl
-    : public ISwapchain
-    , public ComObject
+class SwapchainImpl : public ISwapchain, public ComObject
 {
 public:
     SLANG_COM_OBJECT_IUNKNOWN_ALL
@@ -53,7 +51,7 @@ public:
 
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override { return m_desc; }
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getImage(GfxIndex index, ITextureResource** outResource) override;
+    getImage(GfxIndex index, ITextureResource** outResource) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL present() override;
     virtual SLANG_NO_THROW int SLANG_MCALL acquireNextImage() override;
diff --git a/tools/gfx/vulkan/vk-texture.cpp b/tools/gfx/vulkan/vk-texture.cpp
index 13775cef0..ea305c1a1 100644
--- a/tools/gfx/vulkan/vk-texture.cpp
+++ b/tools/gfx/vulkan/vk-texture.cpp
@@ -10,9 +10,9 @@ namespace vk
 {
 
 TextureResourceImpl::TextureResourceImpl(const Desc& desc, DeviceImpl* device)
-    : Parent(desc)
-    , m_device(device)
-{}
+    : Parent(desc), m_device(device)
+{
+}
 
 TextureResourceImpl::~TextureResourceImpl()
 {
diff --git a/tools/gfx/vulkan/vk-texture.h b/tools/gfx/vulkan/vk-texture.h
index 95e3b779e..58ef420fe 100644
--- a/tools/gfx/vulkan/vk-texture.h
+++ b/tools/gfx/vulkan/vk-texture.h
@@ -26,7 +26,7 @@ public:
     RefPtr<DeviceImpl> m_device;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getNativeResourceHandle(InteropHandle* outHandle) override;
+    getNativeResourceHandle(InteropHandle* outHandle) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL getSharedHandle(InteropHandle* outHandle) override;
 
diff --git a/tools/gfx/vulkan/vk-transient-heap.cpp b/tools/gfx/vulkan/vk-transient-heap.cpp
index fa4eb718b..afc062d0f 100644
--- a/tools/gfx/vulkan/vk-transient-heap.cpp
+++ b/tools/gfx/vulkan/vk-transient-heap.cpp
@@ -22,7 +22,10 @@ void TransientResourceHeapImpl::advanceFence()
         fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
         fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
         m_device->m_api.vkCreateFence(
-            m_device->m_api.m_device, &fenceCreateInfo, nullptr, &m_fences[m_fenceIndex]);
+            m_device->m_api.m_device,
+            &fenceCreateInfo,
+            nullptr,
+            &m_fences[m_fenceIndex]);
     }
 }
 
@@ -40,8 +43,8 @@ Result TransientResourceHeapImpl::init(const ITransientResourceHeap::Desc& desc,
     poolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
     poolCreateInfo.queueFamilyIndex =
         device->getQueueFamilyIndex(ICommandQueue::QueueType::Graphics);
-    device->m_api.vkCreateCommandPool(
-        device->m_api.m_device, &poolCreateInfo, nullptr, &m_commandPool);
+    device->m_api
+        .vkCreateCommandPool(device->m_api.m_device, &poolCreateInfo, nullptr, &m_commandPool);
 
     advanceFence();
     return SLANG_OK;
@@ -83,8 +86,11 @@ Result TransientResourceHeapImpl::synchronizeAndReset()
     m_commandBufferAllocId = 0;
     auto& api = m_device->m_api;
     if (api.vkWaitForFences(
-            api.m_device, (uint32_t)m_fences.getCount(), m_fences.getBuffer(), 1, UINT64_MAX) !=
-        VK_SUCCESS)
+            api.m_device,
+            (uint32_t)m_fences.getCount(),
+            m_fences.getBuffer(),
+            1,
+            UINT64_MAX) != VK_SUCCESS)
     {
         return SLANG_FAIL;
     }
diff --git a/tools/gfx/vulkan/vk-transient-heap.h b/tools/gfx/vulkan/vk-transient-heap.h
index e41d760f2..8a0f7a74d 100644
--- a/tools/gfx/vulkan/vk-transient-heap.h
+++ b/tools/gfx/vulkan/vk-transient-heap.h
@@ -34,7 +34,7 @@ public:
 
 public:
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createCommandBuffer(ICommandBuffer** outCommandBuffer) override;
+    createCommandBuffer(ICommandBuffer** outCommandBuffer) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL synchronizeAndReset() override;
 };
 
diff --git a/tools/gfx/vulkan/vk-util.cpp b/tools/gfx/vulkan/vk-util.cpp
index 1a571c812..696e80fc7 100644
--- a/tools/gfx/vulkan/vk-util.cpp
+++ b/tools/gfx/vulkan/vk-util.cpp
@@ -1,121 +1,123 @@
 // vk-util.cpp
 #include "vk-util.h"
+
 #include "core/slang-math.h"
 
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 
-namespace gfx {
+namespace gfx
+{
 
-/* static */VkFormat VulkanUtil::getVkFormat(Format format)
+/* static */ VkFormat VulkanUtil::getVkFormat(Format format)
 {
     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;
     }
 }
 
@@ -132,38 +134,26 @@ 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;
     }
 }
 
-/* static */SlangResult VulkanUtil::toSlangResult(VkResult res)
+/* static */ SlangResult VulkanUtil::toSlangResult(VkResult res)
 {
     return (res == VK_SUCCESS) ? SLANG_OK : SLANG_FAIL;
 }
@@ -172,37 +162,21 @@ 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);
     }
 }
 
@@ -212,29 +186,18 @@ 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();
 }
@@ -243,23 +206,14 @@ 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;
     }
 }
 
@@ -267,15 +221,10 @@ 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;
     }
 }
 
@@ -283,13 +232,9 @@ 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;
     }
 }
 
@@ -297,13 +242,9 @@ 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;
     }
 }
 
@@ -311,44 +252,25 @@ 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;
     }
 }
 
@@ -356,38 +278,24 @@ 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;
     }
 }
 
-VkPrimitiveTopology VulkanUtil::translatePrimitiveTypeToListTopology(
-    PrimitiveType primitiveType)
+VkPrimitiveTopology VulkanUtil::translatePrimitiveTypeToListTopology(PrimitiveType primitiveType)
 {
     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;
     }
 }
 
@@ -395,24 +303,15 @@ 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;
     }
 }
 
@@ -420,12 +319,10 @@ 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);
@@ -438,12 +335,10 @@ 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);
@@ -456,12 +351,10 @@ 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);
@@ -481,9 +374,8 @@ 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);
@@ -514,16 +406,13 @@ 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;
     }
 }
 
-/* static */Slang::Result VulkanUtil::handleFail(VkResult res)
+/* static */ Slang::Result VulkanUtil::handleFail(VkResult res)
 {
     if (res != VK_SUCCESS)
     {
@@ -532,29 +421,22 @@ VkSamplerReductionMode VulkanUtil::translateReductionOp(TextureReductionOp op)
     return toSlangResult(res);
 }
 
-/* static */void VulkanUtil::checkFail(VkResult res)
+/* static */ void VulkanUtil::checkFail(VkResult res)
 {
     assert(res != VK_SUCCESS);
     assert(!"Vulkan check failed");
-
 }
 
-/* static */VkPrimitiveTopology VulkanUtil::getVkPrimitiveTopology(PrimitiveTopology topology)
+/* static */ VkPrimitiveTopology VulkanUtil::getVkPrimitiveTopology(PrimitiveTopology topology)
 {
     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;
@@ -564,32 +446,20 @@ 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;
     }
 }
 
@@ -676,12 +546,8 @@ 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 ade62ba59..a22c76fc3 100644
--- a/tools/gfx/vulkan/vk-util.h
+++ b/tools/gfx/vulkan/vk-util.h
@@ -2,44 +2,69 @@
 #pragma once
 
 #include "core/slang-basic.h"
-#include "vk-api.h"
 #include "slang-gfx.h"
+#include "vk-api.h"
 
 // Macros to make testing vulkan return codes simpler
 
-/// SLANG_VK_RETURN_ON_FAIL can be used in a similar way to SLANG_RETURN_ON_FAIL macro, except it will turn a vulkan failure into Slang::Result in the process
-/// Calls handleFail which on debug builds asserts
-#define SLANG_VK_RETURN_ON_FAIL(x) { VkResult _res = x; if (_res != VK_SUCCESS) { return VulkanUtil::handleFail(_res); }  }
+/// SLANG_VK_RETURN_ON_FAIL can be used in a similar way to SLANG_RETURN_ON_FAIL macro, except it
+/// will turn a vulkan failure into Slang::Result in the process Calls handleFail which on debug
+/// builds asserts
+#define SLANG_VK_RETURN_ON_FAIL(x)               \
+    {                                            \
+        VkResult _res = x;                       \
+        if (_res != VK_SUCCESS)                  \
+        {                                        \
+            return VulkanUtil::handleFail(_res); \
+        }                                        \
+    }
 
-#define SLANG_VK_RETURN_NULL_ON_FAIL(x) { VkResult _res = x; if (_res != VK_SUCCESS) { VulkanUtil::handleFail(_res); return nullptr; }  }
+#define SLANG_VK_RETURN_NULL_ON_FAIL(x)   \
+    {                                     \
+        VkResult _res = x;                \
+        if (_res != VK_SUCCESS)           \
+        {                                 \
+            VulkanUtil::handleFail(_res); \
+            return nullptr;               \
+        }                                 \
+    }
 
-/// Is similar to SLANG_VK_RETURN_ON_FAIL, but does not return. Will call checkFail on failure - which asserts on debug builds.
-#define SLANG_VK_CHECK(x) {  VkResult _res = x; if (_res != VK_SUCCESS) { VulkanUtil::checkFail(_res); }  }
+/// Is similar to SLANG_VK_RETURN_ON_FAIL, but does not return. Will call checkFail on failure -
+/// which asserts on debug builds.
+#define SLANG_VK_CHECK(x)                \
+    {                                    \
+        VkResult _res = x;               \
+        if (_res != VK_SUCCESS)          \
+        {                                \
+            VulkanUtil::checkFail(_res); \
+        }                                \
+    }
 
-namespace gfx {
+namespace gfx
+{
 
 // Utility functions for Vulkan
 struct VulkanUtil
 {
-        /// Get the equivalent VkFormat from the format
-        /// Returns VK_FORMAT_UNDEFINED if a match is not found
+    /// Get the equivalent VkFormat from the format
+    /// Returns VK_FORMAT_UNDEFINED if a match is not found
     static VkFormat getVkFormat(Format format);
 
     static VkImageAspectFlags getAspectMask(TextureAspect aspect, VkFormat format);
 
-        /// Called by SLANG_VK_RETURN_FAIL if a res is a failure.
-        /// On debug builds this will cause an assertion on failure.
+    /// Called by SLANG_VK_RETURN_FAIL if a res is a failure.
+    /// On debug builds this will cause an assertion on failure.
     static Slang::Result handleFail(VkResult res);
-        /// Called when a failure has occurred with SLANG_VK_CHECK - will typically assert.
+    /// Called when a failure has occurred with SLANG_VK_CHECK - will typically assert.
     static void checkFail(VkResult res);
 
-        /// Get the VkPrimitiveTopology for the given topology.
-        /// Returns VK_PRIMITIVE_TOPOLOGY_MAX_ENUM on failure
+    /// Get the VkPrimitiveTopology for the given topology.
+    /// Returns VK_PRIMITIVE_TOPOLOGY_MAX_ENUM on failure
     static VkPrimitiveTopology getVkPrimitiveTopology(PrimitiveTopology topology);
 
     static VkImageLayout mapResourceStateToLayout(ResourceState state);
 
-        /// Returns Slang::Result equivalent of a VkResult
+    /// Returns Slang::Result equivalent of a VkResult
     static Slang::Result toSlangResult(VkResult res);
 
     static VkShaderStageFlags getShaderStage(SlangStage stage);
@@ -47,7 +72,10 @@ struct VulkanUtil
     static VkImageLayout getImageLayoutFromState(ResourceState state);
 
     /// Calculate size taking into account alignment. Alignment must be a power of 2
-    static UInt calcAligned(UInt size, UInt alignment) { return (size + alignment - 1) & ~(alignment - 1); }
+    static UInt calcAligned(UInt size, UInt alignment)
+    {
+        return (size + alignment - 1) & ~(alignment - 1);
+    }
 
     static inline bool isDepthFormat(VkFormat format)
     {
@@ -57,8 +85,7 @@ 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;
     }
@@ -69,8 +96,7 @@ 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;
     }
@@ -87,11 +113,10 @@ struct VulkanUtil
 
     static VkBlendOp translateBlendOp(BlendOp op);
 
-    static VkPrimitiveTopology translatePrimitiveTypeToListTopology(
-        PrimitiveType primitiveType);
+    static VkPrimitiveTopology translatePrimitiveTypeToListTopology(PrimitiveType primitiveType);
 
     static VkStencilOp translateStencilOp(StencilOp op);
-    
+
     static VkFilter translateFilterMode(TextureFilteringMode mode);
 
     static VkSamplerMipmapMode translateMipFilterMode(TextureFilteringMode mode);
@@ -103,7 +128,6 @@ struct VulkanUtil
     static VkStencilOpState translateStencilState(DepthStencilOpDesc desc);
 
     static VkSamplerReductionMode translateReductionOp(TextureReductionOp op);
-
 };
 
 struct AccelerationStructureBuildGeometryInfoBuilder
@@ -124,4 +148,4 @@ private:
 };
 
 
-} // renderer_test
+} // namespace gfx