format

* format

* Minor test fixes

* enable checking cpp format in ci

41 files changed, 1071 insertions, 888 deletions

diff --git a/tools/gfx/metal/metal-api.cpp b/tools/gfx/metal/metal-api.cpp
index aa13a605f..8537cc630 100644
--- a/tools/gfx/metal/metal-api.cpp
+++ b/tools/gfx/metal/metal-api.cpp
@@ -4,5 +4,5 @@
 #define CA_PRIVATE_IMPLEMENTATION
 #define MTL_PRIVATE_IMPLEMENTATION
 #include <Foundation/Foundation.hpp>
-#include <QuartzCore/QuartzCore.hpp>
 #include <Metal/Metal.hpp>
+#include <QuartzCore/QuartzCore.hpp>
diff --git a/tools/gfx/metal/metal-base.h b/tools/gfx/metal/metal-base.h
index b1650a655..1a7a9eaff 100644
--- a/tools/gfx/metal/metal-base.h
+++ b/tools/gfx/metal/metal-base.h
@@ -14,41 +14,41 @@ namespace gfx
 namespace metal
 {
 
-    class DeviceImpl;
-    class InputLayoutImpl;
-    class BufferResourceImpl;
-    class FenceImpl;
-    class TextureResourceImpl;
-    class SamplerStateImpl;
-    class ResourceViewImpl;
-    class BufferResourceViewImpl;
-    class TextureResourceViewImpl;
-    class TexelBufferResourceViewImpl;
-    class PlainBufferResourceViewImpl;
-    class AccelerationStructureImpl;
-    class FramebufferLayoutImpl;
-    class RenderPassLayoutImpl;
-    class FramebufferImpl;
-    class PipelineStateImpl;
-    class RayTracingPipelineStateImpl;
-    class ShaderObjectLayoutImpl;
-    class EntryPointLayout;
-    class RootShaderObjectLayoutImpl;
-    class ShaderProgramImpl;
-    class PipelineCommandEncoder;
-    class ShaderObjectImpl;
-    class MutableShaderObjectImpl;
-    class RootShaderObjectImpl;
-    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 BufferResourceViewImpl;
+class TextureResourceViewImpl;
+class TexelBufferResourceViewImpl;
+class PlainBufferResourceViewImpl;
+class AccelerationStructureImpl;
+class FramebufferLayoutImpl;
+class RenderPassLayoutImpl;
+class FramebufferImpl;
+class PipelineStateImpl;
+class RayTracingPipelineStateImpl;
+class ShaderObjectLayoutImpl;
+class EntryPointLayout;
+class RootShaderObjectLayoutImpl;
+class ShaderProgramImpl;
+class PipelineCommandEncoder;
+class ShaderObjectImpl;
+class MutableShaderObjectImpl;
+class RootShaderObjectImpl;
+class ShaderTableImpl;
+class ResourceCommandEncoder;
+class RenderCommandEncoder;
+class ComputeCommandEncoder;
+class RayTracingCommandEncoder;
+class CommandBufferImpl;
+class CommandQueueImpl;
+class TransientResourceHeapImpl;
+class QueryPoolImpl;
+class SwapchainImpl;
 
 } // namespace metal
 } // namespace gfx
diff --git a/tools/gfx/metal/metal-buffer.cpp b/tools/gfx/metal/metal-buffer.cpp
index 4f2964c5b..ebb48382e 100644
--- a/tools/gfx/metal/metal-buffer.cpp
+++ b/tools/gfx/metal/metal-buffer.cpp
@@ -1,5 +1,6 @@
 // metal-buffer.cpp
 #include "metal-buffer.h"
+
 #include "metal-util.h"
 
 namespace gfx
@@ -11,14 +12,11 @@ namespace metal
 {
 
 BufferResourceImpl::BufferResourceImpl(const IBufferResource::Desc& desc, DeviceImpl* device)
-    : Parent(desc)
-    , m_device(device)
+    : Parent(desc), m_device(device)
 {
 }
 
-BufferResourceImpl::~BufferResourceImpl()
-{
-}
+BufferResourceImpl::~BufferResourceImpl() {}
 
 DeviceAddress BufferResourceImpl::getDeviceAddress()
 {
diff --git a/tools/gfx/metal/metal-buffer.h b/tools/gfx/metal/metal-buffer.h
index 3f8f60d0e..d8e95c1f1 100644
--- a/tools/gfx/metal/metal-buffer.h
+++ b/tools/gfx/metal/metal-buffer.h
@@ -25,11 +25,13 @@ public:
 
     virtual SLANG_NO_THROW DeviceAddress SLANG_MCALL getDeviceAddress() override;
 
-    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeResourceHandle(InteropHandle* outHandle) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+    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;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+    map(MemoryRange* rangeToRead, void** outPointer) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL unmap(MemoryRange* writtenRange) override;
 
diff --git a/tools/gfx/metal/metal-command-buffer.cpp b/tools/gfx/metal/metal-command-buffer.cpp
index 3f9923bf8..19708cfb6 100644
--- a/tools/gfx/metal/metal-command-buffer.cpp
+++ b/tools/gfx/metal/metal-command-buffer.cpp
@@ -1,10 +1,10 @@
 // metal-command-buffer.cpp
 #include "metal-command-buffer.h"
 
-#include "metal-device.h"
 #include "metal-command-encoder.h"
-#include "metal-shader-object.h"
 #include "metal-command-queue.h"
+#include "metal-device.h"
+#include "metal-shader-object.h"
 
 namespace gfx
 {
@@ -29,7 +29,9 @@ Result CommandBufferImpl::init(DeviceImpl* device, TransientResourceHeapImpl* tr
 }
 
 void CommandBufferImpl::encodeRenderCommands(
-    IRenderPassLayout* renderPass, IFramebuffer* framebuffer, IRenderCommandEncoder** outEncoder)
+    IRenderPassLayout* renderPass,
+    IFramebuffer* framebuffer,
+    IRenderCommandEncoder** outEncoder)
 {
     if (!m_renderCommandEncoder)
     {
@@ -72,7 +74,7 @@ void CommandBufferImpl::encodeRayTracingCommands(IRayTracingCommandEncoder** out
 
 void CommandBufferImpl::close()
 {
-    //m_commandBuffer->commit();
+    // m_commandBuffer->commit();
 }
 
 Result CommandBufferImpl::getNativeHandle(InteropHandle* outHandle)
@@ -82,12 +84,14 @@ Result CommandBufferImpl::getNativeHandle(InteropHandle* outHandle)
     return SLANG_OK;
 }
 
-MTL::RenderCommandEncoder* CommandBufferImpl::getMetalRenderCommandEncoder(MTL::RenderPassDescriptor* renderPassDesc)
+MTL::RenderCommandEncoder* CommandBufferImpl::getMetalRenderCommandEncoder(
+    MTL::RenderPassDescriptor* renderPassDesc)
 {
     if (!m_metalRenderCommandEncoder)
     {
         endMetalCommandEncoder();
-        m_metalRenderCommandEncoder = NS::RetainPtr(m_commandBuffer->renderCommandEncoder(renderPassDesc));
+        m_metalRenderCommandEncoder =
+            NS::RetainPtr(m_commandBuffer->renderCommandEncoder(renderPassDesc));
     }
     return m_metalRenderCommandEncoder.get();
 }
diff --git a/tools/gfx/metal/metal-command-buffer.h b/tools/gfx/metal/metal-command-buffer.h
index f0b36898d..1f791d174 100644
--- a/tools/gfx/metal/metal-command-buffer.h
+++ b/tools/gfx/metal/metal-command-buffer.h
@@ -1,10 +1,10 @@
 // metal-command-buffer.h
 #pragma once
 
+#include "../simple-transient-resource-heap.h"
 #include "metal-base.h"
-#include "metal-shader-object.h"
 #include "metal-command-encoder.h"
-#include "../simple-transient-resource-heap.h"
+#include "metal-shader-object.h"
 
 namespace gfx
 {
@@ -14,9 +14,7 @@ using namespace Slang;
 namespace metal
 {
 
-class CommandBufferImpl
-    : public ICommandBuffer
-    , public ComObject
+class CommandBufferImpl : public ICommandBuffer, public ComObject
 {
 public:
     SLANG_COM_OBJECT_IUNKNOWN_ALL
@@ -45,7 +43,8 @@ public:
 
     void beginCommandBuffer();
 
-    MTL::RenderCommandEncoder* getMetalRenderCommandEncoder(MTL::RenderPassDescriptor* renderPassDesc);
+    MTL::RenderCommandEncoder* getMetalRenderCommandEncoder(
+        MTL::RenderPassDescriptor* renderPassDesc);
     MTL::ComputeCommandEncoder* getMetalComputeCommandEncoder();
     MTL::BlitCommandEncoder* getMetalBlitCommandEncoder();
     void endMetalCommandEncoder();
@@ -56,11 +55,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/metal/metal-command-encoder.cpp b/tools/gfx/metal/metal-command-encoder.cpp
index 442c216aa..f4c393193 100644
--- a/tools/gfx/metal/metal-command-encoder.cpp
+++ b/tools/gfx/metal/metal-command-encoder.cpp
@@ -3,6 +3,7 @@
 
 #include "metal-buffer.h"
 #include "metal-command-buffer.h"
+#include "metal-helper-functions.h"
 #include "metal-query.h"
 #include "metal-render-pass.h"
 #include "metal-resource-views.h"
@@ -12,8 +13,6 @@
 #include "metal-texture.h"
 #include "metal-util.h"
 
-#include "metal-helper-functions.h"
-
 namespace gfx
 {
 
@@ -33,7 +32,9 @@ void PipelineCommandEncoder::endEncodingImpl()
     m_commandBuffer->endMetalCommandEncoder();
 }
 
-Result PipelineCommandEncoder::setPipelineStateImpl(IPipelineState* state, IShaderObject** outRootObject)
+Result PipelineCommandEncoder::setPipelineStateImpl(
+    IPipelineState* state,
+    IShaderObject** outRootObject)
 {
     m_currentPipeline = static_cast<PipelineStateImpl*>(state);
     // m_commandBuffer->m_mutableRootShaderObject = nullptr;
@@ -52,11 +53,18 @@ void ResourceCommandEncoder::endEncoding()
 void ResourceCommandEncoder::writeTimestamp(IQueryPool* queryPool, GfxIndex index)
 {
     auto encoder = m_commandBuffer->getMetalBlitCommandEncoder();
-    encoder->sampleCountersInBuffer(static_cast<QueryPoolImpl*>(queryPool)->m_counterSampleBuffer.get(), index, true);
+    encoder->sampleCountersInBuffer(
+        static_cast<QueryPoolImpl*>(queryPool)->m_counterSampleBuffer.get(),
+        index,
+        true);
 }
 
 void ResourceCommandEncoder::copyBuffer(
-    IBufferResource* dst, Offset dstOffset, IBufferResource* src, Offset srcOffset, Size size)
+    IBufferResource* dst,
+    Offset dstOffset,
+    IBufferResource* src,
+    Offset srcOffset,
+    Size size)
 {
     auto encoder = m_commandBuffer->getMetalBlitCommandEncoder();
     encoder->copyFromBuffer(
@@ -80,7 +88,8 @@ void ResourceCommandEncoder::copyTexture(
 {
     auto encoder = m_commandBuffer->getMetalBlitCommandEncoder();
 
-    if (dstSubresource.layerCount == 0 && dstSubresource.mipLevelCount == 0 && srcSubresource.layerCount == 0 && srcSubresource.mipLevelCount == 0)
+    if (dstSubresource.layerCount == 0 && dstSubresource.mipLevelCount == 0 &&
+        srcSubresource.layerCount == 0 && srcSubresource.mipLevelCount == 0)
     {
         encoder->copyFromTexture(
             static_cast<TextureResourceImpl*>(src)->m_texture.get(),
@@ -131,7 +140,10 @@ void ResourceCommandEncoder::copyTextureToBuffer(
 }
 
 void ResourceCommandEncoder::uploadBufferData(
-    IBufferResource* buffer, Offset offset, Size size, void* data)
+    IBufferResource* buffer,
+    Offset offset,
+    Size size,
+    void* data)
 {
     SLANG_UNIMPLEMENTED_X("uploadBufferData");
 }
@@ -148,13 +160,19 @@ void ResourceCommandEncoder::uploadTextureData(
 }
 
 void ResourceCommandEncoder::bufferBarrier(
-    GfxCount count, IBufferResource* const* buffers, ResourceState src, ResourceState dst)
+    GfxCount count,
+    IBufferResource* const* buffers,
+    ResourceState src,
+    ResourceState dst)
 {
     // We use automatic hazard tracking for now, no need for barriers.
 }
 
 void ResourceCommandEncoder::textureBarrier(
-    GfxCount count, ITextureResource* const* textures, ResourceState src, ResourceState dst)
+    GfxCount count,
+    ITextureResource* const* textures,
+    ResourceState src,
+    ResourceState dst)
 {
     // We use automatic hazard tracking for now, no need for barriers.
 }
@@ -169,7 +187,9 @@ void ResourceCommandEncoder::textureSubresourceBarrier(
 }
 
 void ResourceCommandEncoder::clearResourceView(
-    IResourceView* view, ClearValue* clearValue, ClearResourceViewFlags::Enum flags)
+    IResourceView* view,
+    ClearValue* clearValue,
+    ClearResourceViewFlags::Enum flags)
 {
     SLANG_UNIMPLEMENTED_X("clearResourceView");
 }
@@ -186,7 +206,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 encoder = m_commandBuffer->getMetalBlitCommandEncoder();
     encoder->resolveCounters(
@@ -226,7 +250,8 @@ void RenderCommandEncoder::beginPass(IRenderPassLayout* renderPass, IFramebuffer
     for (Index i = 0; i < m_framebuffer->m_renderTargetViews.getCount(); ++i)
     {
         TextureResourceViewImpl* renderTargetView = m_framebuffer->m_renderTargetViews[i];
-        MTL::RenderPassColorAttachmentDescriptor* colorAttachment = m_renderPassDesc->colorAttachments()->object(i);
+        MTL::RenderPassColorAttachmentDescriptor* colorAttachment =
+            m_renderPassDesc->colorAttachments()->object(i);
         colorAttachment->setTexture(renderTargetView->m_textureView.get());
         colorAttachment->setLevel(renderTargetView->m_desc.subresourceRange.mipLevel);
         colorAttachment->setSlice(renderTargetView->m_desc.subresourceRange.baseArrayLayer);
@@ -235,17 +260,20 @@ void RenderCommandEncoder::beginPass(IRenderPassLayout* renderPass, IFramebuffer
     if (m_framebuffer->m_depthStencilView)
     {
         TextureResourceViewImpl* depthStencilView = m_framebuffer->m_depthStencilView.get();
-        MTL::PixelFormat pixelFormat = MetalUtil::translatePixelFormat(depthStencilView->m_desc.format);
+        MTL::PixelFormat pixelFormat =
+            MetalUtil::translatePixelFormat(depthStencilView->m_desc.format);
         if (MetalUtil::isDepthFormat(pixelFormat))
         {
-            MTL::RenderPassDepthAttachmentDescriptor* depthAttachment = m_renderPassDesc->depthAttachment();
+            MTL::RenderPassDepthAttachmentDescriptor* depthAttachment =
+                m_renderPassDesc->depthAttachment();
             depthAttachment->setTexture(depthStencilView->m_textureView.get());
             depthAttachment->setLevel(depthStencilView->m_desc.subresourceRange.mipLevel);
             depthAttachment->setSlice(depthStencilView->m_desc.subresourceRange.baseArrayLayer);
         }
         if (MetalUtil::isStencilFormat(pixelFormat))
         {
-            MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment = m_renderPassDesc->stencilAttachment();
+            MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment =
+                m_renderPassDesc->stencilAttachment();
             stencilAttachment->setTexture(depthStencilView->m_textureView.get());
             stencilAttachment->setLevel(depthStencilView->m_desc.subresourceRange.mipLevel);
             stencilAttachment->setSlice(depthStencilView->m_desc.subresourceRange.baseArrayLayer);
@@ -259,13 +287,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 SLANG_E_NOT_IMPLEMENTED;
 }
@@ -324,21 +354,18 @@ void RenderCommandEncoder::setVertexBuffers(
 }
 
 void RenderCommandEncoder::setIndexBuffer(
-    IBufferResource* buffer, Format indexFormat, Offset offset)
+    IBufferResource* buffer,
+    Format indexFormat,
+    Offset offset)
 {
     m_indexBuffer = static_cast<BufferResourceImpl*>(buffer)->m_buffer.get();
     m_indexBufferOffset = offset;
 
     switch (indexFormat)
     {
-    case Format::R16_UINT:
-        m_indexBufferType = MTL::IndexTypeUInt16;
-        break;
-    case Format::R32_UINT:
-        m_indexBufferType = MTL::IndexTypeUInt32;
-        break;
-    default:
-        assert(!"unsupported index format");
+    case Format::R16_UINT: m_indexBufferType = MTL::IndexTypeUInt16; break;
+    case Format::R32_UINT: m_indexBufferType = MTL::IndexTypeUInt32; break;
+    default:               assert(!"unsupported index format");
     }
 }
 
@@ -348,7 +375,9 @@ void RenderCommandEncoder::setStencilReference(uint32_t referenceValue)
 }
 
 Result RenderCommandEncoder::setSamplePositions(
-    GfxCount samplesPerPixel, GfxCount pixelCount, const SamplePosition* samplePositions)
+    GfxCount samplesPerPixel,
+    GfxCount pixelCount,
+    const SamplePosition* samplePositions)
 {
     return SLANG_E_NOT_AVAILABLE;
 }
@@ -368,7 +397,10 @@ Result RenderCommandEncoder::prepareDraw(MTL::RenderCommandEncoder*& encoder)
 
     for (Index i = 0; i < m_vertexBuffers.getCount(); ++i)
     {
-        encoder->setVertexBuffer(m_vertexBuffers[i], m_vertexBufferOffsets[i], m_currentPipeline->m_vertexBufferOffset + i);
+        encoder->setVertexBuffer(
+            m_vertexBuffers[i],
+            m_vertexBufferOffsets[i],
+            m_currentPipeline->m_vertexBufferOffset + i);
     }
 
     encoder->setViewports(m_viewports.getArrayView().getBuffer(), m_viewports.getCount());
@@ -378,8 +410,13 @@ Result RenderCommandEncoder::prepareDraw(MTL::RenderCommandEncoder*& encoder)
     const DepthStencilDesc& depthStencilDesc = pipeline->desc.graphics.depthStencil;
     encoder->setFrontFacingWinding(MetalUtil::translateWinding(rasterDesc.frontFace));
     encoder->setCullMode(MetalUtil::translateCullMode(rasterDesc.cullMode));
-    encoder->setDepthClipMode(rasterDesc.depthClipEnable ? MTL::DepthClipModeClip : MTL::DepthClipModeClamp); // TODO correct?
-    encoder->setDepthBias(rasterDesc.depthBias, rasterDesc.slopeScaledDepthBias, rasterDesc.depthBiasClamp);
+    encoder->setDepthClipMode(
+        rasterDesc.depthClipEnable ? MTL::DepthClipModeClip
+                                   : MTL::DepthClipModeClamp); // TODO correct?
+    encoder->setDepthBias(
+        rasterDesc.depthBias,
+        rasterDesc.slopeScaledDepthBias,
+        rasterDesc.depthBiasClamp);
     encoder->setTriangleFillMode(MetalUtil::translateTriangleFillMode(rasterDesc.fillMode));
     // encoder->setBlendColor(); // not supported by gfx
     if (m_framebuffer->m_depthStencilView)
@@ -400,12 +437,19 @@ Result RenderCommandEncoder::draw(GfxCount vertexCount, GfxIndex startVertex)
 }
 
 Result RenderCommandEncoder::drawIndexed(
-    GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex)
+    GfxCount indexCount,
+    GfxIndex startIndex,
+    GfxIndex baseVertex)
 {
     MTL::RenderCommandEncoder* encoder;
     SLANG_RETURN_ON_FAIL(prepareDraw(encoder));
     // TODO baseVertex is not supported by Metal
-    encoder->drawIndexedPrimitives(m_primitiveType, indexCount, m_indexBufferType, m_indexBuffer, m_indexBufferOffset);
+    encoder->drawIndexedPrimitives(
+        m_primitiveType,
+        indexCount,
+        m_indexBufferType,
+        m_indexBuffer,
+        m_indexBufferOffset);
     return SLANG_OK;
 }
 
@@ -437,7 +481,12 @@ Result RenderCommandEncoder::drawInstanced(
 {
     MTL::RenderCommandEncoder* encoder;
     SLANG_RETURN_ON_FAIL(prepareDraw(encoder));
-    encoder->drawPrimitives(m_primitiveType, startVertex, vertexCount, instanceCount, startInstanceLocation);
+    encoder->drawPrimitives(
+        m_primitiveType,
+        startVertex,
+        vertexCount,
+        instanceCount,
+        startInstanceLocation);
     return SLANG_OK;
 }
 
@@ -450,7 +499,15 @@ Result RenderCommandEncoder::drawIndexedInstanced(
 {
     MTL::RenderCommandEncoder* encoder;
     SLANG_RETURN_ON_FAIL(prepareDraw(encoder));
-    encoder->drawIndexedPrimitives(m_primitiveType, indexCount, m_indexBufferType, m_indexBuffer, startIndexLocation, instanceCount, baseVertexLocation, startIndexLocation);
+    encoder->drawIndexedPrimitives(
+        m_primitiveType,
+        indexCount,
+        m_indexBufferType,
+        m_indexBuffer,
+        startIndexLocation,
+        instanceCount,
+        baseVertexLocation,
+        startIndexLocation);
     return SLANG_OK;
 }
 
@@ -465,13 +522,15 @@ void ComputeCommandEncoder::endEncoding()
 }
 
 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 SLANG_E_NOT_IMPLEMENTED;
 }
@@ -489,16 +548,18 @@ Result ComputeCommandEncoder::dispatchCompute(int x, int y, int z)
     RootShaderObjectImpl* rootObjectImpl = &m_commandBuffer->m_rootObject;
     RefPtr<PipelineStateBase> newPipeline;
     SLANG_RETURN_ON_FAIL(m_commandBuffer->m_device->maybeSpecializePipeline(
-        m_currentPipeline, rootObjectImpl, newPipeline));
+        m_currentPipeline,
+        rootObjectImpl,
+        newPipeline));
     PipelineStateImpl* newPipelineImpl = static_cast<PipelineStateImpl*>(newPipeline.Ptr());
 
     SLANG_RETURN_ON_FAIL(newPipelineImpl->ensureAPIPipelineStateCreated());
     m_currentPipeline = newPipelineImpl;
-    
+
     m_currentPipeline->ensureAPIPipelineStateCreated();
     encoder->setComputePipelineState(m_currentPipeline->m_computePipelineState.get());
 
-    
+
     encoder->dispatchThreadgroups(MTL::Size(x, y, z), m_currentPipeline->m_threadGroupSize);
 
     return SLANG_OK;
@@ -533,7 +594,9 @@ void RayTracingCommandEncoder::buildAccelerationStructure(
 }
 
 void RayTracingCommandEncoder::copyAccelerationStructure(
-    IAccelerationStructure* dest, IAccelerationStructure* src, AccelerationStructureCopyMode mode)
+    IAccelerationStructure* dest,
+    IAccelerationStructure* src,
+    AccelerationStructureCopyMode mode)
 {
 }
 
@@ -544,26 +607,34 @@ 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)
 {
 }
 
 void RayTracingCommandEncoder::deserializeAccelerationStructure(
-    IAccelerationStructure* dest, DeviceAddress source)
+    IAccelerationStructure* dest,
+    DeviceAddress source)
 {
 }
 
-Result RayTracingCommandEncoder::bindPipeline(IPipelineState* pipeline, IShaderObject** outRootObject)
+Result RayTracingCommandEncoder::bindPipeline(
+    IPipelineState* pipeline,
+    IShaderObject** outRootObject)
 {
     return SLANG_E_NOT_IMPLEMENTED;
 }
 
 Result RayTracingCommandEncoder::bindPipelineWithRootObject(
-    IPipelineState* pipelineState, IShaderObject* rootObject)
+    IPipelineState* pipelineState,
+    IShaderObject* rootObject)
 {
     return SLANG_E_NOT_IMPLEMENTED;
 }
@@ -578,7 +649,7 @@ Result RayTracingCommandEncoder::dispatchRays(
     return SLANG_E_NOT_IMPLEMENTED;
 }
 
-void RayTracingCommandEncoder::endEncoding() { }
+void RayTracingCommandEncoder::endEncoding() {}
 
 } // namespace metal
 } // namespace gfx
diff --git a/tools/gfx/metal/metal-command-encoder.h b/tools/gfx/metal/metal-command-encoder.h
index 8ef9e5fb5..9ca53f745 100644
--- a/tools/gfx/metal/metal-command-encoder.h
+++ b/tools/gfx/metal/metal-command-encoder.h
@@ -24,12 +24,9 @@ public:
     void endEncodingImpl();
 
     Result setPipelineStateImpl(IPipelineState* state, IShaderObject** outRootObject);
-
 };
 
