Various gfx fixes. (#2132)

* Various gfx fixes.

* Fix test case.

* Fix crash.

* Trigger build

* Trigger build 2

* Fix vulkan unit tests.

Co-authored-by: Yong He <yhe@nvidia.com>

1 files changed, 611 insertions, 604 deletions

diff --git a/tools/gfx/d3d12/render-d3d12.cpp b/tools/gfx/d3d12/render-d3d12.cpp
index 36ec173d7..8457889df 100644
--- a/tools/gfx/d3d12/render-d3d12.cpp
+++ b/tools/gfx/d3d12/render-d3d12.cpp
@@ -9,6 +9,7 @@
 #include "../simple-render-pass-layout.h"
 #include "../d3d/d3d-swapchain.h"
 #include "../mutable-shader-object.h"
+#include "../command-encoder-com-forward.h"
 #include "core/slang-blob.h"
 #include "core/slang-basic.h"
 #include "core/slang-chunked-list.h"
@@ -63,8 +64,14 @@ struct ID3D12GraphicsCommandList1 {};
 #define ENABLE_DEBUG_LAYER 1
 
 namespace gfx {
+
 using namespace Slang;
 
+// Define function pointer types for PIX library.
+typedef HRESULT(WINAPI* PFN_BeginEventOnCommandList)(
+    ID3D12GraphicsCommandList* commandList, UINT64 color, _In_ PCSTR formatString);
+typedef HRESULT(WINAPI* PFN_EndEventOnCommandList)(ID3D12GraphicsCommandList* commandList);
+
 class D3D12Device : public RendererBase
 {
 public:
@@ -3600,543 +3607,12 @@ public:
             m_cmdList->QueryInterface<ID3D12GraphicsCommandList1>(m_cmdList1.writeRef());
         }
 
-        class RenderCommandEncoderImpl
-            : public IRenderCommandEncoder
-            , public PipelineCommandEncoder
-        {
-        public:
-            RefPtr<RenderPassLayoutImpl> m_renderPass;
-            RefPtr<FramebufferImpl> m_framebuffer;
-
-            List<BoundVertexBuffer> m_boundVertexBuffers;
-
-            RefPtr<BufferResourceImpl> m_boundIndexBuffer;
-
-            D3D12_VIEWPORT m_viewports[kMaxRTVCount];
-            D3D12_RECT m_scissorRects[kMaxRTVCount];
-
-            DXGI_FORMAT m_boundIndexFormat;
-            UINT m_boundIndexOffset;
-
-            D3D12_PRIMITIVE_TOPOLOGY_TYPE m_primitiveTopologyType;
-            D3D12_PRIMITIVE_TOPOLOGY m_primitiveTopology;
-
-            void init(
-                D3D12Device* renderer,
-                TransientResourceHeapImpl* transientHeap,
-                CommandBufferImpl* cmdBuffer,
-                RenderPassLayoutImpl* renderPass,
-                FramebufferImpl* framebuffer)
-            {
-                PipelineCommandEncoder::init(cmdBuffer);
-                m_preCmdList = nullptr;
-                m_renderPass = renderPass;
-                m_framebuffer = framebuffer;
-                m_transientHeap = transientHeap;
-                m_boundVertexBuffers.clear();
-                m_boundIndexBuffer = nullptr;
-                m_primitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
-                m_primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
-                m_boundIndexFormat = DXGI_FORMAT_UNKNOWN;
-                m_boundIndexOffset = 0;
-                m_currentPipeline = nullptr;
-
-                // Set render target states.
-                if (!framebuffer)
-                {
-                    return;
-                }
-                m_d3dCmdList->OMSetRenderTargets(
-                    (UINT)framebuffer->renderTargetViews.getCount(),
-                    framebuffer->renderTargetDescriptors.getArrayView().getBuffer(),
-                    FALSE,
-                    framebuffer->depthStencilView ? &framebuffer->depthStencilDescriptor : nullptr);
-
-                // Issue clear commands based on render pass set up.
-                for (Index i = 0; i < framebuffer->renderTargetViews.getCount(); i++)
-                {
-                    if (i >= renderPass->m_renderTargetAccesses.getCount())
-                        continue;
-
-                    auto& access = renderPass->m_renderTargetAccesses[i];
-
-                    // Transit resource states.
-                    {
-                        D3D12BarrierSubmitter submitter(m_d3dCmdList);
-                        auto resourceViewImpl = framebuffer->renderTargetViews[i].Ptr();
-                        if (resourceViewImpl)
-                        {
-                            auto textureResource = static_cast<TextureResourceImpl*>(
-                                resourceViewImpl->m_resource.Ptr());
-                            if (textureResource)
-                            {
-                                D3D12_RESOURCE_STATES initialState;
-                                if (access.initialState == ResourceState::Undefined)
-                                {
-                                    initialState = textureResource->m_defaultState;
-                                }
-                                else
-                                {
-                                    initialState = D3DUtil::getResourceState(access.initialState);
-                                }
-                                textureResource->m_resource.transition(
-                                    initialState, D3D12_RESOURCE_STATE_RENDER_TARGET, submitter);
-                            }
-                        }
-                    }
-                    // Clear.
-                    if (access.loadOp == IRenderPassLayout::AttachmentLoadOp::Clear)
-                    {
-                        m_d3dCmdList->ClearRenderTargetView(
-                            framebuffer->renderTargetDescriptors[i],
-                            framebuffer->renderTargetClearValues[i].values,
-                            0,
-                            nullptr);
-                    }
-                }
-
-                if (renderPass->m_hasDepthStencil)
-                {
-                    // Transit resource states.
-                    {
-                        D3D12BarrierSubmitter submitter(m_d3dCmdList);
-                        auto resourceViewImpl = framebuffer->depthStencilView.Ptr();
-                        auto textureResource =
-                            static_cast<TextureResourceImpl*>(resourceViewImpl->m_resource.Ptr());
-                        D3D12_RESOURCE_STATES initialState;
-                        if (renderPass->m_depthStencilAccess.initialState ==
-                            ResourceState::Undefined)
-                        {
-                            initialState = textureResource->m_defaultState;
-                        }
-                        else
-                        {
-                            initialState = D3DUtil::getResourceState(
-                                renderPass->m_depthStencilAccess.initialState);
-                        }
-                        textureResource->m_resource.transition(
-                            initialState,
-                            D3D12_RESOURCE_STATE_DEPTH_WRITE,
-                            submitter);
-                    }
-                    // Clear.
-                    uint32_t clearFlags = 0;
-                    if (renderPass->m_depthStencilAccess.loadOp ==
-                        IRenderPassLayout::AttachmentLoadOp::Clear)
-                    {
-                        clearFlags |= D3D12_CLEAR_FLAG_DEPTH;
-                    }
-                    if (renderPass->m_depthStencilAccess.stencilLoadOp ==
-                        IRenderPassLayout::AttachmentLoadOp::Clear)
-                    {
-                        clearFlags |= D3D12_CLEAR_FLAG_STENCIL;
-                    }
-                    if (clearFlags)
-                    {
-                        m_d3dCmdList->ClearDepthStencilView(
-                            framebuffer->depthStencilDescriptor,
-                            (D3D12_CLEAR_FLAGS)clearFlags,
-                            framebuffer->depthStencilClearValue.depth,
-                            framebuffer->depthStencilClearValue.stencil,
-                            0,
-                            nullptr);
-                    }
-                }
-            }
-
-            virtual SLANG_NO_THROW Result SLANG_MCALL
-                bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override
-            {
-                return bindPipelineImpl(state, outRootObject);
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL
-                setViewports(uint32_t count, const Viewport* viewports) override
-            {
-                static const int kMaxViewports =
-                    D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
-                assert(count <= kMaxViewports && count <= kMaxRTVCount);
-                for (UInt ii = 0; ii < count; ++ii)
-                {
-                    auto& inViewport = viewports[ii];
-                    auto& dxViewport = m_viewports[ii];
-
-                    dxViewport.TopLeftX = inViewport.originX;
-                    dxViewport.TopLeftY = inViewport.originY;
-                    dxViewport.Width = inViewport.extentX;
-                    dxViewport.Height = inViewport.extentY;
-                    dxViewport.MinDepth = inViewport.minZ;
-                    dxViewport.MaxDepth = inViewport.maxZ;
-                }
-                m_d3dCmdList->RSSetViewports(UINT(count), m_viewports);
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL
-                setScissorRects(uint32_t count, const ScissorRect* rects) override
-            {
-                static const int kMaxScissorRects =
-                    D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
-                assert(count <= kMaxScissorRects && count <= kMaxRTVCount);
-
-                for (UInt ii = 0; ii < count; ++ii)
-                {
-                    auto& inRect = rects[ii];
-                    auto& dxRect = m_scissorRects[ii];
-
-                    dxRect.left = LONG(inRect.minX);
-                    dxRect.top = LONG(inRect.minY);
-                    dxRect.right = LONG(inRect.maxX);
-                    dxRect.bottom = LONG(inRect.maxY);
-                }
-
-                m_d3dCmdList->RSSetScissorRects(UINT(count), m_scissorRects);
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL
-                setPrimitiveTopology(PrimitiveTopology topology) override
-            {
-                m_primitiveTopologyType = D3DUtil::getPrimitiveType(topology);
-                m_primitiveTopology = D3DUtil::getPrimitiveTopology(topology);
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
-                uint32_t startSlot,
-                uint32_t slotCount,
-                IBufferResource* const* buffers,
-                const uint32_t* offsets) override
-            {
-                {
-                    const Index num = startSlot + slotCount;
-                    if (num > m_boundVertexBuffers.getCount())
-                    {
-                        m_boundVertexBuffers.setCount(num);
-                    }
-                }
-
-                for (UInt i = 0; i < slotCount; i++)
-                {
-                    BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(buffers[i]);
-
-                    BoundVertexBuffer& boundBuffer = m_boundVertexBuffers[startSlot + i];
-                    boundBuffer.m_buffer = buffer;
-                    boundBuffer.m_offset = int(offsets[i]);
-                }
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL setIndexBuffer(
-                IBufferResource* buffer, Format indexFormat, uint32_t offset = 0) override
-            {
-                m_boundIndexBuffer = (BufferResourceImpl*)buffer;
-                m_boundIndexFormat = D3DUtil::getMapFormat(indexFormat);
-                m_boundIndexOffset = offset;
-            }
-
-            void prepareDraw()
-            {
-                auto pipelineState = m_currentPipeline.Ptr();
-                if (!pipelineState || (pipelineState->desc.type != PipelineType::Graphics))
-                {
-                    assert(!"No graphics pipeline state set");
-                    return;
-                }
-
-                // Submit - setting for graphics
-                {
-                    GraphicsSubmitter submitter(m_d3dCmdList);
-                    RefPtr<PipelineStateBase> newPipeline;
-                    if(SLANG_FAILED(_bindRenderState(&submitter, newPipeline)))
-                    {
-                        assert(!"Failed to bind render state");
-                    }
-                }
-
-                m_d3dCmdList->IASetPrimitiveTopology(m_primitiveTopology);
-
-                // Set up vertex buffer views
-                {
-                    auto inputLayout = (InputLayoutImpl*)pipelineState->inputLayout.Ptr();
-                    if (inputLayout)
-                    {
-                        int numVertexViews = 0;
-                        D3D12_VERTEX_BUFFER_VIEW vertexViews[16];
-                        for (Index i = 0; i < m_boundVertexBuffers.getCount(); i++)
-                        {
-                            const BoundVertexBuffer& boundVertexBuffer = m_boundVertexBuffers[i];
-                            BufferResourceImpl* buffer = boundVertexBuffer.m_buffer;
-                            if (buffer)
-                            {
-                                D3D12_VERTEX_BUFFER_VIEW& vertexView =
-                                    vertexViews[numVertexViews++];
-                                vertexView.BufferLocation =
-                                    buffer->m_resource.getResource()->GetGPUVirtualAddress() +
-                                    boundVertexBuffer.m_offset;
-                                vertexView.SizeInBytes = UINT(
-                                    buffer->getDesc()->sizeInBytes - boundVertexBuffer.m_offset);
-                                vertexView.StrideInBytes = inputLayout->m_vertexStreamStrides[i];
-                            }
-                        }
-                        m_d3dCmdList->IASetVertexBuffers(0, numVertexViews, vertexViews);
-                    }
-                }
-                // Set up index buffer
-                if (m_boundIndexBuffer)
-                {
-                    D3D12_INDEX_BUFFER_VIEW indexBufferView;
-                    indexBufferView.BufferLocation =
-                        m_boundIndexBuffer->m_resource.getResource()->GetGPUVirtualAddress() +
-                        m_boundIndexOffset;
-                    indexBufferView.SizeInBytes =
-                        UINT(m_boundIndexBuffer->getDesc()->sizeInBytes - m_boundIndexOffset);
-                    indexBufferView.Format = m_boundIndexFormat;
-
-                    m_d3dCmdList->IASetIndexBuffer(&indexBufferView);
-                }
-            }
-            virtual SLANG_NO_THROW void SLANG_MCALL
-                draw(uint32_t vertexCount, uint32_t startVertex = 0) override
-            {
-                prepareDraw();
-                m_d3dCmdList->DrawInstanced(vertexCount, 1, startVertex, 0);
-            }
-            virtual SLANG_NO_THROW void SLANG_MCALL drawIndexed(
-                uint32_t indexCount, uint32_t startIndex = 0, uint32_t baseVertex = 0) override
-            {
-                prepareDraw();
-                m_d3dCmdList->DrawIndexedInstanced(indexCount, 1, startIndex, baseVertex, 0);
-            }
-            virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override
-            {
-                PipelineCommandEncoder::endEncodingImpl();
-                if (!m_framebuffer)
-                    return;
-                // Issue clear commands based on render pass set up.
-                for (Index i = 0; i < m_renderPass->m_renderTargetAccesses.getCount(); i++)
-                {
-                    auto& access = m_renderPass->m_renderTargetAccesses[i];
-
-                    // Transit resource states.
-                    {
-                        D3D12BarrierSubmitter submitter(m_d3dCmdList);
-                        auto resourceViewImpl = m_framebuffer->renderTargetViews[i].Ptr();
-                        if (!resourceViewImpl)
-                            continue;
-                        auto textureResource =
-                            static_cast<TextureResourceImpl*>(resourceViewImpl->m_resource.Ptr());
-                        if (textureResource)
-                        {
-                            textureResource->m_resource.transition(
-                                D3D12_RESOURCE_STATE_RENDER_TARGET,
-                                D3DUtil::getResourceState(access.finalState),
-                                submitter);
-                        }
-                    }
-                }
-
-                if (m_renderPass->m_hasDepthStencil)
-                {
-                    // Transit resource states.
-                    D3D12BarrierSubmitter submitter(m_d3dCmdList);
-                    auto resourceViewImpl = m_framebuffer->depthStencilView.Ptr();
-                    auto textureResource =
-                        static_cast<TextureResourceImpl*>(resourceViewImpl->m_resource.Ptr());
-                    textureResource->m_resource.transition(
-                        D3D12_RESOURCE_STATE_DEPTH_WRITE,
-                        D3DUtil::getResourceState(
-                            m_renderPass->m_depthStencilAccess.finalState),
-                        submitter);
-                }
-                m_framebuffer = nullptr;
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL writeTimestamp(IQueryPool* pool, SlangInt index) override
-            {
-                static_cast<QueryPoolImpl*>(pool)->writeTimestamp(m_d3dCmdList, index);
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL
-                setStencilReference(uint32_t referenceValue) override
-            {
-                m_d3dCmdList->OMSetStencilRef((UINT)referenceValue);
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL drawIndirect(
-                uint32_t maxDrawCount,
-                IBufferResource* argBuffer,
-                uint64_t argOffset,
-                IBufferResource* countBuffer,
-                uint64_t countOffset) override
-            {
-                prepareDraw();
-
-                auto argBufferImpl = static_cast<BufferResourceImpl*>(argBuffer);
-                auto countBufferImpl = static_cast<BufferResourceImpl*>(countBuffer);
-
-                m_d3dCmdList->ExecuteIndirect(
-                    m_renderer->drawIndirectCmdSignature,
-                    maxDrawCount,
-                    argBufferImpl->m_resource,
-                    argOffset,
-                    countBufferImpl ? countBufferImpl->m_resource.getResource() : nullptr,
-                    countOffset);
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedIndirect(
-                uint32_t maxDrawCount,
-                IBufferResource* argBuffer,
-                uint64_t argOffset,
-                IBufferResource* countBuffer,
-                uint64_t countOffset) override
-            {
-                prepareDraw();
-
-                auto argBufferImpl = static_cast<BufferResourceImpl*>(argBuffer);
-                auto countBufferImpl = static_cast<BufferResourceImpl*>(countBuffer);
-
-                m_d3dCmdList->ExecuteIndirect(
-                    m_renderer->drawIndexedIndirectCmdSignature,
-                    maxDrawCount,
-                    argBufferImpl->m_resource,
-                    argOffset,
-                    countBufferImpl ? countBufferImpl->m_resource.getResource() : nullptr,
-                    countOffset);
-            }
-
-            virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
-                uint32_t samplesPerPixel,
-                uint32_t pixelCount,
-                const SamplePosition* samplePositions) override
-            {
-                if (m_commandBuffer->m_cmdList1)
-                {
-                    m_commandBuffer->m_cmdList1->SetSamplePositions(
-                        samplesPerPixel, pixelCount, (D3D12_SAMPLE_POSITION*)samplePositions);
-                    return SLANG_OK;
-                }
-                return SLANG_E_NOT_AVAILABLE;
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
-                uint32_t vertexCount,
-                uint32_t instanceCount,
-                uint32_t startVertex,
-                uint32_t startInstanceLocation) override
-            {
-                prepareDraw();
-                m_d3dCmdList->DrawInstanced(
-                    vertexCount, instanceCount, startVertex, startInstanceLocation);
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
-                uint32_t indexCount,
-                uint32_t instanceCount,
-                uint32_t startIndexLocation,
-                int32_t baseVertexLocation,
-                uint32_t startInstanceLocation) override
-            {
-                prepareDraw();
-                m_d3dCmdList->DrawIndexedInstanced(indexCount, instanceCount, startIndexLocation, baseVertexLocation, startInstanceLocation);
-            }
-        };
-
-        RenderCommandEncoderImpl m_renderCommandEncoder;
-        virtual SLANG_NO_THROW void SLANG_MCALL encodeRenderCommands(
-            IRenderPassLayout* renderPass,
-            IFramebuffer* framebuffer,
-            IRenderCommandEncoder** outEncoder) override
-        {
-            m_renderCommandEncoder.init(
-                m_renderer,
-                m_transientHeap,
-                this,
-                static_cast<RenderPassLayoutImpl*>(renderPass),
-                static_cast<FramebufferImpl*>(framebuffer));
-            *outEncoder = &m_renderCommandEncoder;
-        }
-
-        class ComputeCommandEncoderImpl
-            : public IComputeCommandEncoder
+        
+        class ResourceCommandEncoderImpl
+            : public IResourceCommandEncoder
             , public PipelineCommandEncoder
         {
         public:
-            virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override
-            {
-                PipelineCommandEncoder::endEncodingImpl();
-            }
-            virtual SLANG_NO_THROW void SLANG_MCALL writeTimestamp(IQueryPool* pool, SlangInt index) override
-            {
-                static_cast<QueryPoolImpl*>(pool)->writeTimestamp(m_d3dCmdList, index);
-            }
-            void init(
-                D3D12Device* renderer,
-                TransientResourceHeapImpl* transientHeap,
-                CommandBufferImpl* cmdBuffer)
-            {
-                PipelineCommandEncoder::init(cmdBuffer);
-                m_preCmdList = nullptr;
-                m_transientHeap = transientHeap;
-                m_currentPipeline = nullptr;
-            }
-
-            virtual SLANG_NO_THROW Result SLANG_MCALL
-                bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override
-            {
-                return bindPipelineImpl(state, outRootObject);
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override
-            {
-                // Submit binding for compute
-                {
-                    ComputeSubmitter submitter(m_d3dCmdList);
-                    RefPtr<PipelineStateBase> newPipeline;
-                    if (SLANG_FAILED(_bindRenderState(&submitter, newPipeline)))
-                    {
-                        assert(!"Failed to bind render state");
-                    }
-                }
-                m_d3dCmdList->Dispatch(x, y, z);
-            }
-
-            virtual SLANG_NO_THROW void SLANG_MCALL
-                dispatchComputeIndirect(IBufferResource* argBuffer, uint64_t offset) override
-            {
-                // Submit binding for compute
-                {
-                    ComputeSubmitter submitter(m_d3dCmdList);
-                    RefPtr<PipelineStateBase> newPipeline;
-                    if (SLANG_FAILED(_bindRenderState(&submitter, newPipeline)))
-                    {
-                        assert(!"Failed to bind render state");
-                    }
-                }
-                auto argBufferImpl = static_cast<BufferResourceImpl*>(argBuffer);
-
-                m_d3dCmdList->ExecuteIndirect(
-                    m_renderer->dispatchIndirectCmdSignature,
-                    1,
-                    argBufferImpl->m_resource,
-                    offset,
-                    nullptr,
-                    0);
-            }
-        };
-
-        ComputeCommandEncoderImpl m_computeCommandEncoder;
-        virtual SLANG_NO_THROW void SLANG_MCALL
-            encodeComputeCommands(IComputeCommandEncoder** outEncoder) override
-        {
-            m_computeCommandEncoder.init(m_renderer, m_transientHeap, this);
-            *outEncoder = &m_computeCommandEncoder;
-        }
-
-        class ResourceCommandEncoderImpl : public IResourceCommandEncoder
-        {
-        public:
-            CommandBufferImpl* m_commandBuffer;
-            void init(D3D12Device* renderer, CommandBufferImpl* commandBuffer)
-            {
-                m_commandBuffer = commandBuffer;
-            }
             virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(
                 IBufferResource* dst,
                 size_t dstOffset,
@@ -4155,10 +3631,7 @@ public:
                     size);
             }
             virtual SLANG_NO_THROW void SLANG_MCALL uploadBufferData(
-                IBufferResource* dst,
-                size_t offset,
-                size_t size,
-                void* data) override
+                IBufferResource* dst, size_t offset, size_t size, void* data) override
             {
                 _uploadBufferData(
                     m_commandBuffer->m_renderer->m_device,
@@ -4269,9 +3742,11 @@ public:
                 }
             }
             virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() {}
-            virtual SLANG_NO_THROW void SLANG_MCALL writeTimestamp(IQueryPool* pool, SlangInt index) override
+            virtual SLANG_NO_THROW void SLANG_MCALL
+                writeTimestamp(IQueryPool* pool, SlangInt index) override
             {
-                static_cast<QueryPoolImpl*>(pool)->writeTimestamp(m_commandBuffer->m_cmdList, index);
+                static_cast<QueryPoolImpl*>(pool)->writeTimestamp(
+                    m_commandBuffer->m_cmdList, index);
             }
             virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
                 ITextureResource* dst,
@@ -4383,7 +3858,7 @@ public:
                     D3D12_TEXTURE_COPY_LOCATION srcRegion = {};
                     srcRegion.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
                     D3D12_PLACED_SUBRESOURCE_FOOTPRINT& footprint = srcRegion.PlacedFootprint;
-                    
+
                     footprint.Offset = 0;
                     footprint.Footprint.Format = texDesc.Format;
                     uint32_t mipLevel = D3DUtil::getSubresourceMipLevel(
@@ -4394,7 +3869,8 @@ public:
                     }
                     else
                     {
-                        footprint.Footprint.Width = Math::Max(1, (textureSize.width >> mipLevel)) - offset.x;
+                        footprint.Footprint.Width =
+                            Math::Max(1, (textureSize.width >> mipLevel)) - offset.x;
                     }
                     if (extent.height != ITextureResource::kRemainingTextureSize)
                     {
@@ -4428,13 +3904,15 @@ public:
                     m_commandBuffer->m_transientHeap->allocateStagingBuffer(
                         bufferSize, stagingBuffer, ResourceState::General);
 
-                    BufferResourceImpl* bufferImpl = static_cast<BufferResourceImpl*>(stagingBuffer);
+                    BufferResourceImpl* bufferImpl =
+                        static_cast<BufferResourceImpl*>(stagingBuffer);
                     uint8_t* bufferData = nullptr;
                     D3D12_RANGE mapRange = {0, 0};
                     bufferImpl->m_resource.getResource()->Map(0, &mapRange, (void**)&bufferData);
                     for (uint32_t z = 0; z < footprint.Footprint.Depth; z++)
                     {
-                        auto imageStart = bufferData + footprint.Footprint.RowPitch * rowCount * (size_t)z;
+                        auto imageStart =
+                            bufferData + footprint.Footprint.RowPitch * rowCount * (size_t)z;
                         auto srcData =
                             (uint8_t*)subResourceData->data + subResourceData->strideZ * z;
                         for (uint32_t row = 0; row < rowCount; row++)
@@ -4682,8 +4160,7 @@ public:
                 for (uint32_t layer = 0; layer < srcSubresource.layerCount; layer++)
                 {
                     // Get the footprint
-                    D3D12_RESOURCE_DESC texDesc =
-                        srcTexture->m_resource.getResource()->GetDesc();
+                    D3D12_RESOURCE_DESC texDesc = srcTexture->m_resource.getResource()->GetDesc();
 
                     D3D12_TEXTURE_COPY_LOCATION dstRegion = {};
                     dstRegion.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
@@ -4734,8 +4211,8 @@ public:
                         footprint.Footprint.Width * (UInt)formatInfo.blockSizeInBytes,
                         (uint32_t)D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
 
-                    auto bufferSize = footprint.Footprint.RowPitch *
-                                        footprint.Footprint.Height * footprint.Footprint.Depth;
+                    auto bufferSize = footprint.Footprint.RowPitch * footprint.Footprint.Height *
+                                      footprint.Footprint.Depth;
 
                     D3D12_BOX srcBox = {};
                     srcBox.left = srcOffset.x;
@@ -4804,6 +4281,28 @@ public:
                 m_commandBuffer->m_cmdList->ResourceBarrier(
                     (UINT)barriers.getCount(), barriers.getArrayView().getBuffer());
             }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL
+                beginDebugEvent(const char* name, float rgbColor[3]) override
+            {
+                auto beginEvent = m_commandBuffer->m_renderer->m_BeginEventOnCommandList;
+                if (beginEvent)
+                {
+                    beginEvent(
+                        m_commandBuffer->m_cmdList,
+                        0xff000000 | (uint8_t(rgbColor[0] * 255.0f) << 16) |
+                            (uint8_t(rgbColor[1] * 255.0f) << 8) | uint8_t(rgbColor[2] * 255.0f),
+                        name);
+                }
+            }
+            virtual SLANG_NO_THROW void SLANG_MCALL endDebugEvent() override
+            {
+                auto endEvent = m_commandBuffer->m_renderer->m_EndEventOnCommandList;
+                if (endEvent)
+                {
+                    endEvent(m_commandBuffer->m_cmdList);
+                }
+            }
         };
 
         ResourceCommandEncoderImpl m_resourceCommandEncoder;
@@ -4811,22 +4310,542 @@ public:
         virtual SLANG_NO_THROW void SLANG_MCALL
             encodeResourceCommands(IResourceCommandEncoder** outEncoder) override
         {
-            m_resourceCommandEncoder.init(m_renderer, this);
+            m_resourceCommandEncoder.init(this);
             *outEncoder = &m_resourceCommandEncoder;
         }
 
+        class RenderCommandEncoderImpl
+            : public IRenderCommandEncoder
+            , public ResourceCommandEncoderImpl
+        {
+        public:
+            SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoderImpl)
+        public:
+            RefPtr<RenderPassLayoutImpl> m_renderPass;
+            RefPtr<FramebufferImpl> m_framebuffer;
+
+            List<BoundVertexBuffer> m_boundVertexBuffers;
+
+            RefPtr<BufferResourceImpl> m_boundIndexBuffer;
+
+            D3D12_VIEWPORT m_viewports[kMaxRTVCount];
+            D3D12_RECT m_scissorRects[kMaxRTVCount];
+
+            DXGI_FORMAT m_boundIndexFormat;
+            UINT m_boundIndexOffset;
+
+            D3D12_PRIMITIVE_TOPOLOGY_TYPE m_primitiveTopologyType;
+            D3D12_PRIMITIVE_TOPOLOGY m_primitiveTopology;
+
+            void init(
+                D3D12Device* renderer,
+                TransientResourceHeapImpl* transientHeap,
+                CommandBufferImpl* cmdBuffer,
+                RenderPassLayoutImpl* renderPass,
+                FramebufferImpl* framebuffer)
+            {
+                PipelineCommandEncoder::init(cmdBuffer);
+                m_preCmdList = nullptr;
+                m_renderPass = renderPass;
+                m_framebuffer = framebuffer;
+                m_transientHeap = transientHeap;
+                m_boundVertexBuffers.clear();
+                m_boundIndexBuffer = nullptr;
+                m_primitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
+                m_primitiveTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
+                m_boundIndexFormat = DXGI_FORMAT_UNKNOWN;
+                m_boundIndexOffset = 0;
+                m_currentPipeline = nullptr;
+
+                // Set render target states.
+                if (!framebuffer)
+                {
+                    return;
+                }
+                m_d3dCmdList->OMSetRenderTargets(
+                    (UINT)framebuffer->renderTargetViews.getCount(),
+                    framebuffer->renderTargetDescriptors.getArrayView().getBuffer(),
+                    FALSE,
+                    framebuffer->depthStencilView ? &framebuffer->depthStencilDescriptor : nullptr);
+
+                // Issue clear commands based on render pass set up.
+                for (Index i = 0; i < framebuffer->renderTargetViews.getCount(); i++)
+                {
+                    if (i >= renderPass->m_renderTargetAccesses.getCount())
+                        continue;
+
+                    auto& access = renderPass->m_renderTargetAccesses[i];
+
+                    // Transit resource states.
+                    {
+                        D3D12BarrierSubmitter submitter(m_d3dCmdList);
+                        auto resourceViewImpl = framebuffer->renderTargetViews[i].Ptr();
+                        if (resourceViewImpl)
+                        {
+                            auto textureResource = static_cast<TextureResourceImpl*>(
+                                resourceViewImpl->m_resource.Ptr());
+                            if (textureResource)
+                            {
+                                D3D12_RESOURCE_STATES initialState;
+                                if (access.initialState == ResourceState::Undefined)
+                                {
+                                    initialState = textureResource->m_defaultState;
+                                }
+                                else
+                                {
+                                    initialState = D3DUtil::getResourceState(access.initialState);
+                                }
+                                textureResource->m_resource.transition(
+                                    initialState, D3D12_RESOURCE_STATE_RENDER_TARGET, submitter);
+                            }
+                        }
+                    }
+                    // Clear.
+                    if (access.loadOp == IRenderPassLayout::AttachmentLoadOp::Clear)
+                    {
+                        m_d3dCmdList->ClearRenderTargetView(
+                            framebuffer->renderTargetDescriptors[i],
+                            framebuffer->renderTargetClearValues[i].values,
+                            0,
+                            nullptr);
+                    }
+                }
+
+                if (renderPass->m_hasDepthStencil)
+                {
+                    // Transit resource states.
+                    {
+                        D3D12BarrierSubmitter submitter(m_d3dCmdList);
+                        auto resourceViewImpl = framebuffer->depthStencilView.Ptr();
+                        auto textureResource =
+                            static_cast<TextureResourceImpl*>(resourceViewImpl->m_resource.Ptr());
+                        D3D12_RESOURCE_STATES initialState;
+                        if (renderPass->m_depthStencilAccess.initialState ==
+                            ResourceState::Undefined)
+                        {
+                            initialState = textureResource->m_defaultState;
+                        }
+                        else
+                        {
+                            initialState = D3DUtil::getResourceState(
+                                renderPass->m_depthStencilAccess.initialState);
+                        }
+                        textureResource->m_resource.transition(
+                            initialState,
+                            D3D12_RESOURCE_STATE_DEPTH_WRITE,
+                            submitter);
+                    }
+                    // Clear.
+                    uint32_t clearFlags = 0;
+                    if (renderPass->m_depthStencilAccess.loadOp ==
+                        IRenderPassLayout::AttachmentLoadOp::Clear)
+                    {
+                        clearFlags |= D3D12_CLEAR_FLAG_DEPTH;
+                    }
+                    if (renderPass->m_depthStencilAccess.stencilLoadOp ==
+                        IRenderPassLayout::AttachmentLoadOp::Clear)
+                    {
+                        clearFlags |= D3D12_CLEAR_FLAG_STENCIL;
+                    }
+                    if (clearFlags)
+                    {
+                        m_d3dCmdList->ClearDepthStencilView(
+                            framebuffer->depthStencilDescriptor,
+                            (D3D12_CLEAR_FLAGS)clearFlags,
+                            framebuffer->depthStencilClearValue.depth,
+                            framebuffer->depthStencilClearValue.stencil,
+                            0,
+                            nullptr);
+                    }
+                }
+            }
+
+            virtual SLANG_NO_THROW Result SLANG_MCALL
+                bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override
+            {
+                return bindPipelineImpl(state, outRootObject);
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL
+                setViewports(uint32_t count, const Viewport* viewports) override
+            {
+                static const int kMaxViewports =
+                    D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
+                assert(count <= kMaxViewports && count <= kMaxRTVCount);
+                for (UInt ii = 0; ii < count; ++ii)
+                {
+                    auto& inViewport = viewports[ii];
+                    auto& dxViewport = m_viewports[ii];
+
+                    dxViewport.TopLeftX = inViewport.originX;
+                    dxViewport.TopLeftY = inViewport.originY;
+                    dxViewport.Width = inViewport.extentX;
+                    dxViewport.Height = inViewport.extentY;
+                    dxViewport.MinDepth = inViewport.minZ;
+                    dxViewport.MaxDepth = inViewport.maxZ;
+                }
+                m_d3dCmdList->RSSetViewports(UINT(count), m_viewports);
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL
+                setScissorRects(uint32_t count, const ScissorRect* rects) override
+            {
+                static const int kMaxScissorRects =
+                    D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
+                assert(count <= kMaxScissorRects && count <= kMaxRTVCount);
+
+                for (UInt ii = 0; ii < count; ++ii)
+                {
+                    auto& inRect = rects[ii];
+                    auto& dxRect = m_scissorRects[ii];
+
+                    dxRect.left = LONG(inRect.minX);
+                    dxRect.top = LONG(inRect.minY);
+                    dxRect.right = LONG(inRect.maxX);
+                    dxRect.bottom = LONG(inRect.maxY);
+                }
+
+                m_d3dCmdList->RSSetScissorRects(UINT(count), m_scissorRects);
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL
+                setPrimitiveTopology(PrimitiveTopology topology) override
+            {
+                m_primitiveTopologyType = D3DUtil::getPrimitiveType(topology);
+                m_primitiveTopology = D3DUtil::getPrimitiveTopology(topology);
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
+                uint32_t startSlot,
+                uint32_t slotCount,
+                IBufferResource* const* buffers,
+                const uint32_t* offsets) override
+            {
+                {
+                    const Index num = startSlot + slotCount;
+                    if (num > m_boundVertexBuffers.getCount())
+                    {
+                        m_boundVertexBuffers.setCount(num);
+                    }
+                }
+
+                for (UInt i = 0; i < slotCount; i++)
+                {
+                    BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(buffers[i]);
+
+                    BoundVertexBuffer& boundBuffer = m_boundVertexBuffers[startSlot + i];
+                    boundBuffer.m_buffer = buffer;
+                    boundBuffer.m_offset = int(offsets[i]);
+                }
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL setIndexBuffer(
+                IBufferResource* buffer, Format indexFormat, uint32_t offset = 0) override
+            {
+                m_boundIndexBuffer = (BufferResourceImpl*)buffer;
+                m_boundIndexFormat = D3DUtil::getMapFormat(indexFormat);
+                m_boundIndexOffset = offset;
+            }
+
+            void prepareDraw()
+            {
+                auto pipelineState = m_currentPipeline.Ptr();
+                if (!pipelineState || (pipelineState->desc.type != PipelineType::Graphics))
+                {
+                    assert(!"No graphics pipeline state set");
+                    return;
+                }
+
+                // Submit - setting for graphics
+                {
+                    GraphicsSubmitter submitter(m_d3dCmdList);
+                    RefPtr<PipelineStateBase> newPipeline;
+                    if(SLANG_FAILED(_bindRenderState(&submitter, newPipeline)))
+                    {
+                        assert(!"Failed to bind render state");
+                    }
+                }
+
+                m_d3dCmdList->IASetPrimitiveTopology(m_primitiveTopology);
+
+                // Set up vertex buffer views
+                {
+                    auto inputLayout = (InputLayoutImpl*)pipelineState->inputLayout.Ptr();
+                    if (inputLayout)
+                    {
+                        int numVertexViews = 0;
+                        D3D12_VERTEX_BUFFER_VIEW vertexViews[16];
+                        for (Index i = 0; i < m_boundVertexBuffers.getCount(); i++)
+                        {
+                            const BoundVertexBuffer& boundVertexBuffer = m_boundVertexBuffers[i];
+                            BufferResourceImpl* buffer = boundVertexBuffer.m_buffer;
+                            if (buffer)
+                            {
+                                D3D12_VERTEX_BUFFER_VIEW& vertexView =
+                                    vertexViews[numVertexViews++];
+                                vertexView.BufferLocation =
+                                    buffer->m_resource.getResource()->GetGPUVirtualAddress() +
+                                    boundVertexBuffer.m_offset;
+                                vertexView.SizeInBytes = UINT(
+                                    buffer->getDesc()->sizeInBytes - boundVertexBuffer.m_offset);
+                                vertexView.StrideInBytes = inputLayout->m_vertexStreamStrides[i];
+                            }
+                        }
+                        m_d3dCmdList->IASetVertexBuffers(0, numVertexViews, vertexViews);
+                    }
+                }
+                // Set up index buffer
+                if (m_boundIndexBuffer)
+                {
+                    D3D12_INDEX_BUFFER_VIEW indexBufferView;
+                    indexBufferView.BufferLocation =
+                        m_boundIndexBuffer->m_resource.getResource()->GetGPUVirtualAddress() +
+                        m_boundIndexOffset;
+                    indexBufferView.SizeInBytes =
+                        UINT(m_boundIndexBuffer->getDesc()->sizeInBytes - m_boundIndexOffset);
+                    indexBufferView.Format = m_boundIndexFormat;
+
+                    m_d3dCmdList->IASetIndexBuffer(&indexBufferView);
+                }
+            }
+            virtual SLANG_NO_THROW void SLANG_MCALL
+                draw(uint32_t vertexCount, uint32_t startVertex = 0) override
+            {
+                prepareDraw();
+                m_d3dCmdList->DrawInstanced(vertexCount, 1, startVertex, 0);
+            }
+            virtual SLANG_NO_THROW void SLANG_MCALL drawIndexed(
+                uint32_t indexCount, uint32_t startIndex = 0, uint32_t baseVertex = 0) override
+            {
+                prepareDraw();
+                m_d3dCmdList->DrawIndexedInstanced(indexCount, 1, startIndex, baseVertex, 0);
+            }
+            virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override
+            {
+                PipelineCommandEncoder::endEncodingImpl();
+                if (!m_framebuffer)
+                    return;
+                // Issue clear commands based on render pass set up.
+                for (Index i = 0; i < m_renderPass->m_renderTargetAccesses.getCount(); i++)
+                {
+                    auto& access = m_renderPass->m_renderTargetAccesses[i];
+
+                    // Transit resource states.
+                    {
+                        D3D12BarrierSubmitter submitter(m_d3dCmdList);
+                        auto resourceViewImpl = m_framebuffer->renderTargetViews[i].Ptr();
+                        if (!resourceViewImpl)
+                            continue;
+                        auto textureResource =
+                            static_cast<TextureResourceImpl*>(resourceViewImpl->m_resource.Ptr());
+                        if (textureResource)
+                        {
+                            textureResource->m_resource.transition(
+                                D3D12_RESOURCE_STATE_RENDER_TARGET,
+                                D3DUtil::getResourceState(access.finalState),
+                                submitter);
+                        }
+                    }
+                }
+
+                if (m_renderPass->m_hasDepthStencil)
+                {
+                    // Transit resource states.
+                    D3D12BarrierSubmitter submitter(m_d3dCmdList);
+                    auto resourceViewImpl = m_framebuffer->depthStencilView.Ptr();
+                    auto textureResource =
+                        static_cast<TextureResourceImpl*>(resourceViewImpl->m_resource.Ptr());
+                    textureResource->m_resource.transition(
+                        D3D12_RESOURCE_STATE_DEPTH_WRITE,
+                        D3DUtil::getResourceState(
+                            m_renderPass->m_depthStencilAccess.finalState),
+                        submitter);
+                }
+                m_framebuffer = nullptr;
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL
+                setStencilReference(uint32_t referenceValue) override
+            {
+                m_d3dCmdList->OMSetStencilRef((UINT)referenceValue);
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL drawIndirect(
+                uint32_t maxDrawCount,
+                IBufferResource* argBuffer,
+                uint64_t argOffset,
+                IBufferResource* countBuffer,
+                uint64_t countOffset) override
+            {
+                prepareDraw();
+
+                auto argBufferImpl = static_cast<BufferResourceImpl*>(argBuffer);
+                auto countBufferImpl = static_cast<BufferResourceImpl*>(countBuffer);
+
+                m_d3dCmdList->ExecuteIndirect(
+                    m_renderer->drawIndirectCmdSignature,
+                    maxDrawCount,
+                    argBufferImpl->m_resource,
+                    argOffset,
+                    countBufferImpl ? countBufferImpl->m_resource.getResource() : nullptr,
+                    countOffset);
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedIndirect(
+                uint32_t maxDrawCount,
+                IBufferResource* argBuffer,
+                uint64_t argOffset,
+                IBufferResource* countBuffer,
+                uint64_t countOffset) override
+            {
+                prepareDraw();
+
+                auto argBufferImpl = static_cast<BufferResourceImpl*>(argBuffer);
+                auto countBufferImpl = static_cast<BufferResourceImpl*>(countBuffer);
+
+                m_d3dCmdList->ExecuteIndirect(
+                    m_renderer->drawIndexedIndirectCmdSignature,
+                    maxDrawCount,
+                    argBufferImpl->m_resource,
+                    argOffset,
+                    countBufferImpl ? countBufferImpl->m_resource.getResource() : nullptr,
+                    countOffset);
+            }
+
+            virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
+                uint32_t samplesPerPixel,
+                uint32_t pixelCount,
+                const SamplePosition* samplePositions) override
+            {
+                if (m_commandBuffer->m_cmdList1)
+                {
+                    m_commandBuffer->m_cmdList1->SetSamplePositions(
+                        samplesPerPixel, pixelCount, (D3D12_SAMPLE_POSITION*)samplePositions);
+                    return SLANG_OK;
+                }
+                return SLANG_E_NOT_AVAILABLE;
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
+                uint32_t vertexCount,
+                uint32_t instanceCount,
+                uint32_t startVertex,
+                uint32_t startInstanceLocation) override
+            {
+                prepareDraw();
+                m_d3dCmdList->DrawInstanced(
+                    vertexCount, instanceCount, startVertex, startInstanceLocation);
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
+                uint32_t indexCount,
+                uint32_t instanceCount,
+                uint32_t startIndexLocation,
+                int32_t baseVertexLocation,
+                uint32_t startInstanceLocation) override
+            {
+                prepareDraw();
+                m_d3dCmdList->DrawIndexedInstanced(indexCount, instanceCount, startIndexLocation, baseVertexLocation, startInstanceLocation);
+            }
+        };
+
+        RenderCommandEncoderImpl m_renderCommandEncoder;
+        virtual SLANG_NO_THROW void SLANG_MCALL encodeRenderCommands(
+            IRenderPassLayout* renderPass,
+            IFramebuffer* framebuffer,
+            IRenderCommandEncoder** outEncoder) override
+        {
+            m_renderCommandEncoder.init(
+                m_renderer,
+                m_transientHeap,
+                this,
+                static_cast<RenderPassLayoutImpl*>(renderPass),
+                static_cast<FramebufferImpl*>(framebuffer));
+            *outEncoder = &m_renderCommandEncoder;
+        }
+
+        class ComputeCommandEncoderImpl
+            : public IComputeCommandEncoder
+            , public ResourceCommandEncoderImpl
+        {
+        public:
+            SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoderImpl)
+        public:
+            virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override
+            {
+                PipelineCommandEncoder::endEncodingImpl();
+            }
+            void init(
+                D3D12Device* renderer,
+                TransientResourceHeapImpl* transientHeap,
+                CommandBufferImpl* cmdBuffer)
+            {
+                PipelineCommandEncoder::init(cmdBuffer);
+                m_preCmdList = nullptr;
+                m_transientHeap = transientHeap;
+                m_currentPipeline = nullptr;
+            }
+
+            virtual SLANG_NO_THROW Result SLANG_MCALL
+                bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override
+            {
+                return bindPipelineImpl(state, outRootObject);
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override
+            {
+                // Submit binding for compute
+                {
+                    ComputeSubmitter submitter(m_d3dCmdList);
+                    RefPtr<PipelineStateBase> newPipeline;
+                    if (SLANG_FAILED(_bindRenderState(&submitter, newPipeline)))
+                    {
+                        assert(!"Failed to bind render state");
+                    }
+                }
+                m_d3dCmdList->Dispatch(x, y, z);
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL
+                dispatchComputeIndirect(IBufferResource* argBuffer, uint64_t offset) override
+            {
+                // Submit binding for compute
+                {
+                    ComputeSubmitter submitter(m_d3dCmdList);
+                    RefPtr<PipelineStateBase> newPipeline;
+                    if (SLANG_FAILED(_bindRenderState(&submitter, newPipeline)))
+                    {
+                        assert(!"Failed to bind render state");
+                    }
+                }
+                auto argBufferImpl = static_cast<BufferResourceImpl*>(argBuffer);
+
+                m_d3dCmdList->ExecuteIndirect(
+                    m_renderer->dispatchIndirectCmdSignature,
+                    1,
+                    argBufferImpl->m_resource,
+                    offset,
+                    nullptr,
+                    0);
+            }
+        };
+
+        ComputeCommandEncoderImpl m_computeCommandEncoder;
+        virtual SLANG_NO_THROW void SLANG_MCALL
+            encodeComputeCommands(IComputeCommandEncoder** outEncoder) override
+        {
+            m_computeCommandEncoder.init(m_renderer, m_transientHeap, this);
+            *outEncoder = &m_computeCommandEncoder;
+        }
+
 #if SLANG_GFX_HAS_DXR_SUPPORT
         class RayTracingCommandEncoderImpl
             : public IRayTracingCommandEncoder
-            , public PipelineCommandEncoder
+            , public ResourceCommandEncoderImpl
         {
         public:
-            CommandBufferImpl* m_commandBuffer;
-            void init(D3D12Device* renderer, CommandBufferImpl* commandBuffer)
-            {
-                PipelineCommandEncoder::init(commandBuffer);
-                m_commandBuffer = commandBuffer;
-            }
+            SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoderImpl)
+        public:
             virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
                 const IAccelerationStructure::BuildDesc& desc,
                 int propertyQueryCount,
@@ -4846,11 +4865,6 @@ public:
             virtual SLANG_NO_THROW void SLANG_MCALL deserializeAccelerationStructure(
                 IAccelerationStructure* dest,
                 DeviceAddress source) override;
-            virtual SLANG_NO_THROW void SLANG_MCALL memoryBarrier(
-                int count,
-                IAccelerationStructure* const* structures,
-                AccessFlag sourceAccess,
-                AccessFlag destAccess) override;
             virtual SLANG_NO_THROW void SLANG_MCALL
                 bindPipeline(IPipelineState* state, IShaderObject** outRootObject) override;
             virtual SLANG_NO_THROW void SLANG_MCALL dispatchRays(
@@ -4860,18 +4874,12 @@ public:
                 int32_t height,
                 int32_t depth) override;
             virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() {}
-            virtual SLANG_NO_THROW void SLANG_MCALL
-                writeTimestamp(IQueryPool* pool, SlangInt index) override
-            {
-                static_cast<QueryPoolImpl*>(pool)->writeTimestamp(
-                    m_commandBuffer->m_cmdList, index);
-            }
         };
         RayTracingCommandEncoderImpl m_rayTracingCommandEncoder;
         virtual SLANG_NO_THROW void SLANG_MCALL
             encodeRayTracingCommands(IRayTracingCommandEncoder** outEncoder) override
         {
-            m_rayTracingCommandEncoder.init(m_renderer, this);
+            m_rayTracingCommandEncoder.init(this);
             *outEncoder = &m_rayTracingCommandEncoder;
         }
 #else
@@ -5234,6 +5242,9 @@ public:
     PFN_D3D12_CREATE_DEVICE m_D3D12CreateDevice = nullptr;
     PFN_D3D12_SERIALIZE_ROOT_SIGNATURE m_D3D12SerializeRootSignature = nullptr;
 
+    PFN_BeginEventOnCommandList m_BeginEventOnCommandList = nullptr;
+    PFN_EndEventOnCommandList m_EndEventOnCommandList = nullptr;
+
     bool m_nvapi = false;
 
     // Command signatures required for indirect draws. These indicate the format of the indirect
@@ -5889,6 +5900,15 @@ Result D3D12Device::initialize(const Desc& desc)
         return SLANG_FAIL;
     }
 
+    HMODULE pixModule = LoadLibraryW(L"WinPixEventRuntime.dll");
+    if (pixModule)
+    {
+        m_BeginEventOnCommandList =
+            (PFN_BeginEventOnCommandList)GetProcAddress(pixModule, "PIXBeginEventOnCommandList");
+        m_EndEventOnCommandList =
+            (PFN_EndEventOnCommandList)GetProcAddress(pixModule, "PIXEndEventOnCommandList");
+    }
+
 #if ENABLE_DEBUG_LAYER
     m_D3D12GetDebugInterface = (PFN_D3D12_GET_DEBUG_INTERFACE)loadProc(d3dModule, "D3D12GetDebugInterface");
     if (m_D3D12GetDebugInterface)
@@ -6851,37 +6871,41 @@ Result D3D12Device::createTextureView(ITextureResource* texture, IResourceView::
             viewImpl->m_allocator = m_rtvAllocator;
             D3D12_RENDER_TARGET_VIEW_DESC rtvDesc = {};
             rtvDesc.Format = D3DUtil::getMapFormat(desc.format);
-            isArray = desc.renderTarget.arraySize > 1;
+            isArray = desc.subresourceRange.layerCount > 1;
             switch (desc.renderTarget.shape)
             {
             case IResource::Type::Texture1D:
                 rtvDesc.ViewDimension = isArray ? D3D12_RTV_DIMENSION_TEXTURE1DARRAY
                                                 : D3D12_RTV_DIMENSION_TEXTURE1D;
-                rtvDesc.Texture1D.MipSlice = desc.renderTarget.mipSlice;
+                rtvDesc.Texture1D.MipSlice = desc.subresourceRange.mipLevel;
                 break;
             case IResource::Type::Texture2D:
                 if (isMultiSample)
                 {
                     rtvDesc.ViewDimension = isArray ? D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY
                                                     : D3D12_RTV_DIMENSION_TEXTURE2DMS;
-                    rtvDesc.Texture2DMSArray.ArraySize = desc.renderTarget.arraySize;
-                    rtvDesc.Texture2DMSArray.FirstArraySlice = desc.renderTarget.arrayIndex;
+                    rtvDesc.Texture2DMSArray.ArraySize = desc.subresourceRange.layerCount;
+                    rtvDesc.Texture2DMSArray.FirstArraySlice = desc.subresourceRange.baseArrayLayer;
                 }
                 else
                 {
                     rtvDesc.ViewDimension = isArray ? D3D12_RTV_DIMENSION_TEXTURE2DARRAY
                                                     : D3D12_RTV_DIMENSION_TEXTURE2D;
-                    rtvDesc.Texture2DArray.MipSlice = desc.renderTarget.mipSlice;
-                    rtvDesc.Texture2DArray.PlaneSlice = desc.renderTarget.planeIndex;
-                    rtvDesc.Texture2DArray.ArraySize = desc.renderTarget.arraySize;
-                    rtvDesc.Texture2DArray.FirstArraySlice = desc.renderTarget.arrayIndex;
+                    rtvDesc.Texture2DArray.MipSlice = desc.subresourceRange.mipLevel;
+                    rtvDesc.Texture2DArray.PlaneSlice =
+                        resourceImpl ? D3DUtil::getPlaneSlice(
+                                           D3DUtil::getMapFormat(resourceImpl->getDesc()->format),
+                                           desc.subresourceRange.aspectMask)
+                                     : 0;
+                    rtvDesc.Texture2DArray.ArraySize = desc.subresourceRange.layerCount;
+                    rtvDesc.Texture2DArray.FirstArraySlice = desc.subresourceRange.baseArrayLayer;
                 }
                 break;
             case IResource::Type::Texture3D:
                 rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE3D;
-                rtvDesc.Texture3D.MipSlice = desc.renderTarget.mipSlice;
-                rtvDesc.Texture3D.FirstWSlice = desc.renderTarget.arrayIndex;
-                rtvDesc.Texture3D.WSize = desc.renderTarget.arraySize;
+                rtvDesc.Texture3D.MipSlice = desc.subresourceRange.mipLevel;
+                rtvDesc.Texture3D.FirstWSlice = desc.subresourceRange.baseArrayLayer;
+                rtvDesc.Texture3D.WSize = desc.subresourceRange.layerCount;
                 break;
             case IResource::Type::Buffer:
                 rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_BUFFER;
@@ -6902,28 +6926,28 @@ Result D3D12Device::createTextureView(ITextureResource* texture, IResourceView::
             viewImpl->m_allocator = m_dsvAllocator;
             D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc = {};
             dsvDesc.Format = D3DUtil::getMapFormat(desc.format);
-            isArray = desc.renderTarget.arraySize > 1;
+            isArray = desc.subresourceRange.layerCount > 1;
             switch (desc.renderTarget.shape)
             {
             case IResource::Type::Texture1D:
                 dsvDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE1D;
-                dsvDesc.Texture1D.MipSlice = desc.renderTarget.mipSlice;
+                dsvDesc.Texture1D.MipSlice = desc.subresourceRange.mipLevel;
                 break;
             case IResource::Type::Texture2D:
                 if (isMultiSample)
                 {
                     dsvDesc.ViewDimension = isArray ? D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY
                                                     : D3D12_DSV_DIMENSION_TEXTURE2DMS;
-                    dsvDesc.Texture2DMSArray.ArraySize = desc.renderTarget.arraySize;
-                    dsvDesc.Texture2DMSArray.FirstArraySlice = desc.renderTarget.arrayIndex;
+                    dsvDesc.Texture2DMSArray.ArraySize = desc.subresourceRange.layerCount;
+                    dsvDesc.Texture2DMSArray.FirstArraySlice = desc.subresourceRange.baseArrayLayer;
                 }
                 else
                 {
                     dsvDesc.ViewDimension = isArray ? D3D12_DSV_DIMENSION_TEXTURE2DARRAY
                                                     : D3D12_DSV_DIMENSION_TEXTURE2D;
-                    dsvDesc.Texture2DArray.MipSlice = desc.renderTarget.mipSlice;
-                    dsvDesc.Texture2DArray.ArraySize = desc.renderTarget.arraySize;
-                    dsvDesc.Texture2DArray.FirstArraySlice = desc.renderTarget.arrayIndex;
+                    dsvDesc.Texture2DArray.MipSlice = desc.subresourceRange.mipLevel;
+                    dsvDesc.Texture2DArray.ArraySize = desc.subresourceRange.layerCount;
+                    dsvDesc.Texture2DArray.FirstArraySlice = desc.subresourceRange.baseArrayLayer;
                 }
                 break;
             default:
@@ -8143,23 +8167,6 @@ void D3D12Device::CommandBufferImpl::RayTracingCommandEncoderImpl::deserializeAc
         D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE);
 }
 
-void D3D12Device::CommandBufferImpl::RayTracingCommandEncoderImpl::memoryBarrier(
-    int count,
-    IAccelerationStructure* const* structures,
-    AccessFlag sourceAccess,
-    AccessFlag destAccess)
-{
-    ShortList<D3D12_RESOURCE_BARRIER> barriers;
-    barriers.setCount(count);
-    for (int i = 0; i < count; i++)
-    {
-        barriers[i].Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
-        barriers[i].UAV.pResource = static_cast<D3D12AccelerationStructureImpl*>(structures[i])
-                                        ->m_buffer->m_resource.getResource();
-    }
-    m_commandBuffer->m_cmdList4->ResourceBarrier((UINT)count, barriers.getArrayView().getBuffer());
-}
-
 void D3D12Device::CommandBufferImpl::RayTracingCommandEncoderImpl::bindPipeline(
     IPipelineState* state, IShaderObject** outRootObject)
 {
@@ -8202,7 +8209,7 @@ void D3D12Device::CommandBufferImpl::RayTracingCommandEncoderImpl::dispatchRays(
     auto shaderTableImpl = static_cast<ShaderTableImpl*>(shaderTable);
 
     ResourceCommandEncoderImpl resourceCopyEncoder;
-    resourceCopyEncoder.init(m_renderer, m_commandBuffer);
+    resourceCopyEncoder.init(m_commandBuffer);
     auto shaderTableBuffer = shaderTableImpl->getOrCreateBuffer(pipelineImpl, m_transientHeap, &resourceCopyEncoder);
     auto shaderTableAddr = shaderTableBuffer->getDeviceAddress();