-class ResourceCommandEncoder
-    : public IResourceCommandEncoder
-    , public PipelineCommandEncoder
+class ResourceCommandEncoder : public IResourceCommandEncoder, public PipelineCommandEncoder
 {
 public:
     virtual void* getInterface(SlangUUID const& guid)
@@ -39,7 +36,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))
         {
@@ -54,7 +51,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 copyBuffer(
         IBufferResource* dst,
@@ -86,7 +83,7 @@ public:
         ITextureResource::Extents extent) 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 uploadTextureData(
         ITextureResource* dst,
@@ -122,7 +119,9 @@ public:
         ClearResourceViewFlags::Enum flags);
 
     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,
@@ -140,25 +139,24 @@ public:
         Offset offset) 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;
         }
         return nullptr;
     }
+
 public:
     RefPtr<RenderPassLayoutImpl> m_renderPassLayout;
     RefPtr<FramebufferImpl> m_framebuffer;
@@ -183,19 +181,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,
@@ -204,7 +202,7 @@ 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;
 
     virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) override;
 
@@ -216,9 +214,9 @@ public:
     Result prepareDraw(MTL::RenderCommandEncoder*& encoder);
 
     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 Result SLANG_MCALL drawIndirect(
         GfxCount maxDrawCount,
@@ -247,19 +245,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;
         }
@@ -269,33 +265,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,
@@ -325,16 +320,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/metal/metal-command-queue.cpp b/tools/gfx/metal/metal-command-queue.cpp
index 920b6ef7e..4175076da 100644
--- a/tools/gfx/metal/metal-command-queue.cpp
+++ b/tools/gfx/metal/metal-command-queue.cpp
@@ -10,7 +10,7 @@ namespace gfx
 
 using namespace Slang;
 
-namespace metal 
+namespace metal
 {
 
 ICommandQueue* CommandQueueImpl::getInterface(const Guid& guid)
@@ -20,9 +20,7 @@ ICommandQueue* CommandQueueImpl::getInterface(const Guid& guid)
     return nullptr;
 }
 
-CommandQueueImpl::~CommandQueueImpl()
-{
-}
+CommandQueueImpl::~CommandQueueImpl() {}
 
 void CommandQueueImpl::init(DeviceImpl* device, NS::SharedPtr<MTL::CommandQueue> commandQueue)
 {
@@ -42,10 +40,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 (GfxCount i = 0; i < fenceCount; ++i)
     {
@@ -58,7 +61,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)
 {
     // If there are any pending wait fences, encode them to a new command buffer.
     // Metal ensures that command buffers are executed in the order they are committed.
@@ -79,7 +85,9 @@ void CommandQueueImpl::queueSubmitImpl(
         // If this is the last command buffer and a fence is provided, signal the fence.
         if (i == count - 1 && fence != nullptr)
         {
-            cmdBufImpl->m_commandBuffer->encodeSignalEvent(static_cast<FenceImpl*>(fence)->m_event.get(), valueToSignal);
+            cmdBufImpl->m_commandBuffer->encodeSignalEvent(
+                static_cast<FenceImpl*>(fence)->m_event.get(),
+                valueToSignal);
         }
         cmdBufImpl->m_commandBuffer->commit();
     }
@@ -88,13 +96,18 @@ void CommandQueueImpl::queueSubmitImpl(
     if (count == 0 && fence != nullptr)
     {
         MTL::CommandBuffer* commandBuffer = m_commandQueue->commandBuffer();
-        commandBuffer->encodeSignalEvent(static_cast<FenceImpl*>(fence)->m_event.get(), valueToSignal);
+        commandBuffer->encodeSignalEvent(
+            static_cast<FenceImpl*>(fence)->m_event.get(),
+            valueToSignal);
         commandBuffer->commit();
     }
 }
 
 void CommandQueueImpl::executeCommandBuffers(
-    GfxCount count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal)
+    GfxCount count,
+    ICommandBuffer* const* commandBuffers,
+    IFence* fence,
+    uint64_t valueToSignal)
 {
     AUTORELEASEPOOL
 
diff --git a/tools/gfx/metal/metal-command-queue.h b/tools/gfx/metal/metal-command-queue.h
index 045f4ed73..1f825360b 100644
--- a/tools/gfx/metal/metal-command-queue.h
+++ b/tools/gfx/metal/metal-command-queue.h
@@ -9,12 +9,10 @@ namespace gfx
 
 using namespace Slang;
 
-namespace  metal
+namespace metal
 {
 
-class CommandQueueImpl
-    : public ICommandQueue
-    , public ComObject
+class CommandQueueImpl : public ICommandQueue, public ComObject
 {
 public:
     SLANG_COM_OBJECT_IUNKNOWN_ALL
@@ -42,8 +40,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/metal/metal-device.cpp b/tools/gfx/metal/metal-device.cpp
index 609c1bf27..ff534a78c 100644
--- a/tools/gfx/metal/metal-device.cpp
+++ b/tools/gfx/metal/metal-device.cpp
@@ -1,25 +1,25 @@
 // metal-device.cpp
 #include "metal-device.h"
 
-#include "metal-swap-chain.h"
-#include "metal-util.h"
 #include "../resource-desc-utils.h"
-#include "metal-texture.h"
+#include "metal-buffer.h"
 #include "metal-render-pass.h"
-#include "metal-vertex-layout.h"
 #include "metal-shader-program.h"
-#include "metal-buffer.h"
-//#include "metal-command-queue.h"
+#include "metal-swap-chain.h"
+#include "metal-texture.h"
+#include "metal-util.h"
+#include "metal-vertex-layout.h"
+// #include "metal-command-queue.h"
 #include "metal-fence.h"
 #include "metal-query.h"
-//#include "metal-resource-views.h"
+// #include "metal-resource-views.h"
 #include "metal-sampler.h"
-#include "metal-shader-object.h"
 #include "metal-shader-object-layout.h"
-//#include "metal-shader-table.h"
+#include "metal-shader-object.h"
+// #include "metal-shader-table.h"
 #include "metal-transient-heap.h"
-//#include "metal-pipeline-dump-layer.h"
-//#include "metal-helper-functions.h"
+// #include "metal-pipeline-dump-layer.h"
+// #include "metal-helper-functions.h"
 
 #include "source/core/slang-platform.h"
 namespace gfx
@@ -37,9 +37,7 @@ static bool shouldDumpPipeline()
     return dumpPipelineSettings.produceString() == "1";
 }
 
-DeviceImpl::~DeviceImpl()
-{
-}
+DeviceImpl::~DeviceImpl() {}
 
 Result DeviceImpl::getNativeDeviceHandles(InteropHandles* outHandles)
 {
@@ -59,7 +57,7 @@ SlangResult DeviceImpl::initialize(const Desc& desc)
         m_info.projectionStyle = ProjectionStyle::Metal;
         m_info.deviceType = DeviceType::Metal;
         m_info.adapterName = "default";
-        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));
     }
 
@@ -83,23 +81,27 @@ SlangResult DeviceImpl::initialize(const Desc& desc)
         desc.extendedDescs,
         SLANG_METAL_LIB,
         "",
-        makeArray(slang::PreprocessorMacroDesc{ "__METAL__", "1" }).getView()));
+        makeArray(slang::PreprocessorMacroDesc{"__METAL__", "1"}).getView()));
 
     // TODO: expose via some other means
     if (captureEnabled())
     {
         MTL::CaptureManager* captureManager = MTL::CaptureManager::sharedCaptureManager();
         MTL::CaptureDescriptor* d = MTL::CaptureDescriptor::alloc()->init();
-        MTL::CaptureDestination captureDest = MTL::CaptureDestination::CaptureDestinationGPUTraceDocument;
+        MTL::CaptureDestination captureDest =
+            MTL::CaptureDestination::CaptureDestinationGPUTraceDocument;
         if (!captureManager->supportsDestination(MTL::CaptureDestinationGPUTraceDocument))
         {
-            std::cout << "Cannot capture MTL calls to document; ensure that Info.plist exists with 'MetalCaptureEnabled' set to 'true'." << std::endl;
+            std::cout << "Cannot capture MTL calls to document; ensure that Info.plist exists with "
+                         "'MetalCaptureEnabled' set to 'true'."
+                      << std::endl;
             exit(1);
         }
         d->setDestination(MTL::CaptureDestinationGPUTraceDocument);
         d->setCaptureObject(m_device.get());
         NS::SharedPtr<NS::String> path = MetalUtil::createString("frame.gputrace");
-        NS::SharedPtr<NS::URL> url = NS::TransferPtr(NS::URL::alloc()->initFileURLWithPath(path.get()));
+        NS::SharedPtr<NS::URL> url =
+            NS::TransferPtr(NS::URL::alloc()->initFileURLWithPath(path.get()));
         d->setOutputURL(url.get());
         NS::Error* errorCode = NS::Error::alloc();
         if (!captureManager->startCapture(d, &errorCode))
@@ -113,7 +115,7 @@ SlangResult DeviceImpl::initialize(const Desc& desc)
     return SLANG_OK;
 }
 
-//void DeviceImpl::waitForGpu() { m_deviceQueue.flushAndWait(); }
+// void DeviceImpl::waitForGpu() { m_deviceQueue.flushAndWait(); }
 
 
 const DeviceInfo& DeviceImpl::getDeviceInfo() const
@@ -121,7 +123,9 @@ const DeviceInfo& DeviceImpl::getDeviceInfo() const
     return m_info;
 }
 
-Result DeviceImpl::createTransientResourceHeap(const ITransientResourceHeap::Desc& desc, ITransientResourceHeap** outHeap)
+Result DeviceImpl::createTransientResourceHeap(
+    const ITransientResourceHeap::Desc& desc,
+    ITransientResourceHeap** outHeap)
 {
     AUTORELEASEPOOL
 
@@ -146,7 +150,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)
 {
     AUTORELEASEPOOL
 
@@ -156,7 +162,9 @@ Result DeviceImpl::createSwapchain(
     return SLANG_OK;
 }
 
-Result DeviceImpl::createFramebufferLayout(const IFramebufferLayout::Desc& desc, IFramebufferLayout** outLayout)
+Result DeviceImpl::createFramebufferLayout(
+    const IFramebufferLayout::Desc& desc,
+    IFramebufferLayout** outLayout)
 {
     AUTORELEASEPOOL
 
@@ -166,7 +174,9 @@ Result DeviceImpl::createFramebufferLayout(const IFramebufferLayout::Desc& desc,
     return SLANG_OK;
 }
 
-Result DeviceImpl::createRenderPassLayout(const IRenderPassLayout::Desc& desc, IRenderPassLayout** outRenderPassLayout)
+Result DeviceImpl::createRenderPassLayout(
+    const IRenderPassLayout::Desc& desc,
+    IRenderPassLayout** outRenderPassLayout)
 {
     AUTORELEASEPOOL
 
@@ -199,7 +209,7 @@ SlangResult DeviceImpl::readTextureResource(
 
     if (textureImpl->getDesc()->sampleDesc.numSamples > 1)
     {
-    return SLANG_E_NOT_IMPLEMENTED;
+        return SLANG_E_NOT_IMPLEMENTED;
     }
 
     NS::SharedPtr<MTL::Texture> srcTexture = textureImpl->m_texture;
@@ -220,7 +230,8 @@ SlangResult DeviceImpl::readTextureResource(
         *outPixelSize = bytesPerPixel;
 
     // create staging buffer
-    NS::SharedPtr<MTL::Buffer> stagingBuffer = NS::TransferPtr(m_device->newBuffer(bufferSize, MTL::StorageModeShared));
+    NS::SharedPtr<MTL::Buffer> stagingBuffer =
+        NS::TransferPtr(m_device->newBuffer(bufferSize, MTL::StorageModeShared));
     if (!stagingBuffer)
     {
         return SLANG_FAIL;
@@ -229,8 +240,15 @@ SlangResult DeviceImpl::readTextureResource(
     MTL::CommandBuffer* commandBuffer = m_commandQueue->commandBuffer();
     MTL::BlitCommandEncoder* encoder = commandBuffer->blitCommandEncoder();
     encoder->copyFromTexture(
-        srcTexture.get(), 0, 0, MTL::Origin(0, 0, 0), MTL::Size(width, height, depth),
-        stagingBuffer.get(), 0, bytesPerRow, bytesPerSlice);
+        srcTexture.get(),
+        0,
+        0,
+        MTL::Origin(0, 0, 0),
+        MTL::Size(width, height, depth),
+        stagingBuffer.get(),
+        0,
+        bytesPerRow,
+        bytesPerSlice);
     encoder->endEncoding();
     commandBuffer->commit();
     commandBuffer->waitUntilCompleted();
@@ -245,12 +263,16 @@ SlangResult DeviceImpl::readTextureResource(
 }
 
 SlangResult DeviceImpl::readBufferResource(
-    IBufferResource* buffer, Offset offset, Size size, ISlangBlob** outBlob)
+    IBufferResource* buffer,
+    Offset offset,
+    Size size,
+    ISlangBlob** outBlob)
 {
     AUTORELEASEPOOL
 
     // create staging buffer
-    NS::SharedPtr<MTL::Buffer> stagingBuffer = NS::TransferPtr(m_device->newBuffer(size, MTL::StorageModeShared));
+    NS::SharedPtr<MTL::Buffer> stagingBuffer =
+        NS::TransferPtr(m_device->newBuffer(size, MTL::StorageModeShared));
     if (!stagingBuffer)
     {
         return SLANG_FAIL;
@@ -258,7 +280,12 @@ SlangResult DeviceImpl::readBufferResource(
 
     MTL::CommandBuffer* commandBuffer = m_commandQueue->commandBuffer();
     MTL::BlitCommandEncoder* blitEncoder = commandBuffer->blitCommandEncoder();
-    blitEncoder->copyFromBuffer(static_cast<BufferResourceImpl*>(buffer)->m_buffer.get(), offset, stagingBuffer.get(), 0, size);
+    blitEncoder->copyFromBuffer(
+        static_cast<BufferResourceImpl*>(buffer)->m_buffer.get(),
+        offset,
+        stagingBuffer.get(),
+        0,
+        size);
     blitEncoder->endEncoding();
     commandBuffer->commit();
     commandBuffer->waitUntilCompleted();
@@ -282,7 +309,8 @@ Result DeviceImpl::getAccelerationStructurePrebuildInfo(
 }
 
 Result DeviceImpl::createAccelerationStructure(
-    const IAccelerationStructure::CreateDesc& desc, IAccelerationStructure** outAS)
+    const IAccelerationStructure::CreateDesc& desc,
+    IAccelerationStructure** outAS)
 {
     AUTORELEASEPOOL
 
@@ -290,13 +318,14 @@ Result DeviceImpl::createAccelerationStructure(
 }
 
 Result DeviceImpl::getTextureAllocationInfo(
-    const ITextureResource::Desc& descIn, Size* outSize, Size* outAlignment)
+    const ITextureResource::Desc& descIn,
+    Size* outSize,
+    Size* outAlignment)
 {
     AUTORELEASEPOOL
 
-    auto alignTo = [&](Size size, Size alignment) -> Size {
-        return ((size + alignment - 1) / alignment) * alignment;
-    };
+    auto alignTo = [&](Size size, Size alignment) -> Size
+    { return ((size + alignment - 1) / alignment) * alignment; };
 
     TextureResource::Desc desc = fixupTextureDesc(descIn);
     FormatInfo formatInfo;
@@ -311,7 +340,8 @@ Result DeviceImpl::getTextureAllocationInfo(
 
     for (Int i = 0; i < desc.numMipLevels; ++i)
     {
-        Size rowSize = ((extents.width + formatInfo.blockWidth - 1) / formatInfo.blockWidth) * formatInfo.blockSizeInBytes;
+        Size rowSize = ((extents.width + formatInfo.blockWidth - 1) / formatInfo.blockWidth) *
+                       formatInfo.blockSizeInBytes;
         rowSize = alignTo(rowSize, alignment);
         Size sliceSize = rowSize * alignTo(extents.height, formatInfo.blockHeight);
         size += sliceSize * extents.depth;
@@ -358,19 +388,16 @@ Result DeviceImpl::createTextureResource(
 
     RefPtr<TextureResourceImpl> textureImpl(new TextureResourceImpl(desc, this));
 
-    NS::SharedPtr<MTL::TextureDescriptor> textureDesc = NS::TransferPtr(MTL::TextureDescriptor::alloc()->init());
+    NS::SharedPtr<MTL::TextureDescriptor> textureDesc =
+        NS::TransferPtr(MTL::TextureDescriptor::alloc()->init());
     switch (desc.memoryType)
     {
-    case MemoryType::DeviceLocal:
-        textureDesc->setStorageMode(MTL::StorageModePrivate);
-        break;
+    case MemoryType::DeviceLocal: textureDesc->setStorageMode(MTL::StorageModePrivate); break;
     case MemoryType::Upload:
         textureDesc->setStorageMode(MTL::StorageModeShared);
         textureDesc->setCpuCacheMode(MTL::CPUCacheModeWriteCombined);
         break;
-    case MemoryType::ReadBack:
-        textureDesc->setStorageMode(MTL::StorageModeShared);
-        break;
+    case MemoryType::ReadBack: textureDesc->setStorageMode(MTL::StorageModeShared); break;
     }
 
     bool isArray = desc.arraySize > 0;
@@ -384,7 +411,8 @@ Result DeviceImpl::createTextureResource(
     case IResource::Type::Texture2D:
         if (desc.sampleDesc.numSamples > 1)
         {
-            textureDesc->setTextureType(isArray ? MTL::TextureType2DMultisampleArray : MTL::TextureType2DMultisample);
+            textureDesc->setTextureType(
+                isArray ? MTL::TextureType2DMultisampleArray : MTL::TextureType2DMultisample);
             textureDesc->setSampleCount(desc.sampleDesc.numSamples);
         }
         else
@@ -405,9 +433,7 @@ Result DeviceImpl::createTextureResource(
         textureDesc->setHeight(descIn.size.height);
         textureDesc->setDepth(descIn.size.depth);
         break;
-    default:
-        assert("!Unsupported texture type");
-        return SLANG_FAIL;
+    default: assert("!Unsupported texture type"); return SLANG_FAIL;
     }
 
     MTL::TextureUsage textureUsage = MTL::TextureUsageUnknown;
@@ -430,9 +456,7 @@ Result DeviceImpl::createTextureResource(
         case Format::R32_UINT:
         case Format::R32_SINT:
         case Format::R32G32_UINT:
-        case Format::R32G32_SINT:
-            textureUsage |= MTL::TextureUsageShaderAtomic;
-            break;
+        case Format::R32G32_SINT: textureUsage |= MTL::TextureUsageShaderAtomic; break;
         }
     }
 
@@ -456,7 +480,8 @@ Result DeviceImpl::createTextureResource(
     {
         textureDesc->setStorageMode(MTL::StorageModeManaged);
         textureDesc->setCpuCacheMode(MTL::CPUCacheModeDefaultCache);
-        NS::SharedPtr<MTL::Texture> stagingTexture = NS::TransferPtr(m_device->newTexture(textureDesc.get()));
+        NS::SharedPtr<MTL::Texture> stagingTexture =
+            NS::TransferPtr(m_device->newTexture(textureDesc.get()));
 
         MTL::CommandBuffer* commandBuffer = m_commandQueue->commandBuffer();
         MTL::BlitCommandEncoder* encoder = commandBuffer->blitCommandEncoder();
@@ -480,12 +505,22 @@ Result DeviceImpl::createTextureResource(
             {
                 if (level >= desc.numMipLevels)
                     continue;
-                const ITextureResource::SubresourceData& subresourceData = initData[slice * initMipLevels + level];
-                stagingTexture->replaceRegion(region, level, slice, subresourceData.data, subresourceData.strideY, subresourceData.strideZ);
+                const ITextureResource::SubresourceData& subresourceData =
+                    initData[slice * initMipLevels + level];
+                stagingTexture->replaceRegion(
+                    region,
+                    level,
+                    slice,
+                    subresourceData.data,
+                    subresourceData.strideY,
+                    subresourceData.strideZ);
                 encoder->synchronizeTexture(stagingTexture.get(), slice, level);
-                region.size.width = region.size.width > 0 ? Math::Max(1ul, region.size.width >> 1) : 0;
-                region.size.height = region.size.height > 0 ? Math::Max(1ul, region.size.height >> 1) : 0;
-                region.size.depth = region.size.depth > 0 ? Math::Max(1ul, region.size.depth >> 1) : 0;
+                region.size.width =
+                    region.size.width > 0 ? Math::Max(1ul, region.size.width >> 1) : 0;
+                region.size.height =
+                    region.size.height > 0 ? Math::Max(1ul, region.size.height >> 1) : 0;
+                region.size.depth =
+                    region.size.depth > 0 ? Math::Max(1ul, region.size.depth >> 1) : 0;
             }
         }
 
@@ -500,7 +535,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)
 {
     AUTORELEASEPOOL
 
@@ -511,17 +548,15 @@ Result DeviceImpl::createBufferResource(
     MTL::ResourceOptions resourceOptions = MTL::ResourceOptions(0);
     switch (desc.memoryType)
     {
-    case MemoryType::DeviceLocal:
-        resourceOptions = MTL::ResourceStorageModePrivate;
-        break;
+    case MemoryType::DeviceLocal: resourceOptions = MTL::ResourceStorageModePrivate; break;
     case MemoryType::Upload:
         resourceOptions = MTL::ResourceStorageModeShared | MTL::CPUCacheModeWriteCombined;
         break;
-    case MemoryType::ReadBack:
-        resourceOptions = MTL::ResourceStorageModeShared;
-        break;
+    case MemoryType::ReadBack: resourceOptions = MTL::ResourceStorageModeShared; break;
     }
-    resourceOptions |= (desc.memoryType == MemoryType::DeviceLocal) ? MTL::ResourceStorageModePrivate : MTL::ResourceStorageModeShared;
+    resourceOptions |= (desc.memoryType == MemoryType::DeviceLocal)
+                           ? MTL::ResourceStorageModePrivate
+                           : MTL::ResourceStorageModeShared;
 
     RefPtr<BufferResourceImpl> bufferImpl(new BufferResourceImpl(desc, this));
     bufferImpl->m_buffer = NS::TransferPtr(m_device->newBuffer(bufferSize, resourceOptions));
@@ -533,7 +568,9 @@ Result DeviceImpl::createBufferResource(
     if (initData)
     {
         NS::SharedPtr<MTL::Buffer> stagingBuffer = NS::TransferPtr(m_device->newBuffer(
-            initData, bufferSize, MTL::ResourceStorageModeShared | MTL::CPUCacheModeWriteCombined));
+            initData,
+            bufferSize,
+            MTL::ResourceStorageModeShared | MTL::CPUCacheModeWriteCombined));
         MTL::CommandBuffer* commandBuffer = m_commandQueue->commandBuffer();
         MTL::BlitCommandEncoder* encoder = commandBuffer->blitCommandEncoder();
         if (!stagingBuffer || !commandBuffer || !encoder)
@@ -551,7 +588,9 @@ Result DeviceImpl::createBufferResource(
 }
 
 Result DeviceImpl::createBufferFromNativeHandle(
-    InteropHandle handle, const IBufferResource::Desc& srcDesc, IBufferResource** outResource)
+    InteropHandle handle,
+    const IBufferResource::Desc& srcDesc,
+    IBufferResource** outResource)
 {
     AUTORELEASEPOOL
 
@@ -569,7 +608,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)
 {
     AUTORELEASEPOOL
 
@@ -586,7 +627,8 @@ Result DeviceImpl::createTextureView(
 
     const ITextureResource::Desc& textureDesc = *textureImpl->getDesc();
     SubresourceRange sr = desc.subresourceRange;
-    sr.mipLevelCount = sr.mipLevelCount == 0 ? textureDesc.numMipLevels - sr.mipLevel : sr.mipLevelCount;
+    sr.mipLevelCount =
+        sr.mipLevelCount == 0 ? textureDesc.numMipLevels - sr.mipLevel : sr.mipLevelCount;
     sr.layerCount = sr.layerCount == 0 ? textureDesc.arraySize - sr.baseArrayLayer : sr.layerCount;
     if (sr.mipLevel == 0 && sr.mipLevelCount == textureDesc.numMipLevels &&
         sr.baseArrayLayer == 0 && sr.layerCount == textureDesc.arraySize)
@@ -596,11 +638,17 @@ Result DeviceImpl::createTextureView(
         return SLANG_OK;
     }
 
-    MTL::PixelFormat pixelFormat = desc.format == Format::Unknown ? textureImpl->m_pixelFormat : MetalUtil::translatePixelFormat(desc.format);
+    MTL::PixelFormat pixelFormat = desc.format == Format::Unknown
+                                       ? textureImpl->m_pixelFormat
+                                       : MetalUtil::translatePixelFormat(desc.format);
     NS::Range levelRange(sr.baseArrayLayer, sr.layerCount);
     NS::Range sliceRange(sr.mipLevel, sr.mipLevelCount);
 
-    viewImpl->m_textureView = NS::TransferPtr(textureImpl->m_texture->newTextureView(pixelFormat, textureImpl->m_textureType, levelRange, sliceRange));
+    viewImpl->m_textureView = NS::TransferPtr(textureImpl->m_texture->newTextureView(
+        pixelFormat,
+        textureImpl->m_textureType,
+        levelRange,
+        sliceRange));
     if (!viewImpl->m_textureView)
     {
         return SLANG_FAIL;
@@ -651,7 +699,8 @@ Result DeviceImpl::createBufferView(
         return SLANG_FAIL;
     }
 
-    if (desc.type != IResourceView::Type::UnorderedAccess && desc.type != IResourceView::Type::ShaderResource)
+    if (desc.type != IResourceView::Type::UnorderedAccess &&
+        desc.type != IResourceView::Type::ShaderResource)
     {
         return SLANG_FAIL;
     }
@@ -662,7 +711,8 @@ Result DeviceImpl::createBufferView(
     viewImpl->m_desc = desc;
     viewImpl->m_buffer = bufferImpl;
     viewImpl->m_offset = desc.bufferRange.offset;
-    viewImpl->m_size = desc.bufferRange.size == 0 ? bufferImpl->getDesc()->sizeInBytes : desc.bufferRange.size;
+    viewImpl->m_size =
+        desc.bufferRange.size == 0 ? bufferImpl->getDesc()->sizeInBytes : desc.bufferRange.size;
     returnComPtr(outView, viewImpl);
     return SLANG_OK;
 }
@@ -678,7 +728,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)
 {
     AUTORELEASEPOOL
 
@@ -708,8 +760,8 @@ Result DeviceImpl::createShaderObjectLayout(
     AUTORELEASEPOOL
 
     RefPtr<ShaderObjectLayoutImpl> layout;
-    SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType(
-        this, session, typeLayout, layout.writeRef()));
+    SLANG_RETURN_ON_FAIL(
+        ShaderObjectLayoutImpl::createForElementType(this, session, typeLayout, layout.writeRef()));
     returnRefPtrMove(outLayout, layout);
     return SLANG_OK;
 }
@@ -719,14 +771,17 @@ Result DeviceImpl::createShaderObject(ShaderObjectLayoutBase* layout, IShaderObj
     AUTORELEASEPOOL
 
     RefPtr<ShaderObjectImpl> shaderObject;
-    SLANG_RETURN_ON_FAIL(ShaderObjectImpl::create(this,
-        static_cast<ShaderObjectLayoutImpl*>(layout), shaderObject.writeRef()));
+    SLANG_RETURN_ON_FAIL(ShaderObjectImpl::create(
+        this,
+        static_cast<ShaderObjectLayoutImpl*>(layout),
+        shaderObject.writeRef()));
     returnComPtr(outObject, shaderObject);
     return SLANG_OK;
 }
 
 Result DeviceImpl::createMutableShaderObject(
-    ShaderObjectLayoutBase* layout, IShaderObject** outObject)
+    ShaderObjectLayoutBase* layout,
+    IShaderObject** outObject)
 {
     AUTORELEASEPOOL
 
@@ -747,7 +802,9 @@ Result DeviceImpl::createShaderTable(const IShaderTable::Desc& desc, IShaderTabl
     return SLANG_E_NOT_IMPLEMENTED;
 }
 
-Result DeviceImpl::createGraphicsPipelineState(const GraphicsPipelineStateDesc& desc, IPipelineState** outState)
+Result DeviceImpl::createGraphicsPipelineState(
+    const GraphicsPipelineStateDesc& desc,
+    IPipelineState** outState)
 {
     AUTORELEASEPOOL
 
@@ -757,7 +814,9 @@ Result DeviceImpl::createGraphicsPipelineState(const GraphicsPipelineStateDesc&
     return SLANG_OK;
 }
 
-Result DeviceImpl::createComputePipelineState(const ComputePipelineStateDesc& desc, IPipelineState** outState)
+Result DeviceImpl::createComputePipelineState(
+    const ComputePipelineStateDesc& desc,
+    IPipelineState** outState)
 {
     AUTORELEASEPOOL
 
@@ -768,7 +827,9 @@ Result DeviceImpl::createComputePipelineState(const ComputePipelineStateDesc& de
     return SLANG_OK;
 }
 
-Result DeviceImpl::createRayTracingPipelineState(const RayTracingPipelineStateDesc& desc, IPipelineState** outState)
+Result DeviceImpl::createRayTracingPipelineState(
+    const RayTracingPipelineStateDesc& desc,
+    IPipelineState** outState)
 {
     AUTORELEASEPOOL
 
@@ -796,7 +857,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)
 {
     return SLANG_E_NOT_IMPLEMENTED;
 }
diff --git a/tools/gfx/metal/metal-device.h b/tools/gfx/metal/metal-device.h
index 50eb0e88d..b22066f61 100644
--- a/tools/gfx/metal/metal-device.h
+++ b/tools/gfx/metal/metal-device.h
@@ -1,9 +1,9 @@
 // metal-device.h
 #pragma once
 
+#include "../simple-transient-resource-heap.h"
 #include "metal-base.h"
 #include "metal-device.h"
-#include "../simple-transient-resource-heap.h"
 #include "metal-framebuffer.h"
 
 namespace gfx
@@ -11,7 +11,7 @@ namespace gfx
 
 using namespace Slang;
 
-namespace metal 
+namespace metal
 {
 
 class DeviceImpl : public RendererBase
@@ -20,19 +20,24 @@ public:
     // Renderer implementation
     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,
@@ -46,7 +51,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,
@@ -59,33 +64,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,
@@ -95,22 +104,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,
@@ -119,10 +134,10 @@ public:
         bool waitForAll,
         uint64_t timeout) override;
 
-    //void waitForGpu();
+    // void waitForGpu();
     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();
 
 public:
diff --git a/tools/gfx/metal/metal-fence.cpp b/tools/gfx/metal/metal-fence.cpp
index a908a8493..0de7d8ffb 100644
--- a/tools/gfx/metal/metal-fence.cpp
+++ b/tools/gfx/metal/metal-fence.cpp
@@ -1,5 +1,6 @@
 // metal-fence.cpp
 #include "metal-fence.h"
+
 #include "metal-device.h"
 
 namespace gfx
@@ -10,9 +11,7 @@ using namespace Slang;
 namespace metal
 {
 
-FenceImpl::~FenceImpl()
-{
-}
+FenceImpl::~FenceImpl() {}
 
 Result FenceImpl::init(DeviceImpl* device, const IFence::Desc& desc)
 {
diff --git a/tools/gfx/metal/metal-fence.h b/tools/gfx/metal/metal-fence.h
index d8aed7dfe..434f2f65d 100644
--- a/tools/gfx/metal/metal-fence.h
+++ b/tools/gfx/metal/metal-fence.h
@@ -24,11 +24,12 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL getCurrentValue(uint64_t* outValue) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL setCurrentValue(uint64_t value) override;
-   
+
     virtual SLANG_NO_THROW Result SLANG_MCALL getSharedHandle(InteropHandle* outHandle) override;
 
-    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outNativeHandle) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+    getNativeHandle(InteropHandle* outNativeHandle) override;
 };
 
-} // namespace metal 
+} // namespace metal
 } // namespace gfx
diff --git a/tools/gfx/metal/metal-framebuffer.cpp b/tools/gfx/metal/metal-framebuffer.cpp
index 76e944b4a..e7d04a63a 100644
--- a/tools/gfx/metal/metal-framebuffer.cpp
+++ b/tools/gfx/metal/metal-framebuffer.cpp
@@ -1,8 +1,9 @@
 // metal-framebuffer.cpp
 #include "metal-framebuffer.h"
+
 #include "metal-device.h"
-#include "metal-resource-views.h"
 #include "metal-helper-functions.h"
+#include "metal-resource-views.h"
 
 namespace gfx
 {
@@ -39,7 +40,7 @@ Result FramebufferImpl::init(DeviceImpl* device, const IFramebuffer::Desc& desc)
         m_renderTargetViews[i] = static_cast<TextureResourceViewImpl*>(desc.renderTargetViews[i]);
     }
     m_depthStencilView = static_cast<TextureResourceViewImpl*>(desc.depthStencilView);
-    
+
     // Determine framebuffer dimensions & sample count;
     m_width = 1;
     m_height = 1;
@@ -49,8 +50,11 @@ Result FramebufferImpl::init(DeviceImpl* device, const IFramebuffer::Desc& desc)
     {
         const ITextureResource::Desc* textureDesc = view->m_texture->getDesc();
         const IResourceView::Desc* viewDesc = view->getViewDesc();
-        m_width = Math::Max(1u, uint32_t(textureDesc->size.width >> viewDesc->subresourceRange.mipLevel));
-        m_height = Math::Max(1u, uint32_t(textureDesc->size.height >> viewDesc->subresourceRange.mipLevel));
+        m_width =
+            Math::Max(1u, uint32_t(textureDesc->size.width >> viewDesc->subresourceRange.mipLevel));
+        m_height = Math::Max(
+            1u,
+            uint32_t(textureDesc->size.height >> viewDesc->subresourceRange.mipLevel));
         m_sampleCount = Math::Max(m_sampleCount, uint32_t(textureDesc->sampleDesc.numSamples));
         return SLANG_OK;
     };
diff --git a/tools/gfx/metal/metal-helper-functions.cpp b/tools/gfx/metal/metal-helper-functions.cpp
index 69c4327ad..dc528f8ce 100644
--- a/tools/gfx/metal/metal-helper-functions.cpp
+++ b/tools/gfx/metal/metal-helper-functions.cpp
@@ -1,5 +1,6 @@
 // metal-helper-functions.cpp
 #include "metal-helper-functions.h"
+
 #include "metal-device.h"
 #include "metal-util.h"
 
diff --git a/tools/gfx/metal/metal-pipeline-state.cpp b/tools/gfx/metal/metal-pipeline-state.cpp
index d8ca3f793..c2a9afaac 100644
--- a/tools/gfx/metal/metal-pipeline-state.cpp
+++ b/tools/gfx/metal/metal-pipeline-state.cpp
@@ -2,10 +2,10 @@
 #include "metal-pipeline-state.h"
 
 #include "metal-device.h"
-#include "metal-shader-program.h"
 #include "metal-shader-object-layout.h"
-#include "metal-vertex-layout.h"
+#include "metal-shader-program.h"
 #include "metal-util.h"
+#include "metal-vertex-layout.h"
 
 namespace gfx
 {
@@ -20,9 +20,7 @@ PipelineStateImpl::PipelineStateImpl(DeviceImpl* device)
 {
 }
 
-PipelineStateImpl::~PipelineStateImpl()
-{
-}
+PipelineStateImpl::~PipelineStateImpl() {}
 
 void PipelineStateImpl::init(const GraphicsPipelineStateDesc& desc)
 {
@@ -54,25 +52,22 @@ Result PipelineStateImpl::createMetalRenderPipelineState()
     if (!programImpl)
         return SLANG_FAIL;
 
-    NS::SharedPtr<MTL::RenderPipelineDescriptor> pd = NS::TransferPtr(MTL::RenderPipelineDescriptor::alloc()->init());
+    NS::SharedPtr<MTL::RenderPipelineDescriptor> pd =
+        NS::TransferPtr(MTL::RenderPipelineDescriptor::alloc()->init());
 
     for (const ShaderProgramImpl::Module& module : programImpl->m_modules)
     {
         auto functionName = MetalUtil::createString(module.entryPointName.getBuffer());
-        NS::SharedPtr<MTL::Function> function = NS::TransferPtr(module.library->newFunction(functionName.get()));
+        NS::SharedPtr<MTL::Function> function =
+            NS::TransferPtr(module.library->newFunction(functionName.get()));
         if (!function)
             return SLANG_FAIL;
 
         switch (module.stage)
         {
-        case SLANG_STAGE_VERTEX:
-            pd->setVertexFunction(function.get());
-            break;
-        case SLANG_STAGE_FRAGMENT:
-            pd->setFragmentFunction(function.get());
-            break;
-        default:
-            return SLANG_FAIL;
+        case SLANG_STAGE_VERTEX:   pd->setVertexFunction(function.get()); break;
+        case SLANG_STAGE_FRAGMENT: pd->setFragmentFunction(function.get()); break;
+        default:                   return SLANG_FAIL;
         }
     }
 
@@ -81,12 +76,15 @@ Result PipelineStateImpl::createMetalRenderPipelineState()
     // The +1 is to account for a potential constant buffer at index 0.
     m_vertexBufferOffset = programImpl->m_rootObjectLayout->getBufferCount() + 1;
     auto inputLayoutImpl = static_cast<InputLayoutImpl*>(desc.graphics.inputLayout);
-    NS::SharedPtr<MTL::VertexDescriptor> vertexDescriptor = inputLayoutImpl->createVertexDescriptor(m_vertexBufferOffset);
+    NS::SharedPtr<MTL::VertexDescriptor> vertexDescriptor =
+        inputLayoutImpl->createVertexDescriptor(m_vertexBufferOffset);
     pd->setVertexDescriptor(vertexDescriptor.get());
-    pd->setInputPrimitiveTopology(MetalUtil::translatePrimitiveTopologyClass(desc.graphics.primitiveType));
+    pd->setInputPrimitiveTopology(
+        MetalUtil::translatePrimitiveTopologyClass(desc.graphics.primitiveType));
 
     // Set rasterization state
-    auto framebufferLayoutImpl = static_cast<FramebufferLayoutImpl*>(desc.graphics.framebufferLayout);
+    auto framebufferLayoutImpl =
+        static_cast<FramebufferLayoutImpl*>(desc.graphics.framebufferLayout);
     const auto& blend = desc.graphics.blend;
     GfxCount sampleCount = 1;
 
@@ -96,26 +94,36 @@ Result PipelineStateImpl::createMetalRenderPipelineState()
 
     for (Index i = 0; i < framebufferLayoutImpl->m_renderTargets.getCount(); ++i)
     {
-        const IFramebufferLayout::TargetLayout& targetLayout = framebufferLayoutImpl->m_renderTargets[i];
-        MTL::RenderPipelineColorAttachmentDescriptor* colorAttachment = pd->colorAttachments()->object(i);
+        const IFramebufferLayout::TargetLayout& targetLayout =
+            framebufferLayoutImpl->m_renderTargets[i];
+        MTL::RenderPipelineColorAttachmentDescriptor* colorAttachment =
+            pd->colorAttachments()->object(i);
         colorAttachment->setPixelFormat(MetalUtil::translatePixelFormat(targetLayout.format));
         if (i < blend.targetCount)
         {
             const TargetBlendDesc& targetBlendDesc = blend.targets[i];
             colorAttachment->setBlendingEnabled(targetBlendDesc.enableBlend);
-            colorAttachment->setSourceRGBBlendFactor(MetalUtil::translateBlendFactor(targetBlendDesc.color.srcFactor));
-            colorAttachment->setDestinationRGBBlendFactor(MetalUtil::translateBlendFactor(targetBlendDesc.color.dstFactor));
-            colorAttachment->setRgbBlendOperation(MetalUtil::translateBlendOperation(targetBlendDesc.color.op));
-            colorAttachment->setSourceAlphaBlendFactor(MetalUtil::translateBlendFactor(targetBlendDesc.alpha.srcFactor));
-            colorAttachment->setDestinationAlphaBlendFactor(MetalUtil::translateBlendFactor(targetBlendDesc.alpha.dstFactor));
-            colorAttachment->setAlphaBlendOperation(MetalUtil::translateBlendOperation(targetBlendDesc.alpha.op));
-            colorAttachment->setWriteMask(MetalUtil::translateColorWriteMask(targetBlendDesc.writeMask));
+            colorAttachment->setSourceRGBBlendFactor(
+                MetalUtil::translateBlendFactor(targetBlendDesc.color.srcFactor));
+            colorAttachment->setDestinationRGBBlendFactor(
+                MetalUtil::translateBlendFactor(targetBlendDesc.color.dstFactor));
+            colorAttachment->setRgbBlendOperation(
+                MetalUtil::translateBlendOperation(targetBlendDesc.color.op));
+            colorAttachment->setSourceAlphaBlendFactor(
+                MetalUtil::translateBlendFactor(targetBlendDesc.alpha.srcFactor));
+            colorAttachment->setDestinationAlphaBlendFactor(
+                MetalUtil::translateBlendFactor(targetBlendDesc.alpha.dstFactor));
+            colorAttachment->setAlphaBlendOperation(
+                MetalUtil::translateBlendOperation(targetBlendDesc.alpha.op));
+            colorAttachment->setWriteMask(
+                MetalUtil::translateColorWriteMask(targetBlendDesc.writeMask));
         }
         sampleCount = Math::Max(sampleCount, targetLayout.sampleCount);
     }
     if (framebufferLayoutImpl->m_depthStencil.format != Format::Unknown)
     {
-        const IFramebufferLayout::TargetLayout& depthStencil = framebufferLayoutImpl->m_depthStencil;
+        const IFramebufferLayout::TargetLayout& depthStencil =
+            framebufferLayoutImpl->m_depthStencil;
         MTL::PixelFormat pixelFormat = MetalUtil::translatePixelFormat(depthStencil.format);
         if (MetalUtil::isDepthFormat(pixelFormat))
         {
@@ -123,14 +131,16 @@ Result PipelineStateImpl::createMetalRenderPipelineState()
         }
         if (MetalUtil::isStencilFormat(pixelFormat))
         {
-            pd->setStencilAttachmentPixelFormat(MetalUtil::translatePixelFormat(depthStencil.format));
+            pd->setStencilAttachmentPixelFormat(
+                MetalUtil::translatePixelFormat(depthStencil.format));
         }
     }
 
     pd->setRasterSampleCount(sampleCount);
-    
+
     NS::Error* error;
-    m_renderPipelineState = NS::TransferPtr(m_device->m_device->newRenderPipelineState(pd.get(), &error));
+    m_renderPipelineState =
+        NS::TransferPtr(m_device->m_device->newRenderPipelineState(pd.get(), &error));
     if (!m_renderPipelineState)
     {
         std::cout << error->localizedDescription()->utf8String() << std::endl;
@@ -138,34 +148,52 @@ Result PipelineStateImpl::createMetalRenderPipelineState()
     }
 
     // Create depth stencil state
-    auto createStencilDesc = [](const DepthStencilOpDesc& desc, uint32_t readMask, uint32_t writeMask) -> NS::SharedPtr<MTL::StencilDescriptor>
+    auto createStencilDesc = [](const DepthStencilOpDesc& desc,
+                                uint32_t readMask,
+                                uint32_t writeMask) -> NS::SharedPtr<MTL::StencilDescriptor>
     {
-        NS::SharedPtr<MTL::StencilDescriptor> stencilDesc = NS::TransferPtr(MTL::StencilDescriptor::alloc()->init());
-        stencilDesc->setStencilCompareFunction(MetalUtil::translateCompareFunction(desc.stencilFunc));
-        stencilDesc->setStencilFailureOperation(MetalUtil::translateStencilOperation(desc.stencilFailOp));
-        stencilDesc->setDepthFailureOperation(MetalUtil::translateStencilOperation(desc.stencilDepthFailOp));
-        stencilDesc->setDepthStencilPassOperation(MetalUtil::translateStencilOperation(desc.stencilPassOp));
+        NS::SharedPtr<MTL::StencilDescriptor> stencilDesc =
+            NS::TransferPtr(MTL::StencilDescriptor::alloc()->init());
+        stencilDesc->setStencilCompareFunction(
+            MetalUtil::translateCompareFunction(desc.stencilFunc));
+        stencilDesc->setStencilFailureOperation(
+            MetalUtil::translateStencilOperation(desc.stencilFailOp));
+        stencilDesc->setDepthFailureOperation(
+            MetalUtil::translateStencilOperation(desc.stencilDepthFailOp));
+        stencilDesc->setDepthStencilPassOperation(
+            MetalUtil::translateStencilOperation(desc.stencilPassOp));
         stencilDesc->setReadMask(readMask);
         stencilDesc->setWriteMask(writeMask);
         return stencilDesc;
     };
 
     const auto& depthStencil = desc.graphics.depthStencil;
-    NS::SharedPtr<MTL::DepthStencilDescriptor> depthStencilDesc = NS::TransferPtr(MTL::DepthStencilDescriptor::alloc()->init());
-    m_depthStencilState = NS::TransferPtr(m_device->m_device->newDepthStencilState(depthStencilDesc.get()));
+    NS::SharedPtr<MTL::DepthStencilDescriptor> depthStencilDesc =
+        NS::TransferPtr(MTL::DepthStencilDescriptor::alloc()->init());
+    m_depthStencilState =
+        NS::TransferPtr(m_device->m_device->newDepthStencilState(depthStencilDesc.get()));
     if (!m_depthStencilState)
     {
         return SLANG_FAIL;
     }
     if (depthStencil.depthTestEnable)
     {
-        depthStencilDesc->setDepthCompareFunction(MetalUtil::translateCompareFunction(depthStencil.depthFunc));
+        depthStencilDesc->setDepthCompareFunction(
+            MetalUtil::translateCompareFunction(depthStencil.depthFunc));
     }
     depthStencilDesc->setDepthWriteEnabled(depthStencil.depthWriteEnable);
     if (depthStencil.stencilEnable)
     {
-        depthStencilDesc->setFrontFaceStencil(createStencilDesc(depthStencil.frontFace, depthStencil.stencilReadMask, depthStencil.stencilWriteMask).get());
-        depthStencilDesc->setBackFaceStencil(createStencilDesc(depthStencil.backFace, depthStencil.stencilReadMask, depthStencil.stencilWriteMask).get());
+        depthStencilDesc->setFrontFaceStencil(createStencilDesc(
+                                                  depthStencil.frontFace,
+                                                  depthStencil.stencilReadMask,
+                                                  depthStencil.stencilWriteMask)
+                                                  .get());
+        depthStencilDesc->setBackFaceStencil(createStencilDesc(
+                                                 depthStencil.backFace,
+                                                 depthStencil.stencilReadMask,
+                                                 depthStencil.stencilWriteMask)
+                                                 .get());
     }
 
     return SLANG_OK;
@@ -179,16 +207,20 @@ Result PipelineStateImpl::createMetalComputePipelineState()
 
     const ShaderProgramImpl::Module& module = programImpl->m_modules[0];
     auto functionName = MetalUtil::createString(module.entryPointName.getBuffer());
-    NS::SharedPtr<MTL::Function> function = NS::TransferPtr(module.library->newFunction(functionName.get()));
+    NS::SharedPtr<MTL::Function> function =
+        NS::TransferPtr(module.library->newFunction(functionName.get()));
     if (!function)
         return SLANG_FAIL;
 
-    NS::Error *error;
-    m_computePipelineState = NS::TransferPtr(m_device->m_device->newComputePipelineState(function.get(), &error));
+    NS::Error* error;
+    m_computePipelineState =
+        NS::TransferPtr(m_device->m_device->newComputePipelineState(function.get(), &error));
 
     // Query thread group size for use during dispatch.
     SlangUInt threadGroupSize[3];
-    programImpl->linkedProgram->getLayout()->getEntryPointByIndex(0)->getComputeThreadGroupSize(3, threadGroupSize);
+    programImpl->linkedProgram->getLayout()->getEntryPointByIndex(0)->getComputeThreadGroupSize(
+        3,
+        threadGroupSize);
     m_threadGroupSize = MTL::Size(threadGroupSize[0], threadGroupSize[1], threadGroupSize[2]);
 
     return m_computePipelineState ? SLANG_OK : SLANG_FAIL;
@@ -197,16 +229,14 @@ Result PipelineStateImpl::createMetalComputePipelineState()
 Result PipelineStateImpl::ensureAPIPipelineStateCreated()
 {
     AUTORELEASEPOOL
-    
+
     switch (desc.type)
     {
     case PipelineType::Compute:
         return m_computePipelineState ? SLANG_OK : createMetalComputePipelineState();
     case PipelineType::Graphics:
         return m_renderPipelineState ? SLANG_OK : createMetalRenderPipelineState();
-    default:
-        SLANG_UNREACHABLE("Unknown pipeline type.");
-        return SLANG_FAIL;
+    default: SLANG_UNREACHABLE("Unknown pipeline type."); return SLANG_FAIL;
     }
     return SLANG_OK;
 }
@@ -229,7 +259,8 @@ SLANG_NO_THROW Result SLANG_MCALL PipelineStateImpl::getNativeHandle(InteropHand
 
 RayTracingPipelineStateImpl::RayTracingPipelineStateImpl(DeviceImpl* device)
     : PipelineStateImpl(device)
-{}
+{
+}
 
 Result RayTracingPipelineStateImpl::ensureAPIPipelineStateCreated()
 {
@@ -242,6 +273,5 @@ Result RayTracingPipelineStateImpl::getNativeHandle(InteropHandle* outHandle)
 }
 
 
-
 } // namespace metal
 } // namespace gfx
diff --git a/tools/gfx/metal/metal-query.cpp b/tools/gfx/metal/metal-query.cpp
index 4e1d09d77..6075d5549 100644
--- a/tools/gfx/metal/metal-query.cpp
+++ b/tools/gfx/metal/metal-query.cpp
@@ -1,7 +1,7 @@
 // metal-query.cpp
 #include "metal-query.h"
 
-//#include "metal-util.h"
+// #include "metal-util.h"
 
 namespace gfx
 {
@@ -11,9 +11,7 @@ using namespace Slang;
 namespace metal
 {
 
-QueryPoolImpl::~QueryPoolImpl()
-{
-}
+QueryPoolImpl::~QueryPoolImpl() {}
 
 static MTL::CounterSet* findCounterSet(MTL::Device* device, QueryType queryType)
 {
@@ -26,7 +24,8 @@ static MTL::CounterSet* findCounterSet(MTL::Device* device, QueryType queryType)
 
     for (int i = 0; i < device->counterSets()->count(); ++i)
     {
-        MTL::CounterSet* counterSet = static_cast<MTL::CounterSet*>(device->counterSets()->object(i));
+        MTL::CounterSet* counterSet =
+            static_cast<MTL::CounterSet*>(device->counterSets()->object(i));
         for (int j = 0; j < counterSet->counters()->count(); ++j)
         {
             MTL::Counter* counter = static_cast<MTL::Counter*>(counterSet->counters()->object(j));
@@ -50,7 +49,8 @@ Result QueryPoolImpl::init(DeviceImpl* device, const IQueryPool::Desc& desc)
         return SLANG_E_NOT_AVAILABLE;
     }
 
-    NS::SharedPtr<MTL::CounterSampleBufferDescriptor> counterSampleBufferDesc = NS::TransferPtr(MTL::CounterSampleBufferDescriptor::alloc()->init());
+    NS::SharedPtr<MTL::CounterSampleBufferDescriptor> counterSampleBufferDesc =
+        NS::TransferPtr(MTL::CounterSampleBufferDescriptor::alloc()->init());
     counterSampleBufferDesc->setStorageMode(MTL::StorageModeShared);
     counterSampleBufferDesc->setSampleCount(m_desc.count);
     counterSampleBufferDesc->setCounterSet(counterSet);
@@ -58,7 +58,8 @@ Result QueryPoolImpl::init(DeviceImpl* device, const IQueryPool::Desc& desc)
     m_device->m_device->counterSets();
 
     NS::Error* error;
-    m_counterSampleBuffer = NS::TransferPtr(m_device->m_device->newCounterSampleBuffer(counterSampleBufferDesc.get(), &error));
+    m_counterSampleBuffer = NS::TransferPtr(
+        m_device->m_device->newCounterSampleBuffer(counterSampleBufferDesc.get(), &error));
 
     return m_counterSampleBuffer ? SLANG_OK : SLANG_FAIL;
 }
diff --git a/tools/gfx/metal/metal-query.h b/tools/gfx/metal/metal-query.h
index 3b3e28489..55dc9ebbe 100644
--- a/tools/gfx/metal/metal-query.h
+++ b/tools/gfx/metal/metal-query.h
@@ -23,8 +23,7 @@ public:
     Result init(DeviceImpl* device, const IQueryPool::Desc& desc);
 
     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;
 };
 
 } // namespace metal
diff --git a/tools/gfx/metal/metal-render-pass.cpp b/tools/gfx/metal/metal-render-pass.cpp
index bc60cf746..49e470028 100644
--- a/tools/gfx/metal/metal-render-pass.cpp
+++ b/tools/gfx/metal/metal-render-pass.cpp
@@ -1,7 +1,7 @@
 // metal-render-pass.cpp
 #include "metal-render-pass.h"
 
-//#include "metal-helper-functions.h"
+// #include "metal-helper-functions.h"
 
 namespace gfx
 {
@@ -22,14 +22,10 @@ static inline MTL::LoadAction translateLoadOp(IRenderPassLayout::TargetLoadOp lo
 {
     switch (loadOp)
     {
-    case IRenderPassLayout::TargetLoadOp::Load:
-        return MTL::LoadActionLoad;
-    case IRenderPassLayout::TargetLoadOp::Clear:
-        return MTL::LoadActionClear;
-    case IRenderPassLayout::TargetLoadOp::DontCare:
-        return MTL::LoadActionDontCare;
-    default:
-        return MTL::LoadAction(0);
+    case IRenderPassLayout::TargetLoadOp::Load:     return MTL::LoadActionLoad;
+    case IRenderPassLayout::TargetLoadOp::Clear:    return MTL::LoadActionClear;
+    case IRenderPassLayout::TargetLoadOp::DontCare: return MTL::LoadActionDontCare;
+    default:                                        return MTL::LoadAction(0);
     }
 }
 
@@ -37,12 +33,9 @@ static inline MTL::StoreAction translateStoreOp(IRenderPassLayout::TargetStoreOp
 {
     switch (storeOp)
     {
-    case IRenderPassLayout::TargetStoreOp::Store:
-        return MTL::StoreActionStore;
-    case IRenderPassLayout::TargetStoreOp::DontCare:
-        return MTL::StoreActionDontCare;
-    default:
-        return MTL::StoreAction(0);
+    case IRenderPassLayout::TargetStoreOp::Store:    return MTL::StoreActionStore;
+    case IRenderPassLayout::TargetStoreOp::DontCare: return MTL::StoreActionDontCare;
+    default:                                         return MTL::StoreAction(0);
     }
 }
 
@@ -50,25 +43,32 @@ Result RenderPassLayoutImpl::init(DeviceImpl* device, const IRenderPassLayout::D
 {
     m_device = device;
 
-    FramebufferLayoutImpl* framebufferLayout = static_cast<FramebufferLayoutImpl*>(desc.framebufferLayout);
+    FramebufferLayoutImpl* framebufferLayout =
+        static_cast<FramebufferLayoutImpl*>(desc.framebufferLayout);
     assert(framebufferLayout);
 
-    // Initialize render pass descriptor, filling in attachment metadata, but leaving texture data unbound.
+    // Initialize render pass descriptor, filling in attachment metadata, but leaving texture data
+    // unbound.
     m_renderPassDesc = NS::TransferPtr(MTL::RenderPassDescriptor::alloc()->init());
 
     m_renderPassDesc->setRenderTargetArrayLength(desc.renderTargetCount);
     for (GfxIndex i = 0; i < desc.renderTargetCount; ++i)
     {
-        MTL::RenderPassColorAttachmentDescriptor* colorAttachment = m_renderPassDesc->colorAttachments()->object(i);
+        MTL::RenderPassColorAttachmentDescriptor* colorAttachment =
+            m_renderPassDesc->colorAttachments()->object(i);
         colorAttachment->setLoadAction(translateLoadOp(desc.renderTargetAccess[i].loadOp));
         colorAttachment->setStoreAction(translateStoreOp(desc.renderTargetAccess[i].storeOp));
     }
 
-    m_renderPassDesc->depthAttachment()->setLoadAction(translateLoadOp(desc.depthStencilAccess->loadOp));
-    m_renderPassDesc->depthAttachment()->setStoreAction(translateStoreOp(desc.depthStencilAccess->storeOp));
+    m_renderPassDesc->depthAttachment()->setLoadAction(
+        translateLoadOp(desc.depthStencilAccess->loadOp));
+    m_renderPassDesc->depthAttachment()->setStoreAction(
+        translateStoreOp(desc.depthStencilAccess->storeOp));
 
-    m_renderPassDesc->stencilAttachment()->setLoadAction(translateLoadOp(desc.depthStencilAccess->loadOp));
-    m_renderPassDesc->stencilAttachment()->setStoreAction(translateStoreOp(desc.depthStencilAccess->storeOp));
+    m_renderPassDesc->stencilAttachment()->setLoadAction(
+        translateLoadOp(desc.depthStencilAccess->loadOp));
+    m_renderPassDesc->stencilAttachment()->setStoreAction(
+        translateStoreOp(desc.depthStencilAccess->storeOp));
 
     return SLANG_OK;
 }
diff --git a/tools/gfx/metal/metal-render-pass.h b/tools/gfx/metal/metal-render-pass.h
index ee66b0c4d..94659a561 100644
--- a/tools/gfx/metal/metal-render-pass.h
+++ b/tools/gfx/metal/metal-render-pass.h
@@ -12,9 +12,7 @@ using namespace Slang;
 namespace metal
 {
 
-class RenderPassLayoutImpl
-    : public IRenderPassLayout
-    , public ComObject
+class RenderPassLayoutImpl : public IRenderPassLayout, public ComObject
 {
 public:
     SLANG_COM_OBJECT_IUNKNOWN_ALL
diff --git a/tools/gfx/metal/metal-resource-views.cpp b/tools/gfx/metal/metal-resource-views.cpp
index ea5c23c10..2f8a4b16e 100644
--- a/tools/gfx/metal/metal-resource-views.cpp
+++ b/tools/gfx/metal/metal-resource-views.cpp
@@ -9,9 +9,7 @@ using namespace Slang;
 namespace metal
 {
 
-TextureResourceViewImpl::~TextureResourceViewImpl()
-{
-}
+TextureResourceViewImpl::~TextureResourceViewImpl() {}
 
 Result TextureResourceViewImpl::getNativeHandle(InteropHandle* outHandle)
 {
@@ -20,9 +18,7 @@ Result TextureResourceViewImpl::getNativeHandle(InteropHandle* outHandle)
     return SLANG_OK;
 }
 
-BufferResourceViewImpl::~BufferResourceViewImpl()
-{
-}
+BufferResourceViewImpl::~BufferResourceViewImpl() {}
 
 Result BufferResourceViewImpl::getNativeHandle(InteropHandle* outHandle)
 {
@@ -33,12 +29,11 @@ Result BufferResourceViewImpl::getNativeHandle(InteropHandle* outHandle)
 
 TexelBufferResourceViewImpl::TexelBufferResourceViewImpl(DeviceImpl* device)
     : ResourceViewImpl(ViewType::TexelBuffer, device)
-{}
-
-TexelBufferResourceViewImpl::~TexelBufferResourceViewImpl()
 {
 }
 
+TexelBufferResourceViewImpl::~TexelBufferResourceViewImpl() {}
+
 Result TexelBufferResourceViewImpl::getNativeHandle(InteropHandle* outHandle)
 {
     return SLANG_E_NOT_IMPLEMENTED;
@@ -54,9 +49,7 @@ Result AccelerationStructureImpl::getNativeHandle(InteropHandle* outHandle)
     return SLANG_E_NOT_IMPLEMENTED;
 }
 
-AccelerationStructureImpl::~AccelerationStructureImpl()
-{
-}
+AccelerationStructureImpl::~AccelerationStructureImpl() {}
 
 } // namespace metal
 } // namespace gfx
diff --git a/tools/gfx/metal/metal-resource-views.h b/tools/gfx/metal/metal-resource-views.h
index 89986f19d..ae494c2fb 100644
--- a/tools/gfx/metal/metal-resource-views.h
+++ b/tools/gfx/metal/metal-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;
     NS::SharedPtr<MTL::Texture> m_textureView;
@@ -51,7 +52,8 @@ class BufferResourceViewImpl : public ResourceViewImpl
 public:
     BufferResourceViewImpl(DeviceImpl* device)
         : ResourceViewImpl(ViewType::Buffer, device)
-    {}
+    {
+    }
     ~BufferResourceViewImpl();
     RefPtr<BufferResourceImpl> m_buffer;
     Offset m_offset;
diff --git a/tools/gfx/metal/metal-sampler.cpp b/tools/gfx/metal/metal-sampler.cpp
index 561b93ea2..6f0c0e36b 100644
--- a/tools/gfx/metal/metal-sampler.cpp
+++ b/tools/gfx/metal/metal-sampler.cpp
@@ -1,5 +1,6 @@
 // metal-sampler.cpp
 #include "metal-sampler.h"
+
 #include "metal-util.h"
 
 namespace gfx
@@ -10,15 +11,14 @@ using namespace Slang;
 namespace metal
 {
 
-SamplerStateImpl::~SamplerStateImpl()
-{
-}
+SamplerStateImpl::~SamplerStateImpl() {}
 
 Result SamplerStateImpl::init(DeviceImpl* device, const ISamplerState::Desc& desc)
 {
     m_device = device;
 
-    NS::SharedPtr<MTL::SamplerDescriptor> samplerDesc = NS::TransferPtr(MTL::SamplerDescriptor::alloc()->init());
+    NS::SharedPtr<MTL::SamplerDescriptor> samplerDesc =
+        NS::TransferPtr(MTL::SamplerDescriptor::alloc()->init());
 
     samplerDesc->setMinFilter(MetalUtil::translateSamplerMinMagFilter(desc.minFilter));
     samplerDesc->setMagFilter(MetalUtil::translateSamplerMinMagFilter(desc.magFilter));
@@ -45,7 +45,7 @@ Result SamplerStateImpl::init(DeviceImpl* device, const ISamplerState::Desc& des
     // TODO: no support for reduction op
 
     m_samplerState = NS::TransferPtr(m_device->m_device->newSamplerState(samplerDesc.get()));
-    
+
     return m_samplerState ? SLANG_OK : SLANG_FAIL;
 }
 
diff --git a/tools/gfx/metal/metal-sampler.h b/tools/gfx/metal/metal-sampler.h
index c7156cb2e..0d94a6d2d 100644
--- a/tools/gfx/metal/metal-sampler.h
+++ b/tools/gfx/metal/metal-sampler.h
@@ -21,7 +21,7 @@ public:
     ~SamplerStateImpl();
 
     Result init(DeviceImpl* device, const ISamplerState::Desc& desc);
-    
+
     virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outHandle) override;
 };
 
diff --git a/tools/gfx/metal/metal-shader-object-layout.cpp b/tools/gfx/metal/metal-shader-object-layout.cpp
index 94bcb6db6..e674b830a 100644
--- a/tools/gfx/metal/metal-shader-object-layout.cpp
+++ b/tools/gfx/metal/metal-shader-object-layout.cpp
@@ -29,7 +29,8 @@ ShaderObjectLayoutImpl::SubObjectRangeStride::SubObjectRangeStride(
     }
 }
 
-Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(slang::TypeLayoutReflection* typeLayout)
+Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(
+    slang::TypeLayoutReflection* typeLayout)
 {
     typeLayout = _unwrapParameterGroups(typeLayout, m_containerType);
 
@@ -94,8 +95,7 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(slang::TypeLayoutRe
             m_textureCount += count;
             m_textureRanges.add(r);
             break;
-        default:
-            break;
+        default: break;
         }
 
         // We'd like to extract the information on the Metal resource
@@ -125,7 +125,9 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(slang::TypeLayoutRe
             SLANG_ASSERT(descriptorSetIndex == 0);
 
             SlangInt descriptorRangeIndex = typeLayout->getBindingRangeFirstDescriptorRangeIndex(r);
-            auto registerOffset = typeLayout->getDescriptorSetDescriptorRangeIndexOffset(descriptorSetIndex, descriptorRangeIndex);
+            auto registerOffset = typeLayout->getDescriptorSetDescriptorRangeIndexOffset(
+                descriptorSetIndex,
+                descriptorRangeIndex);
 
             bindingRangeInfo.registerOffset = (uint32_t)registerOffset;
         }
@@ -160,18 +162,18 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(slang::TypeLayoutRe
         switch (slangBindingType)
         {
         default:
-        {
-            // In the case of `ConstantBuffer<X>` or `ParameterBlock<X>`
-            // we can construct a layout from the element type directly.
-            //
-            auto elementTypeLayout = slangLeafTypeLayout->getElementTypeLayout();
-            createForElementType(
-                m_renderer,
-                m_session,
-                elementTypeLayout,
-                subObjectLayout.writeRef());
-        }
-        break;
+            {
+                // In the case of `ConstantBuffer<X>` or `ParameterBlock<X>`
+                // we can construct a layout from the element type directly.
+                //
+                auto elementTypeLayout = slangLeafTypeLayout->getElementTypeLayout();
+                createForElementType(
+                    m_renderer,
+                    m_session,
+                    elementTypeLayout,
+                    subObjectLayout.writeRef());
+            }
+            break;
         case slang::BindingType::ExistentialValue:
             // In the case of an interface-type sub-object range, we can only
             // construct a layout if we have static specialization information
@@ -193,8 +195,9 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(slang::TypeLayoutRe
                 // increase the size of the ordinary data buffer we need to
                 // allocate for the parent object.
                 //
-                uint32_t ordinaryDataEnd = subObjectRange.offset.pendingOrdinaryData
-                    + (uint32_t)bindingRange.count * subObjectRange.stride.pendingOrdinaryData;
+                uint32_t ordinaryDataEnd =
+                    subObjectRange.offset.pendingOrdinaryData +
+                    (uint32_t)bindingRange.count * subObjectRange.stride.pendingOrdinaryData;
 
                 if (ordinaryDataEnd > m_totalOrdinaryDataSize)
                 {
@@ -211,8 +214,7 @@ Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(slang::TypeLayoutRe
 
 SlangResult ShaderObjectLayoutImpl::Builder::build(ShaderObjectLayoutImpl** outLayout)
 {
-    auto layout =
-        RefPtr<ShaderObjectLayoutImpl>(new ShaderObjectLayoutImpl());
+    auto layout = RefPtr<ShaderObjectLayoutImpl>(new ShaderObjectLayoutImpl());
     SLANG_RETURN_ON_FAIL(layout->_init(this));
 
     returnRefPtrMove(outLayout, layout);
@@ -224,7 +226,9 @@ slang::TypeLayoutReflection* ShaderObjectLayoutImpl::getParameterBlockTypeLayout
     if (!m_parameterBlockTypeLayout)
     {
         m_parameterBlockTypeLayout = m_slangSession->getTypeLayout(
-            m_elementTypeLayout->getType(), 0, slang::LayoutRules::MetalArgumentBufferTier2);
+            m_elementTypeLayout->getType(),
+            0,
+            slang::LayoutRules::MetalArgumentBufferTier2);
     }
     return m_parameterBlockTypeLayout;
 }
@@ -272,13 +276,16 @@ Result RootShaderObjectLayoutImpl::Builder::build(RootShaderObjectLayoutImpl** o
     return SLANG_OK;
 }
 
-void RootShaderObjectLayoutImpl::Builder::addGlobalParams(slang::VariableLayoutReflection* globalsLayout)
+void RootShaderObjectLayoutImpl::Builder::addGlobalParams(
+    slang::VariableLayoutReflection* globalsLayout)
 {
     setElementTypeLayout(globalsLayout->getTypeLayout());
 }
 
 void RootShaderObjectLayoutImpl::Builder::addEntryPoint(
-    SlangStage stage, ShaderObjectLayoutImpl* entryPointLayout, slang::EntryPointLayout* slangEntryPoint)
+    SlangStage stage,
+    ShaderObjectLayoutImpl* entryPointLayout,
+    slang::EntryPointLayout* slangEntryPoint)
 {
     EntryPointInfo info;
     info.layout = entryPointLayout;
@@ -301,7 +308,10 @@ Result RootShaderObjectLayoutImpl::create(
         auto slangEntryPoint = programLayout->getEntryPointByIndex(e);
         RefPtr<ShaderObjectLayoutImpl> entryPointLayout;
         SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType(
-            renderer, program->getSession(), slangEntryPoint->getTypeLayout(), entryPointLayout.writeRef()));
+            renderer,
+            program->getSession(),
+            slangEntryPoint->getTypeLayout(),
+            entryPointLayout.writeRef()));
         builder.addEntryPoint(slangEntryPoint->getStage(), entryPointLayout, slangEntryPoint);
     }
 
diff --git a/tools/gfx/metal/metal-shader-object-layout.h b/tools/gfx/metal/metal-shader-object-layout.h
index 24a969c89..02833e4ca 100644
--- a/tools/gfx/metal/metal-shader-object-layout.h
+++ b/tools/gfx/metal/metal-shader-object-layout.h
@@ -63,8 +63,7 @@ public:
     /// Offset information for a sub-object range
     struct SubObjectRangeOffset : BindingOffset
     {
-        SubObjectRangeOffset()
-        {}
+        SubObjectRangeOffset() {}
 
         SubObjectRangeOffset(slang::VariableLayoutReflection* varLayout);
 
@@ -75,8 +74,7 @@ public:
     /// Stride information for a sub-object range
     struct SubObjectRangeStride : BindingOffset
     {
-        SubObjectRangeStride()
-        {}
+        SubObjectRangeStride() {}
 
         SubObjectRangeStride(slang::TypeLayoutReflection* typeLayout);
 
@@ -105,7 +103,8 @@ public:
     public:
         Builder(RendererBase* renderer, slang::ISession* session)
             : m_renderer(renderer), m_session(session)
-        {}
+        {
+        }
 
         RendererBase* m_renderer;
         slang::ISession* m_session;
@@ -129,7 +128,7 @@ public:
         Index m_subObjectCount = 0;
 
         uint32_t m_totalOrdinaryDataSize = 0;
-            
+
         /// The container type of this shader object. When `m_containerType` is
         /// `StructuredBuffer` or `Array`, this shader object represents a collection
         /// instead of a single object.
@@ -161,10 +160,7 @@ public:
 
     RendererBase* getRenderer() { return m_renderer; }
 
-    slang::TypeReflection* getType()
-    {
-        return m_elementTypeLayout->getType();
-    }
+    slang::TypeReflection* getType() { return m_elementTypeLayout->getType(); }
 
     /// Get the indices that represent all the buffer ranges in this type
     List<Index> const& getBufferRanges() const { return m_bufferRanges; }
@@ -178,6 +174,7 @@ public:
     uint32_t getTotalOrdinaryDataSize() const { return m_totalOrdinaryDataSize; }
 
     slang::TypeLayoutReflection* getParameterBlockTypeLayout();
+
 protected:
     Result _init(Builder const* builder);
 
@@ -204,7 +201,8 @@ public:
     {
         RefPtr<ShaderObjectLayoutImpl> layout;
 
-        /// The offset for this entry point's parameters, relative to the starting offset for the program
+        /// The offset for this entry point's parameters, relative to the starting offset for the
+        /// program
         BindingOffset offset;
     };
 
@@ -217,11 +215,15 @@ public:
             : Super::Builder(renderer, program->getSession())
             , m_program(program)
             , m_programLayout(programLayout)
-        {}
+        {
+        }
 
         Result build(RootShaderObjectLayoutImpl** outLayout);
         void addGlobalParams(slang::VariableLayoutReflection* globalsLayout);
-        void addEntryPoint(SlangStage stage, ShaderObjectLayoutImpl* entryPointLayout, slang::EntryPointLayout* slangEntryPoint);
+        void addEntryPoint(
+            SlangStage stage,
+            ShaderObjectLayoutImpl* entryPointLayout,
+            slang::EntryPointLayout* slangEntryPoint);
 
         slang::IComponentType* m_program;
         slang::ProgramLayout* m_programLayout;
@@ -244,7 +246,7 @@ public:
 protected:
     Result _init(Builder const* builder);
 
-    ComPtr<slang::IComponentType>   m_program;
+    ComPtr<slang::IComponentType> m_program;
     slang::ProgramLayout* m_programLayout = nullptr;
 
     List<EntryPointInfo> m_entryPoints;
diff --git a/tools/gfx/metal/metal-shader-object.cpp b/tools/gfx/metal/metal-shader-object.cpp
index 6d421e065..7ee7e8023 100644
--- a/tools/gfx/metal/metal-shader-object.cpp
+++ b/tools/gfx/metal/metal-shader-object.cpp
@@ -1,8 +1,8 @@
 // metal-shader-object.cpp
 #include "metal-shader-object.h"
-#include "metal-sampler.h"
 
 #include "metal-device.h"
+#include "metal-sampler.h"
 
 namespace gfx
 {
@@ -24,12 +24,10 @@ Result ShaderObjectImpl::create(
     return SLANG_OK;
 }
 
-ShaderObjectImpl::~ShaderObjectImpl()
-{
-}
+ShaderObjectImpl::~ShaderObjectImpl() {}
 
 SLANG_NO_THROW Result SLANG_MCALL
-    ShaderObjectImpl::setData(ShaderOffset const& inOffset, void const* data, size_t inSize)
+ShaderObjectImpl::setData(ShaderOffset const& inOffset, void const* data, size_t inSize)
 {
     Index offset = inOffset.uniformOffset;
     Index size = inSize;
@@ -59,7 +57,7 @@ SLANG_NO_THROW Result SLANG_MCALL
 }
 
 SLANG_NO_THROW Result SLANG_MCALL
-    ShaderObjectImpl::setResource(ShaderOffset const& offset, IResourceView* resourceView)
+ShaderObjectImpl::setResource(ShaderOffset const& offset, IResourceView* resourceView)
 {
     if (offset.bindingRangeIndex < 0)
         return SLANG_E_INVALID_ARG;
@@ -74,26 +72,30 @@ SLANG_NO_THROW Result SLANG_MCALL
     case slang::BindingType::Texture:
     case slang::BindingType::MutableTexture:
         SLANG_ASSERT(resourceViewImpl->m_type == ResourceViewImpl::ViewType::Texture);
-        m_textures[bindingRange.baseIndex + offset.bindingArrayIndex] = static_cast<TextureResourceViewImpl*>(resourceView);
+        m_textures[bindingRange.baseIndex + offset.bindingArrayIndex] =
+            static_cast<TextureResourceViewImpl*>(resourceView);
         break;
     case slang::BindingType::RawBuffer:
     case slang::BindingType::ConstantBuffer:
     case slang::BindingType::MutableRawBuffer:
         SLANG_ASSERT(resourceViewImpl->m_type == ResourceViewImpl::ViewType::Buffer);
-        m_buffers[bindingRange.baseIndex + offset.bindingArrayIndex] = static_cast<BufferResourceViewImpl*>(resourceView);
+        m_buffers[bindingRange.baseIndex + offset.bindingArrayIndex] =
+            static_cast<BufferResourceViewImpl*>(resourceView);
         break;
     case slang::BindingType::TypedBuffer:
     case slang::BindingType::MutableTypedBuffer:
         SLANG_ASSERT(!"Not implemented");
         // SLANG_ASSERT(resourceViewImpl->m_type == ResourceViewImpl::ViewType::TexelBuffer);
-        // m_textures[bindingRange.baseIndex + offset.bindingArrayIndex] = static_cast<TextureResourceViewImpl*>(resourceView);
+        // m_textures[bindingRange.baseIndex + offset.bindingArrayIndex] =
+        // static_cast<TextureResourceViewImpl*>(resourceView);
         break;
     }
     m_isArgumentBufferDirty = true;
     return SLANG_OK;
 }
 
-SLANG_NO_THROW Result SLANG_MCALL ShaderObjectImpl::setSampler(ShaderOffset const& offset, ISamplerState* sampler)
+SLANG_NO_THROW Result SLANG_MCALL
+ShaderObjectImpl::setSampler(ShaderOffset const& offset, ISamplerState* sampler)
 {
     if (offset.bindingRangeIndex < 0)
         return SLANG_E_INVALID_ARG;
@@ -102,7 +104,8 @@ SLANG_NO_THROW Result SLANG_MCALL ShaderObjectImpl::setSampler(ShaderOffset cons
         return SLANG_E_INVALID_ARG;
     auto& bindingRange = layout->getBindingRange(offset.bindingRangeIndex);
 
-    m_samplers[bindingRange.baseIndex + offset.bindingArrayIndex] = static_cast<SamplerStateImpl*>(sampler);
+    m_samplers[bindingRange.baseIndex + offset.bindingArrayIndex] =
+        static_cast<SamplerStateImpl*>(sampler);
     m_isArgumentBufferDirty = true;
     return SLANG_OK;
 }
@@ -169,7 +172,7 @@ Result ShaderObjectImpl::init(IDevice* device, ShaderObjectLayoutImpl* layout)
 
 Result ShaderObjectImpl::_writeOrdinaryData(
     void* dest,
-    size_t                  destSize,
+    size_t destSize,
     ShaderObjectLayoutImpl* layout)
 {
     // We start by simply writing in the ordinary data contained directly in this object.
@@ -197,7 +200,8 @@ Result ShaderObjectImpl::_writeOrdinaryData(
     for (auto const& subObjectRangeInfo : layout->getSubObjectRanges())
     {
         Index subObjectRangeIndex = subObjectRangeCounter++;
-        auto const& bindingRangeInfo = layout->getBindingRange(subObjectRangeInfo.bindingRangeIndex);
+        auto const& bindingRangeInfo =
+            layout->getBindingRange(subObjectRangeInfo.bindingRangeIndex);
 
         // We only need to handle sub-object ranges for interface/existential-type fields,
         // because fields of constant-buffer or parameter-block type are responsible for
@@ -250,11 +254,15 @@ Result ShaderObjectImpl::_writeOrdinaryData(
 
             ShaderObjectLayoutImpl* subObjectLayout = subObject->getLayout();
 
-            auto subObjectOffset = subObjectRangePendingDataOffset + i * subObjectRangePendingDataStride;
+            auto subObjectOffset =
+                subObjectRangePendingDataOffset + i * subObjectRangePendingDataStride;
 
             auto subObjectDest = (char*)dest + subObjectOffset;
 
-            subObject->_writeOrdinaryData(subObjectDest, destSize - subObjectOffset, subObjectLayout);
+            subObject->_writeOrdinaryData(
+                subObjectDest,
+                destSize - subObjectOffset,
+                subObjectLayout);
         }
     }
     return SLANG_OK;
@@ -294,7 +302,7 @@ Result ShaderObjectImpl::_ensureOrdinaryDataBufferCreatedIfNeeded(
         // don't need or want to inline it into this call site.
         //
 
-        MemoryRange range = { 0, ordinaryDataSize };
+        MemoryRange range = {0, ordinaryDataSize};
         void* ordinaryData;
         SLANG_RETURN_ON_FAIL(m_ordinaryDataBuffer->map(&range, &ordinaryData));
         auto result = _writeOrdinaryData(ordinaryData, ordinaryDataSize, layout);
@@ -389,78 +397,98 @@ BufferResourceImpl* ShaderObjectImpl::_ensureArgumentBufferUpToDate(
         // the offsets for each field.
         //
         auto dataSize = typeLayout->getSize();
-        MemoryRange range = { 0, dataSize };
+        MemoryRange range = {0, dataSize};
         void* argumentData;
         SLANG_RETURN_NULL_ON_FAIL(m_argumentBuffer->map(&range, &argumentData));
 
         // Now fill in argument values to `argumentData`.
         int bindingRangeIndex = 0;
-        SLANG_ASSERT(defaultTypeLayout->getBindingRangeCount() == typeLayout->getBindingRangeCount());
+        SLANG_ASSERT(
+            defaultTypeLayout->getBindingRangeCount() == typeLayout->getBindingRangeCount());
 
         int bufferBindingIndexOffset = layout->getTotalOrdinaryDataSize() != 0 ? 1 : 0;
-        
-        for (unsigned int bindingRangeIndex = 0; bindingRangeIndex < defaultTypeLayout->getBindingRangeCount(); bindingRangeIndex++)
+
+        for (unsigned int bindingRangeIndex = 0;
+             bindingRangeIndex < defaultTypeLayout->getBindingRangeCount();
+             bindingRangeIndex++)
         {
             int bindingCount = defaultTypeLayout->getBindingRangeBindingCount(bindingRangeIndex);
             int setIndex = defaultTypeLayout->getBindingRangeDescriptorSetIndex(bindingRangeIndex);
-            int rangeIndex = defaultTypeLayout->getBindingRangeFirstDescriptorRangeIndex(bindingRangeIndex);
-            int bindingOffset = defaultTypeLayout->getDescriptorSetDescriptorRangeIndexOffset(setIndex, rangeIndex);
+            int rangeIndex =
+                defaultTypeLayout->getBindingRangeFirstDescriptorRangeIndex(bindingRangeIndex);
+            int bindingOffset =
+                defaultTypeLayout->getDescriptorSetDescriptorRangeIndexOffset(setIndex, rangeIndex);
             auto bindingType = defaultTypeLayout->getBindingRangeType(bindingRangeIndex);
             for (int i = 0; i < bindingCount; i++)
             {
-                auto argumentDataOffset = typeLayout->getDescriptorSetDescriptorRangeIndexOffset(setIndex, rangeIndex) + i * sizeof(uint64_t);
+                auto argumentDataOffset =
+                    typeLayout->getDescriptorSetDescriptorRangeIndexOffset(setIndex, rangeIndex) +
+                    i * sizeof(uint64_t);
                 auto argumentPtr = (uint8_t*)argumentData + argumentDataOffset;
                 auto resourceIndex = bindingOffset + i;
                 switch (bindingType)
                 {
                 case slang::BindingType::ConstantBuffer:
                 case slang::BindingType::ParameterBlock:
-                {
-                    if (m_objects[resourceIndex])
                     {
-                        auto subArgumentBuffer = m_objects[resourceIndex]->_ensureArgumentBufferUpToDate(device, m_objects[resourceIndex]->getLayout());
-                        if (subArgumentBuffer)
+                        if (m_objects[resourceIndex])
                         {
-                            gfx::DeviceAddress bufferPtr = subArgumentBuffer->m_buffer->gpuAddress();
-                            memcpy(argumentPtr, &bufferPtr, sizeof(bufferPtr));
+                            auto subArgumentBuffer =
+                                m_objects[resourceIndex]->_ensureArgumentBufferUpToDate(
+                                    device,
+                                    m_objects[resourceIndex]->getLayout());
+                            if (subArgumentBuffer)
+                            {
+                                gfx::DeviceAddress bufferPtr =
+                                    subArgumentBuffer->m_buffer->gpuAddress();
+                                memcpy(argumentPtr, &bufferPtr, sizeof(bufferPtr));
+                            }
                         }
+                        break;
                     }
-                    break;
-                }
                 case slang::BindingType::RawBuffer:
                 case slang::BindingType::MutableRawBuffer:
-                {
-                    auto bufferViewImpl = static_cast<BufferResourceViewImpl*>(m_buffers[resourceIndex + bufferBindingIndexOffset].get());
-
-                    if (bufferViewImpl)
                     {
-                        gfx::DeviceAddress bufferPtr = bufferViewImpl->m_buffer->getDeviceAddress() + bufferViewImpl->m_offset;
-                        memcpy(argumentPtr, &bufferPtr, sizeof(bufferPtr));
+                        auto bufferViewImpl = static_cast<BufferResourceViewImpl*>(
+                            m_buffers[resourceIndex + bufferBindingIndexOffset].get());
+
+                        if (bufferViewImpl)
+                        {
+                            gfx::DeviceAddress bufferPtr =
+                                bufferViewImpl->m_buffer->getDeviceAddress() +
+                                bufferViewImpl->m_offset;
+                            memcpy(argumentPtr, &bufferPtr, sizeof(bufferPtr));
+                        }
+                        break;
                     }
-                    break;
-                }
                 case slang::BindingType::Texture:
                 case slang::BindingType::MutableTexture:
-                {
-                    auto textureViewImpl = static_cast<TextureResourceViewImpl*>(m_textures[resourceIndex].get());
-                    if (textureViewImpl)
                     {
-                        auto resourceId = textureViewImpl->m_textureView->gpuResourceID();
-                        memcpy(argumentPtr, &resourceId, sizeof(resourceId));
+                        auto textureViewImpl =
+                            static_cast<TextureResourceViewImpl*>(m_textures[resourceIndex].get());
+                        if (textureViewImpl)
+                        {
+                            auto resourceId = textureViewImpl->m_textureView->gpuResourceID();
+                            memcpy(argumentPtr, &resourceId, sizeof(resourceId));
+                        }
+                        break;
                     }
-                    break;
-                }
                 case slang::BindingType::Sampler:
-                {
-                    auto samplerStateImpl = static_cast<SamplerStateImpl*>(m_samplers[resourceIndex].get());
-                    auto resourceId = samplerStateImpl->m_samplerState->gpuResourceID();
-                    memcpy(argumentPtr, &resourceId, sizeof(resourceId));
-                    break;
-                }
+                    {
+                        auto samplerStateImpl =
+                            static_cast<SamplerStateImpl*>(m_samplers[resourceIndex].get());
+                        auto resourceId = samplerStateImpl->m_samplerState->gpuResourceID();
+                        memcpy(argumentPtr, &resourceId, sizeof(resourceId));
+                        break;
+                    }
                 }
             }
         }
-        writeOrdinaryDataIntoArgumentBuffer(typeLayout, defaultTypeLayout, (uint8_t*)argumentData, (uint8_t*)m_data.getBuffer());
+        writeOrdinaryDataIntoArgumentBuffer(
+            typeLayout,
+            defaultTypeLayout,
+            (uint8_t*)argumentData,
+            (uint8_t*)m_data.getBuffer());
         m_argumentBuffer->unmap(&range);
         m_isArgumentBufferDirty = false;
     }
@@ -475,7 +503,7 @@ Result ShaderObjectImpl::bindAsParameterBlock(
 {
     if (!context->device->m_hasArgumentBufferTier2)
         return SLANG_FAIL;
-    
+
     auto argumentBuffer = _ensureArgumentBufferUpToDate(context->device, layout);
 
     if (m_argumentBuffer)
@@ -531,7 +559,9 @@ Result ShaderObjectImpl::bindAsValue(
         for (uint32_t i = 0; i < count; ++i)
         {
             auto buffer = m_buffers[baseIndex + i];
-            context->setBuffer(buffer ? buffer->m_buffer->m_buffer.get() : nullptr, registerOffset + i);
+            context->setBuffer(
+                buffer ? buffer->m_buffer->m_buffer.get() : nullptr,
+                registerOffset + i);
         }
     }
 
@@ -544,7 +574,9 @@ Result ShaderObjectImpl::bindAsValue(
         for (uint32_t i = 0; i < count; ++i)
         {
             auto texture = m_textures[baseIndex + i];
-            context->setTexture(texture ? texture->m_textureView.get() : nullptr, registerOffset + i);
+            context->setTexture(
+                texture ? texture->m_textureView.get() : nullptr,
+                registerOffset + i);
         }
     }
 
@@ -557,7 +589,9 @@ Result ShaderObjectImpl::bindAsValue(
         for (uint32_t i = 0; i < count; ++i)
         {
             auto sampler = m_samplers[baseIndex + i];
-            context->setSampler(sampler ? sampler->m_samplerState.get() : nullptr, registerOffset + i);
+            context->setSampler(
+                sampler ? sampler->m_samplerState.get() : nullptr,
+                registerOffset + i);
         }
     }
 
@@ -585,31 +619,33 @@ Result ShaderObjectImpl::bindAsValue(
         switch (bindingRange.bindingType)
         {
         case slang::BindingType::ConstantBuffer:
-        {
-            BindingOffset objOffset = rangeOffset;
-            for (Index i = 0; i < count; ++i)
             {
-                auto subObject = m_objects[subObjectIndex + i];
+                BindingOffset objOffset = rangeOffset;
+                for (Index i = 0; i < count; ++i)
+                {
+                    auto subObject = m_objects[subObjectIndex + i];
 
-                // Unsurprisingly, we bind each object in the range as
-                // a constant buffer.
-                //
-                SLANG_RETURN_ON_FAIL(subObject->bindAsConstantBuffer(context, objOffset, subObjectLayout));
+                    // Unsurprisingly, we bind each object in the range as
+                    // a constant buffer.
+                    //
+                    SLANG_RETURN_ON_FAIL(
+                        subObject->bindAsConstantBuffer(context, objOffset, subObjectLayout));
 
-                objOffset += rangeStride;
+                    objOffset += rangeStride;
+                }
+                break;
             }
-            break;
-        }
         case slang::BindingType::ParameterBlock:
-        {
-            BindingOffset objOffset = rangeOffset;
-            for (Index i = 0; i < count; ++i)
             {
-                auto subObject = m_objects[subObjectIndex + i];
-                SLANG_RETURN_ON_FAIL(subObject->bindAsParameterBlock(context, objOffset, subObjectLayout));
-                objOffset += rangeStride;
+                BindingOffset objOffset = rangeOffset;
+                for (Index i = 0; i < count; ++i)
+                {
+                    auto subObject = m_objects[subObjectIndex + i];
+                    SLANG_RETURN_ON_FAIL(
+                        subObject->bindAsParameterBlock(context, objOffset, subObjectLayout));
+                    objOffset += rangeStride;
+                }
             }
-        }
             break;
 
 #if 0
@@ -638,8 +674,7 @@ Result ShaderObjectImpl::bindAsValue(
             break;
 #endif
 
-        default:
-            break;
+        default: break;
         }
     }
 
@@ -668,9 +703,7 @@ Result RootShaderObjectImpl::collectSpecializationArgs(ExtendedShaderObjectTypeL
     return SLANG_OK;
 }
 
-Result RootShaderObjectImpl::bindAsRoot(
-    BindingContext* context,
-    RootShaderObjectLayoutImpl* layout)
+Result RootShaderObjectImpl::bindAsRoot(BindingContext* context, RootShaderObjectLayoutImpl* layout)
 {
     // When binding an entire root shader object, we need to deal with
     // the way that specialization might have allocated space for "pending"
@@ -724,7 +757,8 @@ Result RootShaderObjectImpl::bindAsRoot(
         // the absolute offsets as are used for the global scope do not apply
         // (because entry points don't need to deal with explicit bindings).
         //
-        SLANG_RETURN_ON_FAIL(entryPoint->bindAsConstantBuffer(context, entryPointOffset, entryPointInfo.layout));
+        SLANG_RETURN_ON_FAIL(
+            entryPoint->bindAsConstantBuffer(context, entryPointOffset, entryPointInfo.layout));
     }
 
     return SLANG_OK;
diff --git a/tools/gfx/metal/metal-shader-object.h b/tools/gfx/metal/metal-shader-object.h
index 8a3d5d392..256995fe4 100644
--- a/tools/gfx/metal/metal-shader-object.h
+++ b/tools/gfx/metal/metal-shader-object.h
@@ -1,12 +1,11 @@
 // metal-shader-object.h
 #pragma once
 #include "metal-base.h"
+#include "metal-helper-functions.h"
 #include "metal-resource-views.h"
 #include "metal-sampler.h"
 #include "metal-shader-object-layout.h"
 
-#include "metal-helper-functions.h"
-
 namespace gfx
 {
 
@@ -16,10 +15,7 @@ namespace metal
 {
 
 class ShaderObjectImpl
-    : public ShaderObjectBaseImpl<
-            ShaderObjectImpl,
-            ShaderObjectLayoutImpl,
-            SimpleShaderObjectData>
+    : public ShaderObjectBaseImpl<ShaderObjectImpl, ShaderObjectLayoutImpl, SimpleShaderObjectData>
 {
 public:
     static Result create(
@@ -51,33 +47,31 @@ public:
     }
 
     SLANG_NO_THROW Result SLANG_MCALL
-        setData(ShaderOffset const& inOffset, void const* data, size_t inSize) SLANG_OVERRIDE;
+    setData(ShaderOffset const& inOffset, void const* data, size_t inSize) SLANG_OVERRIDE;
 
     SLANG_NO_THROW Result SLANG_MCALL
-        setResource(ShaderOffset const& offset, IResourceView* resourceView) SLANG_OVERRIDE;
+    setResource(ShaderOffset const& offset, IResourceView* resourceView) SLANG_OVERRIDE;
 
     SLANG_NO_THROW Result SLANG_MCALL setSampler(ShaderOffset const& offset, ISamplerState* sampler)
         SLANG_OVERRIDE;
 
     SLANG_NO_THROW Result SLANG_MCALL setCombinedTextureSampler(
-        ShaderOffset const& offset, IResourceView* textureView, ISamplerState* sampler) SLANG_OVERRIDE
+        ShaderOffset const& offset,
+        IResourceView* textureView,
+        ISamplerState* sampler) SLANG_OVERRIDE
     {
         return SLANG_E_NOT_IMPLEMENTED;
     }
 
 public:
-
-
 protected:
     friend class ProgramVars;
 
     Result init(IDevice* device, ShaderObjectLayoutImpl* layout);
 
-    /// Write the uniform/ordinary data of this object into the given `dest` buffer at the given `offset`
-    Result _writeOrdinaryData(
-        void* dest,
-        size_t destSize,
-        ShaderObjectLayoutImpl* layout);
+    /// Write the uniform/ordinary data of this object into the given `dest` buffer at the given
+    /// `offset`
+    Result _writeOrdinaryData(void* dest, size_t destSize, ShaderObjectLayoutImpl* layout);
 
     /// Ensure that the `m_ordinaryDataBuffer` has been created, if it is needed
     ///
@@ -162,10 +156,9 @@ public:
 };
 
 class MutableShaderObjectImpl
-    : public MutableShaderObject<
-    MutableShaderObjectImpl,
-    ShaderObjectLayoutImpl>
-{};
+    : public MutableShaderObject<MutableShaderObjectImpl, ShaderObjectLayoutImpl>
+{
+};
 
 class RootShaderObjectImpl : public ShaderObjectImpl
 {
@@ -175,14 +168,24 @@ public:
     virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() override { return 1; }
     virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() override { return 1; }
 
-    static Result create(IDevice* device, RootShaderObjectLayoutImpl* layout, RootShaderObjectImpl** outShaderObject);
+    static Result create(
+        IDevice* device,
+        RootShaderObjectLayoutImpl* layout,
+        RootShaderObjectImpl** outShaderObject);
 
     Result init(IDevice* device, RootShaderObjectLayoutImpl* layout);
 
-    RootShaderObjectLayoutImpl* getLayout() { return static_cast<RootShaderObjectLayoutImpl*>(m_layout.Ptr()); }
+    RootShaderObjectLayoutImpl* getLayout()
+    {
+        return static_cast<RootShaderObjectLayoutImpl*>(m_layout.Ptr());
+    }
 
-    GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return (GfxCount)m_entryPoints.getCount(); }
-    SlangResult SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) SLANG_OVERRIDE
+    GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE
+    {
+        return (GfxCount)m_entryPoints.getCount();
+    }
+    SlangResult SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint)
+        SLANG_OVERRIDE
     {
         returnComPtr(outEntryPoint, m_entryPoints[index]);
         return SLANG_OK;
@@ -191,9 +194,7 @@ public:
     virtual Result collectSpecializationArgs(ExtendedShaderObjectTypeList& args) override;
 
     /// Bind this object as a root shader object
-    Result bindAsRoot(
-        BindingContext* context,
-        RootShaderObjectLayoutImpl* specializedLayout);
+    Result bindAsRoot(BindingContext* context, RootShaderObjectLayoutImpl* specializedLayout);
 
 protected:
     List<RefPtr<ShaderObjectImpl>> m_entryPoints;
diff --git a/tools/gfx/metal/metal-shader-program.cpp b/tools/gfx/metal/metal-shader-program.cpp
index e0f973eb6..c95e99d04 100644
--- a/tools/gfx/metal/metal-shader-program.cpp
+++ b/tools/gfx/metal/metal-shader-program.cpp
@@ -1,5 +1,6 @@
 // metal-shader-program.cpp
 #include "metal-shader-program.h"
+
 #include "metal-device.h"
 #include "metal-util.h"
 
@@ -16,18 +17,22 @@ ShaderProgramImpl::ShaderProgramImpl(DeviceImpl* device)
 {
 }
 
-ShaderProgramImpl::~ShaderProgramImpl()
-{
-}
+ShaderProgramImpl::~ShaderProgramImpl() {}
 
-Result ShaderProgramImpl::createShaderModule(slang::EntryPointReflection* entryPointInfo, ComPtr<ISlangBlob> kernelCode)
+Result ShaderProgramImpl::createShaderModule(
+    slang::EntryPointReflection* entryPointInfo,
+    ComPtr<ISlangBlob> kernelCode)
 {
     Module module;
     module.stage = entryPointInfo->getStage();
     module.entryPointName = entryPointInfo->getNameOverride();
     module.code = kernelCode;
-    
-    dispatch_data_t data = dispatch_data_create(kernelCode->getBufferPointer(), kernelCode->getBufferSize(), dispatch_get_main_queue(), NULL);
+
+    dispatch_data_t data = dispatch_data_create(
+        kernelCode->getBufferPointer(),
+        kernelCode->getBufferSize(),
+        dispatch_get_main_queue(),
+        NULL);
     NS::Error* error;
     module.library = NS::TransferPtr(m_device->m_device->newLibrary(data, &error));
     if (!module.library)
diff --git a/tools/gfx/metal/metal-shader-program.h b/tools/gfx/metal/metal-shader-program.h
index d6deb6574..691e12c9e 100644
--- a/tools/gfx/metal/metal-shader-program.h
+++ b/tools/gfx/metal/metal-shader-program.h
@@ -31,7 +31,9 @@ public:
     ShaderProgramImpl(DeviceImpl* device);
     ~ShaderProgramImpl();
 
-    virtual Result createShaderModule(slang::EntryPointReflection* entryPointInfo, ComPtr<ISlangBlob> kernelCode) override;
+    virtual Result createShaderModule(
+        slang::EntryPointReflection* entryPointInfo,
+        ComPtr<ISlangBlob> kernelCode) override;
 };
 
 
diff --git a/tools/gfx/metal/metal-swap-chain.cpp b/tools/gfx/metal/metal-swap-chain.cpp
index 1478c8bf4..75bb5afa1 100644
--- a/tools/gfx/metal/metal-swap-chain.cpp
+++ b/tools/gfx/metal/metal-swap-chain.cpp
@@ -1,8 +1,8 @@
 // metal-swap-chain.cpp
 #include "metal-swap-chain.h"
 
-#include "metal-util.h"
 #include "../apple/cocoa-util.h"
+#include "metal-util.h"
 
 namespace gfx
 {
@@ -31,7 +31,10 @@ void SwapchainImpl::createImages()
     {
         ITextureResource::Desc imageDesc = {};
         imageDesc.allowedStates = ResourceStateSet(
-            ResourceState::Present, ResourceState::RenderTarget, ResourceState::CopyDestination, ResourceState::CopySource);
+            ResourceState::Present,
+            ResourceState::RenderTarget,
+            ResourceState::CopyDestination,
+            ResourceState::CopySource);
         imageDesc.type = IResource::Type::Texture2D;
         imageDesc.arraySize = 0;
         imageDesc.format = m_desc.format;
@@ -40,7 +43,10 @@ void SwapchainImpl::createImages()
         imageDesc.size.depth = 1;
         imageDesc.numMipLevels = 1;
         imageDesc.defaultState = ResourceState::Present;
-        m_device->createTextureResource(imageDesc, nullptr, (gfx::ITextureResource**)m_images[i].writeRef());
+        m_device->createTextureResource(
+            imageDesc,
+            nullptr,
+            (gfx::ITextureResource**)m_images[i].writeRef());
     }
 }
 
@@ -105,7 +111,9 @@ Result SwapchainImpl::present()
 
     MTL::CommandBuffer* commandBuffer = m_device->m_commandQueue->commandBuffer();
     MTL::BlitCommandEncoder* encoder = commandBuffer->blitCommandEncoder();
-    encoder->copyFromTexture(m_images[m_currentImageIndex]->m_texture.get(), m_currentDrawable->texture());
+    encoder->copyFromTexture(
+        m_images[m_currentImageIndex]->m_texture.get(),
+        m_currentDrawable->texture());
     encoder->endEncoding();
     commandBuffer->presentDrawable(m_currentDrawable.get());
     commandBuffer->commit();
@@ -146,5 +154,5 @@ Result SwapchainImpl::setFullScreenMode(bool mode)
     return SLANG_E_NOT_AVAILABLE;
 }
 
-} // namespace metal 
+} // namespace metal
 } // namespace gfx
diff --git a/tools/gfx/metal/metal-swap-chain.h b/tools/gfx/metal/metal-swap-chain.h
index b7d57e271..957db1ad9 100644
--- a/tools/gfx/metal/metal-swap-chain.h
+++ b/tools/gfx/metal/metal-swap-chain.h
@@ -14,9 +14,7 @@ using namespace Slang;
 namespace metal
 {
 
-class SwapchainImpl
-    : public ISwapchain
-    , public ComObject
+class SwapchainImpl : public ISwapchain, public ComObject
 {
 public:
     SLANG_COM_OBJECT_IUNKNOWN_ALL
@@ -42,7 +40,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/metal/metal-texture.cpp b/tools/gfx/metal/metal-texture.cpp
index 81625aa7e..996a0b333 100644
--- a/tools/gfx/metal/metal-texture.cpp
+++ b/tools/gfx/metal/metal-texture.cpp
@@ -1,5 +1,6 @@
 // metal-texture.cpp
 #include "metal-texture.h"
+
 #include "metal-util.h"
 
 namespace gfx
@@ -11,14 +12,12 @@ namespace metal
 {
 
 TextureResourceImpl::TextureResourceImpl(const Desc& desc, DeviceImpl* device)
-    : Parent(desc)
-    , m_device(device)
-{}
-
-TextureResourceImpl::~TextureResourceImpl()
+    : Parent(desc), m_device(device)
 {
 }
 
+TextureResourceImpl::~TextureResourceImpl() {}
+
 Result TextureResourceImpl::getNativeResourceHandle(InteropHandle* outHandle)
 {
     outHandle->api = InteropHandleAPI::Metal;
diff --git a/tools/gfx/metal/metal-texture.h b/tools/gfx/metal/metal-texture.h
index aff49beb6..fe923e965 100644
--- a/tools/gfx/metal/metal-texture.h
+++ b/tools/gfx/metal/metal-texture.h
@@ -25,7 +25,8 @@ public:
     MTL::TextureType m_textureType;
     MTL::PixelFormat m_pixelFormat;
 
-    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeResourceHandle(InteropHandle* outHandle) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+    getNativeResourceHandle(InteropHandle* outHandle) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL getSharedHandle(InteropHandle* outHandle) override;
 
diff --git a/tools/gfx/metal/metal-transient-heap.cpp b/tools/gfx/metal/metal-transient-heap.cpp
index 8810897dd..16c883f67 100644
--- a/tools/gfx/metal/metal-transient-heap.cpp
+++ b/tools/gfx/metal/metal-transient-heap.cpp
@@ -22,9 +22,7 @@ Result TransientResourceHeapImpl::init(const ITransientResourceHeap::Desc& desc,
     return SLANG_OK;
 }
 
-TransientResourceHeapImpl::~TransientResourceHeapImpl()
-{
-}
+TransientResourceHeapImpl::~TransientResourceHeapImpl() {}
 
 Result TransientResourceHeapImpl::createCommandBuffer(ICommandBuffer** outCmdBuffer)
 {
diff --git a/tools/gfx/metal/metal-transient-heap.h b/tools/gfx/metal/metal-transient-heap.h
index 4b3f6dee9..963b5bd1b 100644
--- a/tools/gfx/metal/metal-transient-heap.h
+++ b/tools/gfx/metal/metal-transient-heap.h
@@ -27,7 +27,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/metal/metal-util.cpp b/tools/gfx/metal/metal-util.cpp
index ed96eb487..fd2e9e009 100644
--- a/tools/gfx/metal/metal-util.cpp
+++ b/tools/gfx/metal/metal-util.cpp
@@ -1,117 +1,119 @@
 // metal-util.cpp
 #include "metal-util.h"
+
 #include "core/slang-math.h"
 
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 
-namespace gfx {
+namespace gfx
+{
 
 MTL::PixelFormat MetalUtil::translatePixelFormat(Format format)
 {
     switch (format)
     {
-    case Format::R32G32B32A32_TYPELESS:     return MTL::PixelFormatRGBA32Float;
-    case Format::R32G32B32_TYPELESS:        return MTL::PixelFormatInvalid;
-    case Format::R32G32_TYPELESS:           return MTL::PixelFormatRG32Float;
-    case Format::R32_TYPELESS:              return MTL::PixelFormatR32Float;
-
-    case Format::R16G16B16A16_TYPELESS:     return MTL::PixelFormatRGBA16Float;
-    case Format::R16G16_TYPELESS:           return MTL::PixelFormatRG16Float;
-    case Format::R16_TYPELESS:              return MTL::PixelFormatR16Float;
-
-    case Format::R8G8B8A8_TYPELESS:         return MTL::PixelFormatRGBA8Unorm;
-    case Format::R8G8_TYPELESS:             return MTL::PixelFormatRG8Unorm;
-    case Format::R8_TYPELESS:               return MTL::PixelFormatR8Unorm;
-    case Format::B8G8R8A8_TYPELESS:         return MTL::PixelFormatBGRA8Unorm;
-
-    case Format::R32G32B32A32_FLOAT:        return MTL::PixelFormatRGBA32Float;
-    case Format::R32G32B32_FLOAT:           return MTL::PixelFormatInvalid;
-    case Format::R32G32_FLOAT:              return MTL::PixelFormatRG32Float;
-    case Format::R32_FLOAT:                 return MTL::PixelFormatR32Float;
-
-    case Format::R16G16B16A16_FLOAT:        return MTL::PixelFormatRGBA16Float;
-    case Format::R16G16_FLOAT:              return MTL::PixelFormatRG16Float;
-    case Format::R16_FLOAT:                 return MTL::PixelFormatR16Float;
-
-    case Format::R32G32B32A32_UINT:         return MTL::PixelFormatRGBA32Uint;
-    case Format::R32G32B32_UINT:            return MTL::PixelFormatInvalid;
-    case Format::R32G32_UINT:               return MTL::PixelFormatRG32Uint;
-    case Format::R32_UINT:                  return MTL::PixelFormatR32Uint;
-
-    case Format::R16G16B16A16_UINT:         return MTL::PixelFormatRGBA16Uint;
-    case Format::R16G16_UINT:               return MTL::PixelFormatRG16Uint;
-    case Format::R16_UINT:                  return MTL::PixelFormatR16Uint;
-
-    case Format::R8G8B8A8_UINT:             return MTL::PixelFormatRGBA8Uint;
-    case Format::R8G8_UINT:                 return MTL::PixelFormatRG8Uint;
-    case Format::R8_UINT:                   return MTL::PixelFormatR8Uint;
-
-    case Format::R32G32B32A32_SINT:         return MTL::PixelFormatRGBA32Sint;
-    case Format::R32G32B32_SINT:            return MTL::PixelFormatInvalid;
-    case Format::R32G32_SINT:               return MTL::PixelFormatRG32Sint;
-    case Format::R32_SINT:                  return MTL::PixelFormatR32Sint;
-
-    case Format::R16G16B16A16_SINT:         return MTL::PixelFormatRGBA16Sint;
-    case Format::R16G16_SINT:               return MTL::PixelFormatRG16Sint;
-    case Format::R16_SINT:                  return MTL::PixelFormatR16Sint;
-
-    case Format::R8G8B8A8_SINT:             return MTL::PixelFormatRGBA8Sint;
-    case Format::R8G8_SINT:                 return MTL::PixelFormatRG8Sint;
-    case Format::R8_SINT:                   return MTL::PixelFormatR8Sint;
-
-    case Format::R16G16B16A16_UNORM:        return MTL::PixelFormatRGBA16Unorm;
-    case Format::R16G16_UNORM:              return MTL::PixelFormatRG16Unorm;
-    case Format::R16_UNORM:                 return MTL::PixelFormatR16Unorm;
-
-    case Format::R8G8B8A8_UNORM:            return MTL::PixelFormatRGBA8Unorm;
-    case Format::R8G8B8A8_UNORM_SRGB:       return MTL::PixelFormatRGBA8Unorm_sRGB;
-    case Format::R8G8_UNORM:                return MTL::PixelFormatRG8Unorm;
-    case Format::R8_UNORM:                  return MTL::PixelFormatR8Unorm;
-    case Format::B8G8R8A8_UNORM:            return MTL::PixelFormatBGRA8Unorm;
-    case Format::B8G8R8A8_UNORM_SRGB:       return MTL::PixelFormatBGRA8Unorm_sRGB;
-    case Format::B8G8R8X8_UNORM:            return MTL::PixelFormatInvalid;
-    case Format::B8G8R8X8_UNORM_SRGB:       return MTL::PixelFormatInvalid;
-
-    case Format::R16G16B16A16_SNORM:        return MTL::PixelFormatRGBA16Snorm;
-    case Format::R16G16_SNORM:              return MTL::PixelFormatRG16Snorm;
-    case Format::R16_SNORM:                 return MTL::PixelFormatR16Snorm;
-
-    case Format::R8G8B8A8_SNORM:            return MTL::PixelFormatRGBA8Snorm;
-    case Format::R8G8_SNORM:                return MTL::PixelFormatRG8Snorm;
-    case Format::R8_SNORM:                  return MTL::PixelFormatR8Snorm;
-
-    case Format::D32_FLOAT:                 return MTL::PixelFormatDepth32Float;
-    case Format::D16_UNORM:                 return MTL::PixelFormatDepth16Unorm;
-    case Format::D32_FLOAT_S8_UINT:         return MTL::PixelFormatDepth32Float_Stencil8;
-    case Format::R32_FLOAT_X32_TYPELESS:    return MTL::PixelFormatInvalid;
-
-    case Format::B4G4R4A4_UNORM:            return MTL::PixelFormatABGR4Unorm;
-    case Format::B5G6R5_UNORM:              return MTL::PixelFormatB5G6R5Unorm;
-    case Format::B5G5R5A1_UNORM:            return MTL::PixelFormatA1BGR5Unorm;
-
-    case Format::R9G9B9E5_SHAREDEXP:        return MTL::PixelFormatRGB9E5Float;
-    case Format::R10G10B10A2_TYPELESS:      return MTL::PixelFormatInvalid;
-    case Format::R10G10B10A2_UINT:          return MTL::PixelFormatRGB10A2Uint;
-    case Format::R10G10B10A2_UNORM:         return MTL::PixelFormatRGB10A2Unorm;
-    case Format::R11G11B10_FLOAT:           return MTL::PixelFormatRG11B10Float;
-
-    case Format::BC1_UNORM:                 return MTL::PixelFormatBC1_RGBA;
-    case Format::BC1_UNORM_SRGB:            return MTL::PixelFormatBC1_RGBA_sRGB;
-    case Format::BC2_UNORM:                 return MTL::PixelFormatBC2_RGBA;
-    case Format::BC2_UNORM_SRGB:            return MTL::PixelFormatBC2_RGBA_sRGB;
-    case Format::BC3_UNORM:                 return MTL::PixelFormatBC3_RGBA;
-    case Format::BC3_UNORM_SRGB:            return MTL::PixelFormatBC3_RGBA_sRGB;
-    case Format::BC4_UNORM:                 return MTL::PixelFormatBC4_RUnorm;
-    case Format::BC4_SNORM:                 return MTL::PixelFormatBC4_RSnorm;
-    case Format::BC5_UNORM:                 return MTL::PixelFormatBC5_RGUnorm;
-    case Format::BC5_SNORM:                 return MTL::PixelFormatBC5_RGSnorm;
-    case Format::BC6H_UF16:                 return MTL::PixelFormatBC6H_RGBUfloat;
-    case Format::BC6H_SF16:                 return MTL::PixelFormatBC6H_RGBFloat;
-    case Format::BC7_UNORM:                 return MTL::PixelFormatBC7_RGBAUnorm;
-    case Format::BC7_UNORM_SRGB:            return MTL::PixelFormatBC7_RGBAUnorm_sRGB;
-
-    default:                                return MTL::PixelFormatInvalid;
+    case Format::R32G32B32A32_TYPELESS: return MTL::PixelFormatRGBA32Float;
+    case Format::R32G32B32_TYPELESS:    return MTL::PixelFormatInvalid;
+    case Format::R32G32_TYPELESS:       return MTL::PixelFormatRG32Float;
+    case Format::R32_TYPELESS:          return MTL::PixelFormatR32Float;
+
+    case Format::R16G16B16A16_TYPELESS: return MTL::PixelFormatRGBA16Float;
+    case Format::R16G16_TYPELESS:       return MTL::PixelFormatRG16Float;
+    case Format::R16_TYPELESS:          return MTL::PixelFormatR16Float;
+
+    case Format::R8G8B8A8_TYPELESS: return MTL::PixelFormatRGBA8Unorm;
+    case Format::R8G8_TYPELESS:     return MTL::PixelFormatRG8Unorm;
+    case Format::R8_TYPELESS:       return MTL::PixelFormatR8Unorm;
+    case Format::B8G8R8A8_TYPELESS: return MTL::PixelFormatBGRA8Unorm;
+
+    case Format::R32G32B32A32_FLOAT: return MTL::PixelFormatRGBA32Float;
+    case Format::R32G32B32_FLOAT:    return MTL::PixelFormatInvalid;
+    case Format::R32G32_FLOAT:       return MTL::PixelFormatRG32Float;
+    case Format::R32_FLOAT:          return MTL::PixelFormatR32Float;
+
+    case Format::R16G16B16A16_FLOAT: return MTL::PixelFormatRGBA16Float;
+    case Format::R16G16_FLOAT:       return MTL::PixelFormatRG16Float;
+    case Format::R16_FLOAT:          return MTL::PixelFormatR16Float;
+
+    case Format::R32G32B32A32_UINT: return MTL::PixelFormatRGBA32Uint;
+    case Format::R32G32B32_UINT:    return MTL::PixelFormatInvalid;
+    case Format::R32G32_UINT:       return MTL::PixelFormatRG32Uint;
+    case Format::R32_UINT:          return MTL::PixelFormatR32Uint;
+
+    case Format::R16G16B16A16_UINT: return MTL::PixelFormatRGBA16Uint;
+    case Format::R16G16_UINT:       return MTL::PixelFormatRG16Uint;
+    case Format::R16_UINT:          return MTL::PixelFormatR16Uint;
+
+    case Format::R8G8B8A8_UINT: return MTL::PixelFormatRGBA8Uint;
+    case Format::R8G8_UINT:     return MTL::PixelFormatRG8Uint;
+    case Format::R8_UINT:       return MTL::PixelFormatR8Uint;
+
+    case Format::R32G32B32A32_SINT: return MTL::PixelFormatRGBA32Sint;
+    case Format::R32G32B32_SINT:    return MTL::PixelFormatInvalid;
+    case Format::R32G32_SINT:       return MTL::PixelFormatRG32Sint;
+    case Format::R32_SINT:          return MTL::PixelFormatR32Sint;
+
+    case Format::R16G16B16A16_SINT: return MTL::PixelFormatRGBA16Sint;
+    case Format::R16G16_SINT:       return MTL::PixelFormatRG16Sint;
+    case Format::R16_SINT:          return MTL::PixelFormatR16Sint;
+
+    case Format::R8G8B8A8_SINT: return MTL::PixelFormatRGBA8Sint;
+    case Format::R8G8_SINT:     return MTL::PixelFormatRG8Sint;
+    case Format::R8_SINT:       return MTL::PixelFormatR8Sint;
+
+    case Format::R16G16B16A16_UNORM: return MTL::PixelFormatRGBA16Unorm;
+    case Format::R16G16_UNORM:       return MTL::PixelFormatRG16Unorm;
+    case Format::R16_UNORM:          return MTL::PixelFormatR16Unorm;
+
+    case Format::R8G8B8A8_UNORM:      return MTL::PixelFormatRGBA8Unorm;
+    case Format::R8G8B8A8_UNORM_SRGB: return MTL::PixelFormatRGBA8Unorm_sRGB;
+    case Format::R8G8_UNORM:          return MTL::PixelFormatRG8Unorm;
+    case Format::R8_UNORM:            return MTL::PixelFormatR8Unorm;
+    case Format::B8G8R8A8_UNORM:      return MTL::PixelFormatBGRA8Unorm;
+    case Format::B8G8R8A8_UNORM_SRGB: return MTL::PixelFormatBGRA8Unorm_sRGB;
+    case Format::B8G8R8X8_UNORM:      return MTL::PixelFormatInvalid;
+    case Format::B8G8R8X8_UNORM_SRGB: return MTL::PixelFormatInvalid;
+
+    case Format::R16G16B16A16_SNORM: return MTL::PixelFormatRGBA16Snorm;
+    case Format::R16G16_SNORM:       return MTL::PixelFormatRG16Snorm;
+    case Format::R16_SNORM:          return MTL::PixelFormatR16Snorm;
+
+    case Format::R8G8B8A8_SNORM: return MTL::PixelFormatRGBA8Snorm;
+    case Format::R8G8_SNORM:     return MTL::PixelFormatRG8Snorm;
+    case Format::R8_SNORM:       return MTL::PixelFormatR8Snorm;
+
+    case Format::D32_FLOAT:              return MTL::PixelFormatDepth32Float;
+    case Format::D16_UNORM:              return MTL::PixelFormatDepth16Unorm;
+    case Format::D32_FLOAT_S8_UINT:      return MTL::PixelFormatDepth32Float_Stencil8;
+    case Format::R32_FLOAT_X32_TYPELESS: return MTL::PixelFormatInvalid;
+
+    case Format::B4G4R4A4_UNORM: return MTL::PixelFormatABGR4Unorm;
+    case Format::B5G6R5_UNORM:   return MTL::PixelFormatB5G6R5Unorm;
+    case Format::B5G5R5A1_UNORM: return MTL::PixelFormatA1BGR5Unorm;
+
+    case Format::R9G9B9E5_SHAREDEXP:   return MTL::PixelFormatRGB9E5Float;
+    case Format::R10G10B10A2_TYPELESS: return MTL::PixelFormatInvalid;
+    case Format::R10G10B10A2_UINT:     return MTL::PixelFormatRGB10A2Uint;
+    case Format::R10G10B10A2_UNORM:    return MTL::PixelFormatRGB10A2Unorm;
+    case Format::R11G11B10_FLOAT:      return MTL::PixelFormatRG11B10Float;
+
+    case Format::BC1_UNORM:      return MTL::PixelFormatBC1_RGBA;
+    case Format::BC1_UNORM_SRGB: return MTL::PixelFormatBC1_RGBA_sRGB;
+    case Format::BC2_UNORM:      return MTL::PixelFormatBC2_RGBA;
+    case Format::BC2_UNORM_SRGB: return MTL::PixelFormatBC2_RGBA_sRGB;
+    case Format::BC3_UNORM:      return MTL::PixelFormatBC3_RGBA;
+    case Format::BC3_UNORM_SRGB: return MTL::PixelFormatBC3_RGBA_sRGB;
+    case Format::BC4_UNORM:      return MTL::PixelFormatBC4_RUnorm;
+    case Format::BC4_SNORM:      return MTL::PixelFormatBC4_RSnorm;
+    case Format::BC5_UNORM:      return MTL::PixelFormatBC5_RGUnorm;
+    case Format::BC5_SNORM:      return MTL::PixelFormatBC5_RGSnorm;
+    case Format::BC6H_UF16:      return MTL::PixelFormatBC6H_RGBUfloat;
+    case Format::BC6H_SF16:      return MTL::PixelFormatBC6H_RGBFloat;
+    case Format::BC7_UNORM:      return MTL::PixelFormatBC7_RGBAUnorm;
+    case Format::BC7_UNORM_SRGB: return MTL::PixelFormatBC7_RGBAUnorm_sRGB;
+
+    default: return MTL::PixelFormatInvalid;
     }
 }
 
@@ -119,60 +121,60 @@ MTL::VertexFormat MetalUtil::translateVertexFormat(Format format)
 {
     switch (format)
     {
-    case Format::R8G8_UINT:                 return MTL::VertexFormatUChar2;
+    case Format::R8G8_UINT: return MTL::VertexFormatUChar2;
     // VertexFormatUChar3
-    case Format::R8G8B8A8_UINT:             return MTL::VertexFormatUChar4;
-    case Format::R8G8_SINT:                 return MTL::VertexFormatChar2;
+    case Format::R8G8B8A8_UINT: return MTL::VertexFormatUChar4;
+    case Format::R8G8_SINT:     return MTL::VertexFormatChar2;
     // return VertexFormatChar3
-    case Format::R8G8B8A8_SINT:             return MTL::VertexFormatChar4;
-    case Format::R8G8_UNORM:                return MTL::VertexFormatUChar2Normalized;
+    case Format::R8G8B8A8_SINT: return MTL::VertexFormatChar4;
+    case Format::R8G8_UNORM:    return MTL::VertexFormatUChar2Normalized;
     // return VertexFormatUChar3Normalized;
-    case Format::R8G8B8A8_UNORM:            return MTL::VertexFormatUChar4Normalized;
-    case Format::R8G8_SNORM:                return MTL::VertexFormatChar2Normalized;
+    case Format::R8G8B8A8_UNORM: return MTL::VertexFormatUChar4Normalized;
+    case Format::R8G8_SNORM:     return MTL::VertexFormatChar2Normalized;
     // return VertexFormatChar3Normalized
-    case Format::R8G8B8A8_SNORM:            return MTL::VertexFormatChar4Normalized;
-    case Format::R16G16_UINT:               return MTL::VertexFormatUShort2;
+    case Format::R8G8B8A8_SNORM: return MTL::VertexFormatChar4Normalized;
+    case Format::R16G16_UINT:    return MTL::VertexFormatUShort2;
     // return VertexFormatUShort3;
-    case Format::R16G16B16A16_UINT:         return MTL::VertexFormatUShort4;
-    case Format::R16G16_SINT:               return MTL::VertexFormatShort2;
+    case Format::R16G16B16A16_UINT: return MTL::VertexFormatUShort4;
+    case Format::R16G16_SINT:       return MTL::VertexFormatShort2;
     // return VertexFormatShort3;
-    case Format::R16G16B16A16_SINT:         return MTL::VertexFormatShort4;
-    case Format::R16G16_UNORM:              return MTL::VertexFormatUShort2Normalized;
+    case Format::R16G16B16A16_SINT: return MTL::VertexFormatShort4;
+    case Format::R16G16_UNORM:      return MTL::VertexFormatUShort2Normalized;
     // return VertexFormatUShort3Normalized;
-    case Format::R16G16B16A16_UNORM:        return MTL::VertexFormatUShort4Normalized;
-    case Format::R16G16_SNORM:              return MTL::VertexFormatShort2Normalized;
+    case Format::R16G16B16A16_UNORM: return MTL::VertexFormatUShort4Normalized;
+    case Format::R16G16_SNORM:       return MTL::VertexFormatShort2Normalized;
     // return VertexFormatShort3Normalized;
-    case Format::R16G16B16A16_SNORM:        return MTL::VertexFormatShort4Normalized;
-    case Format::R16G16_FLOAT:              return MTL::VertexFormatHalf2;
+    case Format::R16G16B16A16_SNORM: return MTL::VertexFormatShort4Normalized;
+    case Format::R16G16_FLOAT:       return MTL::VertexFormatHalf2;
     // return VertexFormatHalf3;
-    case Format::R16G16B16A16_FLOAT:        return MTL::VertexFormatHalf4;
-    case Format::R32_FLOAT:                 return MTL::VertexFormatFloat;
-    case Format::R32G32_FLOAT:              return MTL::VertexFormatFloat2;
-    case Format::R32G32B32_FLOAT:           return MTL::VertexFormatFloat3;
-    case Format::R32G32B32A32_FLOAT:        return MTL::VertexFormatFloat4;
-    case Format::R32_SINT:                  return MTL::VertexFormatInt;
-    case Format::R32G32_SINT:               return MTL::VertexFormatInt2;
-    case Format::R32G32B32_SINT:            return MTL::VertexFormatInt3;
-    case Format::R32G32B32A32_SINT:         return MTL::VertexFormatInt4;
-    case Format::R32_UINT:                  return MTL::VertexFormatUInt;
-    case Format::R32G32_UINT:               return MTL::VertexFormatUInt2;
-    case Format::R32G32B32_UINT:            return MTL::VertexFormatUInt3;
-    case Format::R32G32B32A32_UINT:         return MTL::VertexFormatUInt4;
+    case Format::R16G16B16A16_FLOAT: return MTL::VertexFormatHalf4;
+    case Format::R32_FLOAT:          return MTL::VertexFormatFloat;
+    case Format::R32G32_FLOAT:       return MTL::VertexFormatFloat2;
+    case Format::R32G32B32_FLOAT:    return MTL::VertexFormatFloat3;
+    case Format::R32G32B32A32_FLOAT: return MTL::VertexFormatFloat4;
+    case Format::R32_SINT:           return MTL::VertexFormatInt;
+    case Format::R32G32_SINT:        return MTL::VertexFormatInt2;
+    case Format::R32G32B32_SINT:     return MTL::VertexFormatInt3;
+    case Format::R32G32B32A32_SINT:  return MTL::VertexFormatInt4;
+    case Format::R32_UINT:           return MTL::VertexFormatUInt;
+    case Format::R32G32_UINT:        return MTL::VertexFormatUInt2;
+    case Format::R32G32B32_UINT:     return MTL::VertexFormatUInt3;
+    case Format::R32G32B32A32_UINT:  return MTL::VertexFormatUInt4;
     // return VertexFormatInt1010102Normalized;
-    case Format::R10G10B10A2_UNORM:         return MTL::VertexFormatUInt1010102Normalized;
-    case Format::B4G4R4A4_UNORM:            return MTL::VertexFormatUChar4Normalized_BGRA;
-    case Format::R8_UINT:                   return MTL::VertexFormatUChar;
-    case Format::R8_SINT:                   return MTL::VertexFormatChar;
-    case Format::R8_UNORM:                  return MTL::VertexFormatUCharNormalized;
-    case Format::R8_SNORM:                  return MTL::VertexFormatCharNormalized;
-    case Format::R16_UINT:                  return MTL::VertexFormatUShort;
-    case Format::R16_SINT:                  return MTL::VertexFormatShort;
-    case Format::R16_UNORM:                 return MTL::VertexFormatUShortNormalized;
-    case Format::R16_SNORM:                 return MTL::VertexFormatShortNormalized;
-    case Format::R16_FLOAT:                 return MTL::VertexFormatHalf;
-    case Format::R11G11B10_FLOAT:           return MTL::VertexFormatFloatRG11B10;
-    case Format::R9G9B9E5_SHAREDEXP:        return MTL::VertexFormatFloatRGB9E5;
-    default:                                return MTL::VertexFormatInvalid;
+    case Format::R10G10B10A2_UNORM:  return MTL::VertexFormatUInt1010102Normalized;
+    case Format::B4G4R4A4_UNORM:     return MTL::VertexFormatUChar4Normalized_BGRA;
+    case Format::R8_UINT:            return MTL::VertexFormatUChar;
+    case Format::R8_SINT:            return MTL::VertexFormatChar;
+    case Format::R8_UNORM:           return MTL::VertexFormatUCharNormalized;
+    case Format::R8_SNORM:           return MTL::VertexFormatCharNormalized;
+    case Format::R16_UINT:           return MTL::VertexFormatUShort;
+    case Format::R16_SINT:           return MTL::VertexFormatShort;
+    case Format::R16_UNORM:          return MTL::VertexFormatUShortNormalized;
+    case Format::R16_SNORM:          return MTL::VertexFormatShortNormalized;
+    case Format::R16_FLOAT:          return MTL::VertexFormatHalf;
+    case Format::R11G11B10_FLOAT:    return MTL::VertexFormatFloatRG11B10;
+    case Format::R9G9B9E5_SHAREDEXP: return MTL::VertexFormatFloatRGB9E5;
+    default:                         return MTL::VertexFormatInvalid;
     }
 }
 
@@ -183,10 +185,8 @@ bool MetalUtil::isDepthFormat(MTL::PixelFormat format)
     case MTL::PixelFormatDepth16Unorm:
     case MTL::PixelFormatDepth32Float:
     case MTL::PixelFormatDepth24Unorm_Stencil8:
-    case MTL::PixelFormatDepth32Float_Stencil8:
-        return true;
-    default:
-        return false;
+    case MTL::PixelFormatDepth32Float_Stencil8: return true;
+    default:                                    return false;
     }
 }
 
@@ -198,10 +198,8 @@ bool MetalUtil::isStencilFormat(MTL::PixelFormat format)
     case MTL::PixelFormatDepth24Unorm_Stencil8:
     case MTL::PixelFormatDepth32Float_Stencil8:
     case MTL::PixelFormatX32_Stencil8:
-    case MTL::PixelFormatX24_Stencil8:
-        return true;
-    default:
-        return false;
+    case MTL::PixelFormatX24_Stencil8:          return true;
+    default:                                    return false;
     }
 }
 
@@ -209,12 +207,9 @@ MTL::SamplerMinMagFilter MetalUtil::translateSamplerMinMagFilter(TextureFilterin
 {
     switch (mode)
     {
-    case TextureFilteringMode::Point:
-        return MTL::SamplerMinMagFilterNearest;
-    case TextureFilteringMode::Linear:
-        return MTL::SamplerMinMagFilterLinear;
-    default:
-        return MTL::SamplerMinMagFilter(0);
+    case TextureFilteringMode::Point:  return MTL::SamplerMinMagFilterNearest;
+    case TextureFilteringMode::Linear: return MTL::SamplerMinMagFilterLinear;
+    default:                           return MTL::SamplerMinMagFilter(0);
     }
 }
 
@@ -222,31 +217,22 @@ MTL::SamplerMipFilter MetalUtil::translateSamplerMipFilter(TextureFilteringMode
 {
     switch (mode)
     {
-    case TextureFilteringMode::Point:
-        return MTL::SamplerMipFilterNearest;
-    case TextureFilteringMode::Linear:
-        return MTL::SamplerMipFilterLinear;
-    default:
-        return MTL::SamplerMipFilter(0);
-    }    
+    case TextureFilteringMode::Point:  return MTL::SamplerMipFilterNearest;
+    case TextureFilteringMode::Linear: return MTL::SamplerMipFilterLinear;
+    default:                           return MTL::SamplerMipFilter(0);
+    }
 }
 
 MTL::SamplerAddressMode MetalUtil::translateSamplerAddressMode(TextureAddressingMode mode)
 {
     switch (mode)
     {
-    case TextureAddressingMode::Wrap:
-        return MTL::SamplerAddressModeRepeat;
-    case TextureAddressingMode::ClampToEdge:
-        return MTL::SamplerAddressModeClampToEdge;
-    case TextureAddressingMode::ClampToBorder:
-        return MTL::SamplerAddressModeClampToBorderColor;
-    case TextureAddressingMode::MirrorRepeat:
-        return MTL::SamplerAddressModeMirrorRepeat;
-    case TextureAddressingMode::MirrorOnce:
-        return MTL::SamplerAddressModeMirrorClampToEdge;
-    default:
-        return MTL::SamplerAddressMode(0);
+    case TextureAddressingMode::Wrap:          return MTL::SamplerAddressModeRepeat;
+    case TextureAddressingMode::ClampToEdge:   return MTL::SamplerAddressModeClampToEdge;
+    case TextureAddressingMode::ClampToBorder: return MTL::SamplerAddressModeClampToBorderColor;
+    case TextureAddressingMode::MirrorRepeat:  return MTL::SamplerAddressModeMirrorRepeat;
+    case TextureAddressingMode::MirrorOnce:    return MTL::SamplerAddressModeMirrorClampToEdge;
+    default:                                   return MTL::SamplerAddressMode(0);
     }
 }
 
@@ -254,24 +240,15 @@ MTL::CompareFunction MetalUtil::translateCompareFunction(ComparisonFunc func)
 {
     switch (func)
     {
-    case ComparisonFunc::Never:
-        return MTL::CompareFunctionNever;
-    case ComparisonFunc::Less:
-        return MTL::CompareFunctionLess;
-    case ComparisonFunc::Equal:
-        return MTL::CompareFunctionEqual;
-    case ComparisonFunc::LessEqual:
-        return MTL::CompareFunctionLessEqual;
-    case ComparisonFunc::Greater:
-        return MTL::CompareFunctionGreater;
-    case ComparisonFunc::NotEqual:
-        return MTL::CompareFunctionNotEqual;
-    case ComparisonFunc::GreaterEqual:
-        return MTL::CompareFunctionGreaterEqual;
-    case ComparisonFunc::Always:
-        return MTL::CompareFunctionAlways;
-    default:
-        return MTL::CompareFunction(0);
+    case ComparisonFunc::Never:        return MTL::CompareFunctionNever;
+    case ComparisonFunc::Less:         return MTL::CompareFunctionLess;
+    case ComparisonFunc::Equal:        return MTL::CompareFunctionEqual;
+    case ComparisonFunc::LessEqual:    return MTL::CompareFunctionLessEqual;
+    case ComparisonFunc::Greater:      return MTL::CompareFunctionGreater;
+    case ComparisonFunc::NotEqual:     return MTL::CompareFunctionNotEqual;
+    case ComparisonFunc::GreaterEqual: return MTL::CompareFunctionGreaterEqual;
+    case ComparisonFunc::Always:       return MTL::CompareFunctionAlways;
+    default:                           return MTL::CompareFunction(0);
     }
 }
 
@@ -279,24 +256,15 @@ MTL::StencilOperation MetalUtil::translateStencilOperation(StencilOp op)
 {
     switch (op)
     {
-    case StencilOp::Keep:
-        return MTL::StencilOperationKeep;
-    case StencilOp::Zero:
-        return MTL::StencilOperationZero;
-    case StencilOp::Replace:
-        return MTL::StencilOperationReplace;
-    case StencilOp::IncrementSaturate:
-        return MTL::StencilOperationIncrementClamp;
-    case StencilOp::DecrementSaturate:
-        return MTL::StencilOperationDecrementClamp;
-    case StencilOp::Invert:
-        return MTL::StencilOperationInvert;
-    case StencilOp::IncrementWrap:
-        return MTL::StencilOperationIncrementWrap;
-    case StencilOp::DecrementWrap:
-        return MTL::StencilOperationDecrementWrap;
-    default:
-        return MTL::StencilOperation(0);
+    case StencilOp::Keep:              return MTL::StencilOperationKeep;
+    case StencilOp::Zero:              return MTL::StencilOperationZero;
+    case StencilOp::Replace:           return MTL::StencilOperationReplace;
+    case StencilOp::IncrementSaturate: return MTL::StencilOperationIncrementClamp;
+    case StencilOp::DecrementSaturate: return MTL::StencilOperationDecrementClamp;
+    case StencilOp::Invert:            return MTL::StencilOperationInvert;
+    case StencilOp::IncrementWrap:     return MTL::StencilOperationIncrementWrap;
+    case StencilOp::DecrementWrap:     return MTL::StencilOperationDecrementWrap;
+    default:                           return MTL::StencilOperation(0);
     }
 }
 
@@ -304,12 +272,9 @@ MTL::VertexStepFunction MetalUtil::translateVertexStepFunction(InputSlotClass sl
 {
     switch (slotClass)
     {
-    case InputSlotClass::PerVertex:
-        return MTL::VertexStepFunctionPerVertex;
-    case InputSlotClass::PerInstance:
-        return MTL::VertexStepFunctionPerInstance;
-    default:
-        return MTL::VertexStepFunctionPerVertex;
+    case InputSlotClass::PerVertex:   return MTL::VertexStepFunctionPerVertex;
+    case InputSlotClass::PerInstance: return MTL::VertexStepFunctionPerInstance;
+    default:                          return MTL::VertexStepFunctionPerVertex;
     }
 }
 
@@ -317,18 +282,12 @@ MTL::PrimitiveType MetalUtil::translatePrimitiveType(PrimitiveTopology topology)
 {
     switch (topology)
     {
-    case PrimitiveTopology::TriangleList:
-        return MTL::PrimitiveTypeTriangle;
-    case PrimitiveTopology::TriangleStrip:
-        return MTL::PrimitiveTypeTriangleStrip;
-    case PrimitiveTopology::PointList:
-        return MTL::PrimitiveTypePoint;
-    case PrimitiveTopology::LineList:
-        return MTL::PrimitiveTypeLine;
-    case PrimitiveTopology::LineStrip:
-        return MTL::PrimitiveTypeLineStrip;
-    default:
-        return MTL::PrimitiveType(0);
+    case PrimitiveTopology::TriangleList:  return MTL::PrimitiveTypeTriangle;
+    case PrimitiveTopology::TriangleStrip: return MTL::PrimitiveTypeTriangleStrip;
+    case PrimitiveTopology::PointList:     return MTL::PrimitiveTypePoint;
+    case PrimitiveTopology::LineList:      return MTL::PrimitiveTypeLine;
+    case PrimitiveTopology::LineStrip:     return MTL::PrimitiveTypeLineStrip;
+    default:                               return MTL::PrimitiveType(0);
     }
 }
 
@@ -336,15 +295,11 @@ MTL::PrimitiveTopologyClass MetalUtil::translatePrimitiveTopologyClass(Primitive
 {
     switch (type)
     {
-    case PrimitiveType::Point:
-        return MTL::PrimitiveTopologyClassPoint;
-    case PrimitiveType::Line: 
-        return MTL::PrimitiveTopologyClassLine;
-    case PrimitiveType::Triangle:
-        return MTL::PrimitiveTopologyClassTriangle;
+    case PrimitiveType::Point:    return MTL::PrimitiveTopologyClassPoint;
+    case PrimitiveType::Line:     return MTL::PrimitiveTopologyClassLine;
+    case PrimitiveType::Triangle: return MTL::PrimitiveTopologyClassTriangle;
     case PrimitiveType::Patch:
-    default:
-        return MTL::PrimitiveTopologyClassUnspecified;
+    default:                      return MTL::PrimitiveTopologyClassUnspecified;
     }
 }
 
@@ -352,42 +307,24 @@ MTL::BlendFactor MetalUtil::translateBlendFactor(BlendFactor factor)
 {
     switch (factor)
     {
-    case BlendFactor::Zero:
-        return MTL::BlendFactorZero;
-    case BlendFactor::One:
-        return MTL::BlendFactorOne;
-    case BlendFactor::SrcColor:
-        return MTL::BlendFactorSourceColor;
-    case BlendFactor::InvSrcColor:
-        return MTL::BlendFactorOneMinusSourceColor;
-    case BlendFactor::SrcAlpha:
-        return MTL::BlendFactorSourceAlpha;
-    case BlendFactor::InvSrcAlpha:
-        return MTL::BlendFactorOneMinusSourceAlpha;
-    case BlendFactor::DestAlpha:
-        return MTL::BlendFactorDestinationAlpha;
-    case BlendFactor::InvDestAlpha:
-        return MTL::BlendFactorOneMinusDestinationAlpha;
-    case BlendFactor::DestColor:
-        return MTL::BlendFactorDestinationColor;
-    case BlendFactor::InvDestColor:
-        return MTL::BlendFactorOneMinusDestinationColor;
-    case BlendFactor::SrcAlphaSaturate:
-        return MTL::BlendFactorSourceAlphaSaturated;
-    case BlendFactor::BlendColor:
-        return MTL::BlendFactorBlendColor;
-    case BlendFactor::InvBlendColor:
-        return MTL::BlendFactorOneMinusBlendColor;
-    case BlendFactor::SecondarySrcColor:
-        return MTL::BlendFactorSource1Color;
-    case BlendFactor::InvSecondarySrcColor:
-        return MTL::BlendFactorOneMinusSource1Color;
-    case BlendFactor::SecondarySrcAlpha:
-        return MTL::BlendFactorSource1Alpha;
-    case BlendFactor::InvSecondarySrcAlpha:
-        return MTL::BlendFactorOneMinusSource1Alpha;
-    default:
-        return MTL::BlendFactor(0);
+    case BlendFactor::Zero:                 return MTL::BlendFactorZero;
+    case BlendFactor::One:                  return MTL::BlendFactorOne;
+    case BlendFactor::SrcColor:             return MTL::BlendFactorSourceColor;
+    case BlendFactor::InvSrcColor:          return MTL::BlendFactorOneMinusSourceColor;
+    case BlendFactor::SrcAlpha:             return MTL::BlendFactorSourceAlpha;
+    case BlendFactor::InvSrcAlpha:          return MTL::BlendFactorOneMinusSourceAlpha;
+    case BlendFactor::DestAlpha:            return MTL::BlendFactorDestinationAlpha;
+    case BlendFactor::InvDestAlpha:         return MTL::BlendFactorOneMinusDestinationAlpha;
+    case BlendFactor::DestColor:            return MTL::BlendFactorDestinationColor;
+    case BlendFactor::InvDestColor:         return MTL::BlendFactorOneMinusDestinationColor;
+    case BlendFactor::SrcAlphaSaturate:     return MTL::BlendFactorSourceAlphaSaturated;
+    case BlendFactor::BlendColor:           return MTL::BlendFactorBlendColor;
+    case BlendFactor::InvBlendColor:        return MTL::BlendFactorOneMinusBlendColor;
+    case BlendFactor::SecondarySrcColor:    return MTL::BlendFactorSource1Color;
+    case BlendFactor::InvSecondarySrcColor: return MTL::BlendFactorOneMinusSource1Color;
+    case BlendFactor::SecondarySrcAlpha:    return MTL::BlendFactorSource1Alpha;
+    case BlendFactor::InvSecondarySrcAlpha: return MTL::BlendFactorOneMinusSource1Alpha;
+    default:                                return MTL::BlendFactor(0);
     }
 }
 
@@ -395,18 +332,12 @@ MTL::BlendOperation MetalUtil::translateBlendOperation(BlendOp op)
 {
     switch (op)
     {
-    case BlendOp::Add:
-        return MTL::BlendOperationAdd;
-    case BlendOp::Subtract:
-        return MTL::BlendOperationSubtract;
-    case BlendOp::ReverseSubtract:
-        return MTL::BlendOperationReverseSubtract;
-    case BlendOp::Min:
-        return MTL::BlendOperationMin;
-    case BlendOp::Max:
-        return MTL::BlendOperationMax;
-    default:
-        return MTL::BlendOperation(0);
+    case BlendOp::Add:             return MTL::BlendOperationAdd;
+    case BlendOp::Subtract:        return MTL::BlendOperationSubtract;
+    case BlendOp::ReverseSubtract: return MTL::BlendOperationReverseSubtract;
+    case BlendOp::Min:             return MTL::BlendOperationMin;
+    case BlendOp::Max:             return MTL::BlendOperationMax;
+    default:                       return MTL::BlendOperation(0);
     }
 }
 
@@ -428,12 +359,9 @@ MTL::Winding MetalUtil::translateWinding(FrontFaceMode mode)
 {
     switch (mode)
     {
-    case FrontFaceMode::CounterClockwise:
-        return MTL::WindingCounterClockwise;
-    case FrontFaceMode::Clockwise:
-        return MTL::WindingClockwise;
-    default:
-        return MTL::Winding(0);
+    case FrontFaceMode::CounterClockwise: return MTL::WindingCounterClockwise;
+    case FrontFaceMode::Clockwise:        return MTL::WindingClockwise;
+    default:                              return MTL::Winding(0);
     }
 }
 
@@ -441,14 +369,10 @@ MTL::CullMode MetalUtil::translateCullMode(CullMode mode)
 {
     switch (mode)
     {
-    case CullMode::None:
-        return MTL::CullModeNone;
-    case CullMode::Front:
-        return MTL::CullModeFront;
-    case CullMode::Back:
-        return MTL::CullModeBack;
-    default:
-        return MTL::CullMode(0);
+    case CullMode::None:  return MTL::CullModeNone;
+    case CullMode::Front: return MTL::CullModeFront;
+    case CullMode::Back:  return MTL::CullModeBack;
+    default:              return MTL::CullMode(0);
     }
 }
 
@@ -456,12 +380,9 @@ MTL::TriangleFillMode MetalUtil::translateTriangleFillMode(FillMode mode)
 {
     switch (mode)
     {
-    case FillMode::Solid:
-        return MTL::TriangleFillModeFill;
-    case FillMode::Wireframe:
-        return MTL::TriangleFillModeLines;
-    default:
-        return MTL::TriangleFillMode(0);
+    case FillMode::Solid:     return MTL::TriangleFillModeFill;
+    case FillMode::Wireframe: return MTL::TriangleFillModeLines;
+    default:                  return MTL::TriangleFillMode(0);
     }
 }
 
diff --git a/tools/gfx/metal/metal-util.h b/tools/gfx/metal/metal-util.h
index 279f0c67e..bcf988c3b 100644
--- a/tools/gfx/metal/metal-util.h
+++ b/tools/gfx/metal/metal-util.h
@@ -5,20 +5,28 @@
 #include "metal-api.h"
 #include "slang-gfx.h"
 
-namespace gfx {
+namespace gfx
+{
 
 // Utility functions for Metal
-struct MetalUtil 
+struct MetalUtil
 {
-    static NS::SharedPtr<NS::String> createString(const char* str, NS::StringEncoding encoding = NS::UTF8StringEncoding)
+    static NS::SharedPtr<NS::String> createString(
+        const char* str,
+        NS::StringEncoding encoding = NS::UTF8StringEncoding)
     {
-        NS::SharedPtr<NS::String> nsString = NS::TransferPtr(NS::String::alloc()->init(str, encoding));
+        NS::SharedPtr<NS::String> nsString =
+            NS::TransferPtr(NS::String::alloc()->init(str, encoding));
         return nsString;
     }
 
-    static NS::SharedPtr<NS::String> createStringView(void* bytes, size_t len, NS::StringEncoding encoding = NS::UTF8StringEncoding)
+    static NS::SharedPtr<NS::String> createStringView(
+        void* bytes,
+        size_t len,
+        NS::StringEncoding encoding = NS::UTF8StringEncoding)
     {
-        NS::SharedPtr<NS::String> nsString = NS::TransferPtr(NS::String::alloc()->init(bytes, len, encoding, false));
+        NS::SharedPtr<NS::String> nsString =
+            NS::TransferPtr(NS::String::alloc()->init(bytes, len, encoding, false));
         return nsString;
     }
 
@@ -31,7 +39,7 @@ struct MetalUtil
     static MTL::SamplerMinMagFilter translateSamplerMinMagFilter(TextureFilteringMode mode);
     static MTL::SamplerMipFilter translateSamplerMipFilter(TextureFilteringMode mode);
     static MTL::SamplerAddressMode translateSamplerAddressMode(TextureAddressingMode mode);
-    static MTL::CompareFunction translateCompareFunction(ComparisonFunc func); 
+    static MTL::CompareFunction translateCompareFunction(ComparisonFunc func);
     static MTL::StencilOperation translateStencilOperation(StencilOp op);
 
     static MTL::VertexStepFunction translateVertexStepFunction(InputSlotClass slotClass);
@@ -46,7 +54,6 @@ struct MetalUtil
     static MTL::Winding translateWinding(FrontFaceMode mode);
     static MTL::CullMode translateCullMode(CullMode mode);
     static MTL::TriangleFillMode translateTriangleFillMode(FillMode mode);
-
 };
 
 struct ScopedAutoreleasePool
diff --git a/tools/gfx/metal/metal-vertex-layout.cpp b/tools/gfx/metal/metal-vertex-layout.cpp
index 686f3ad0c..722d5396d 100644
--- a/tools/gfx/metal/metal-vertex-layout.cpp
+++ b/tools/gfx/metal/metal-vertex-layout.cpp
@@ -1,5 +1,6 @@
 // metal-vertex-layout.cpp
 #include "metal-vertex-layout.h"
+
 #include "metal-util.h"
 
 namespace gfx
@@ -14,7 +15,8 @@ Result InputLayoutImpl::init(const IInputLayout::Desc& desc)
 {
     for (Index i = 0; i < desc.inputElementCount; i++)
     {
-        if (MetalUtil::translateVertexFormat(desc.inputElements[i].format) == MTL::VertexFormatInvalid)
+        if (MetalUtil::translateVertexFormat(desc.inputElements[i].format) ==
+            MTL::VertexFormatInvalid)
         {
             return SLANG_E_INVALID_ARG;
         }
@@ -27,9 +29,11 @@ Result InputLayoutImpl::init(const IInputLayout::Desc& desc)
     return SLANG_OK;
 }
 
-NS::SharedPtr<MTL::VertexDescriptor> InputLayoutImpl::createVertexDescriptor(NS::UInteger vertexBufferIndexOffset)
+NS::SharedPtr<MTL::VertexDescriptor> InputLayoutImpl::createVertexDescriptor(
+    NS::UInteger vertexBufferIndexOffset)
 {
-    NS::SharedPtr<MTL::VertexDescriptor> vertexDescriptor = NS::TransferPtr(MTL::VertexDescriptor::alloc()->init());
+    NS::SharedPtr<MTL::VertexDescriptor> vertexDescriptor =
+        NS::TransferPtr(MTL::VertexDescriptor::alloc()->init());
 
     for (Index i = 0; i < m_inputElements.getCount(); i++)
     {
@@ -44,9 +48,13 @@ NS::SharedPtr<MTL::VertexDescriptor> InputLayoutImpl::createVertexDescriptor(NS:
     for (Index i = 0; i < m_vertexStreams.getCount(); i++)
     {
         const auto& vertexStream = m_vertexStreams[i];
-        MTL::VertexBufferLayoutDescriptor* desc = vertexDescriptor->layouts()->object(i + vertexBufferIndexOffset);
+        MTL::VertexBufferLayoutDescriptor* desc =
+            vertexDescriptor->layouts()->object(i + vertexBufferIndexOffset);
         desc->setStepFunction(MetalUtil::translateVertexStepFunction(vertexStream.slotClass));
-        desc->setStepRate(vertexStream.slotClass == InputSlotClass::PerVertex ? 1 : vertexStream.instanceDataStepRate);
+        desc->setStepRate(
+            vertexStream.slotClass == InputSlotClass::PerVertex
+                ? 1
+                : vertexStream.instanceDataStepRate);
         desc->setStride(vertexStream.stride);
     }
 
diff --git a/tools/gfx/metal/metal-vertex-layout.h b/tools/gfx/metal/metal-vertex-layout.h
index 5cfdf3dc6..26af7f496 100644
--- a/tools/gfx/metal/metal-vertex-layout.h
+++ b/tools/gfx/metal/metal-vertex-layout.h
@@ -18,7 +18,8 @@ public:
     List<VertexStreamDesc> m_vertexStreams;
 
     Result init(const IInputLayout::Desc& desc);
-    NS::SharedPtr<MTL::VertexDescriptor> createVertexDescriptor(NS::UInteger vertexBufferIndexOffset);
+    NS::SharedPtr<MTL::VertexDescriptor> createVertexDescriptor(
+        NS::UInteger vertexBufferIndexOffset);
 };
 
 } // namespace metal