gfx: Add more fixed function states and instancing draw calls. (#2023)

* gfx: Add more fixed function states and instancing draw calls.

* Fix clang error.

* Fix clang.

* Fixes.

* Add `AccelerationStructureCurrentSize` enum.

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

10 files changed, 326 insertions, 52 deletions

diff --git a/slang-gfx.h b/slang-gfx.h
index 64ea4e6a4..971c2fffc 100644
--- a/slang-gfx.h
+++ b/slang-gfx.h
@@ -349,12 +349,20 @@ struct FormatInfo
     uint32_t blockHeight;
 };
 
+enum class InputSlotClass
+{
+    PerVertex, PerInstance
+};
+
 struct InputElementDesc
 {
     char const* semanticName;
-    UInt        semanticIndex;
-    Format      format;
-    UInt        offset;
+    UInt semanticIndex;
+    Format format;
+    UInt offset;
+    InputSlotClass slotClass;
+    UInt bufferSlotIndex;
+    UInt instanceDataStepRate;
 };
 
 enum class PrimitiveType
@@ -1080,16 +1088,18 @@ struct DepthStencilDesc
 
 struct RasterizerDesc
 {
-    FillMode        fillMode                = FillMode::Solid;
-    CullMode        cullMode                = CullMode::Back;
-    FrontFaceMode   frontFace               = FrontFaceMode::CounterClockwise;
-    int32_t         depthBias               = 0;
-    float           depthBiasClamp          = 0.0f;
-    float           slopeScaledDepthBias    = 0.0f;
-    bool            depthClipEnable         = true;
-    bool            scissorEnable           = false;
-    bool            multisampleEnable       = false;
-    bool            antialiasedLineEnable   = false;
+    FillMode fillMode = FillMode::Solid;
+    CullMode cullMode = CullMode::None;
+    FrontFaceMode frontFace = FrontFaceMode::CounterClockwise;
+    int32_t depthBias = 0;
+    float depthBiasClamp = 0.0f;
+    float slopeScaledDepthBias = 0.0f;
+    bool depthClipEnable = true;
+    bool scissorEnable = false;
+    bool multisampleEnable = false;
+    bool antialiasedLineEnable = false;
+    bool enableConservativeRasterization = false;
+    uint32_t forcedSampleCount = 0;
 };
 
 enum class LogicOp
@@ -1153,7 +1163,7 @@ struct TargetBlendDesc
 {
     AspectBlendDesc color;
     AspectBlendDesc alpha;
-
+    bool enableBlend = false;
     LogicOp                 logicOp     = LogicOp::NoOp;
     RenderTargetWriteMaskT  writeMask   = RenderTargetWriteMask::EnableAll;
 };
@@ -1163,7 +1173,7 @@ struct BlendDesc
     TargetBlendDesc const*  targets     = nullptr;
     UInt                    targetCount = 0;
 
-    bool alphaToCoverateEnable  = false;
+    bool alphaToCoverageEnable  = false;
 };
 
 class IFramebufferLayout : public ISlangUnknown
@@ -1243,10 +1253,10 @@ class IPipelineState : public ISlangUnknown
 
 struct ScissorRect
 {
-    Int minX;
-    Int minY;
-    Int maxX;
-    Int maxY;
+    int32_t minX;
+    int32_t minY;
+    int32_t maxX;
+    int32_t maxY;
 };
 
 struct Viewport
@@ -1348,6 +1358,7 @@ enum class QueryType
     Timestamp,
     AccelerationStructureCompactedSize,
     AccelerationStructureSerializedSize,
+    AccelerationStructureCurrentSize,
 };
 
 class IQueryPool : public ISlangUnknown
@@ -1477,6 +1488,17 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) = 0;
     virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
         uint32_t samplesPerPixel, uint32_t pixelCount, const SamplePosition* samplePositions) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
+        UInt vertexCount,
+        UInt instanceCount,
+        UInt startVertex,
+        UInt startInstanceLocation) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
+        uint32_t indexCount,
+        uint32_t instanceCount,
+        uint32_t startIndexLocation,
+        int32_t baseVertexLocation,
+        uint32_t startInstanceLocation) = 0;
 };
 
 class IComputeCommandEncoder : public ICommandEncoder
diff --git a/tools/gfx/d3d/d3d-util.cpp b/tools/gfx/d3d/d3d-util.cpp
index afd4d068b..505755005 100644
--- a/tools/gfx/d3d/d3d-util.cpp
+++ b/tools/gfx/d3d/d3d-util.cpp
@@ -665,6 +665,114 @@ uint32_t D3DUtil::getPlaneSlice(DXGI_FORMAT format, TextureAspect aspect)
     }
 }
 
+D3D12_INPUT_CLASSIFICATION D3DUtil::getInputSlotClass(InputSlotClass slotClass)
+{
+    switch (slotClass)
+    {
+    case InputSlotClass::PerVertex:
+        return D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
+    case InputSlotClass::PerInstance:
+        return D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
+    default:
+        SLANG_ASSERT_FAILURE("Unknown input slot class.");
+        return D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
+    }
+}
+
+D3D12_FILL_MODE D3DUtil::getFillMode(FillMode mode)
+{
+    switch (mode)
+    {
+    case FillMode::Solid:
+        return D3D12_FILL_MODE_SOLID;
+    case FillMode::Wireframe:
+        return D3D12_FILL_MODE_WIREFRAME;
+    default:
+        SLANG_ASSERT_FAILURE("Unknown fill mode.");
+        return D3D12_FILL_MODE_SOLID;
+    }
+}
+
+D3D12_CULL_MODE D3DUtil::getCullMode(CullMode mode)
+{
+    switch (mode)
+    {
+    case CullMode::None:
+        return D3D12_CULL_MODE_NONE;
+    case CullMode::Front:
+        return D3D12_CULL_MODE_FRONT;
+    case CullMode::Back:
+        return D3D12_CULL_MODE_BACK;
+    default:
+        SLANG_ASSERT_FAILURE("Unknown cull mode.");
+        return D3D12_CULL_MODE_NONE;
+    }
+}
+
+D3D12_BLEND_OP D3DUtil::getBlendOp(BlendOp op)
+{
+    switch (op)
+    {
+    case BlendOp::Add:
+        return D3D12_BLEND_OP_ADD;
+    case BlendOp::Subtract:
+        return D3D12_BLEND_OP_SUBTRACT;
+    case BlendOp::ReverseSubtract:
+        return D3D12_BLEND_OP_REV_SUBTRACT;
+    case BlendOp::Min:
+        return D3D12_BLEND_OP_MIN;
+    case BlendOp::Max:
+        return D3D12_BLEND_OP_MAX;
+    default:
+        SLANG_ASSERT_FAILURE("Unknown blend op.");
+        return D3D12_BLEND_OP_ADD;
+    }
+}
+
+D3D12_BLEND D3DUtil::getBlendFactor(BlendFactor factor)
+{
+    switch (factor)
+    {
+    case BlendFactor::Zero:
+        return D3D12_BLEND_ZERO;
+    case BlendFactor::One:
+        return D3D12_BLEND_ONE;
+    case BlendFactor::SrcColor:
+        return D3D12_BLEND_SRC_COLOR;
+    case BlendFactor::InvSrcColor:
+        return D3D12_BLEND_INV_SRC_COLOR;
+    case BlendFactor::SrcAlpha:
+        return D3D12_BLEND_SRC_ALPHA;
+    case BlendFactor::InvSrcAlpha:
+        return D3D12_BLEND_INV_SRC_ALPHA;
+    case BlendFactor::DestAlpha:
+        return D3D12_BLEND_DEST_ALPHA;
+    case BlendFactor::InvDestAlpha:
+        return D3D12_BLEND_INV_DEST_ALPHA;
+    case BlendFactor::DestColor:
+        return D3D12_BLEND_DEST_COLOR;
+    case BlendFactor::InvDestColor:
+        return D3D12_BLEND_INV_DEST_COLOR;
+    case BlendFactor::SrcAlphaSaturate:
+        return D3D12_BLEND_SRC_ALPHA_SAT;
+    case BlendFactor::BlendColor:
+        return D3D12_BLEND_BLEND_FACTOR;
+    case BlendFactor::InvBlendColor:
+        return D3D12_BLEND_INV_BLEND_FACTOR;
+    case BlendFactor::SecondarySrcColor:
+        return D3D12_BLEND_SRC1_COLOR;
+    case BlendFactor::InvSecondarySrcColor:
+        return D3D12_BLEND_INV_SRC1_COLOR;
+    case BlendFactor::SecondarySrcAlpha:
+        return D3D12_BLEND_SRC1_ALPHA;
+    case BlendFactor::InvSecondarySrcAlpha:
+        return D3D12_BLEND_INV_SRC1_ALPHA;
+    default:
+        SLANG_ASSERT_FAILURE("Unknown blend factor.");
+        return D3D12_BLEND_ZERO;
+    }
+}
+
 /* static */SlangResult D3DUtil::findAdapters(DeviceCheckFlags flags, const UnownedStringSlice& adapterName, IDXGIFactory* dxgiFactory, List<ComPtr<IDXGIAdapter>>& outDxgiAdapters)
 {
     Slang::String lowerAdapterName = Slang::String(adapterName).toLower();
diff --git a/tools/gfx/d3d/d3d-util.h b/tools/gfx/d3d/d3d-util.h
index 7ce922b21..96ccfd776 100644
--- a/tools/gfx/d3d/d3d-util.h
+++ b/tools/gfx/d3d/d3d-util.h
@@ -98,6 +98,15 @@ class D3DUtil
 
     static uint32_t getPlaneSlice(DXGI_FORMAT format, TextureAspect aspect);
 
+    static D3D12_INPUT_CLASSIFICATION getInputSlotClass(InputSlotClass slotClass);
+
+    static D3D12_FILL_MODE getFillMode(FillMode mode);
+
+    static D3D12_CULL_MODE getCullMode(CullMode mode);
+
+    static D3D12_BLEND_OP getBlendOp(BlendOp op);
+
+    static D3D12_BLEND getBlendFactor(BlendFactor factor);
 };
 
 #if SLANG_GFX_HAS_DXR_SUPPORT
diff --git a/tools/gfx/d3d11/render-d3d11.cpp b/tools/gfx/d3d11/render-d3d11.cpp
index 304c0c91e..78cd5b61a 100644
--- a/tools/gfx/d3d11/render-d3d11.cpp
+++ b/tools/gfx/d3d11/render-d3d11.cpp
@@ -3845,7 +3845,7 @@ Result D3D11Device::createGraphicsPipelineState(const GraphicsPipelineStateDesc&
         }
 
         dstDesc.IndependentBlendEnable = srcDesc.targetCount > 1;
-        dstDesc.AlphaToCoverageEnable = srcDesc.alphaToCoverateEnable;
+        dstDesc.AlphaToCoverageEnable = srcDesc.alphaToCoverageEnable;
 
         SLANG_RETURN_ON_FAIL(m_device->CreateBlendState(
             &dstDesc,
diff --git a/tools/gfx/d3d12/render-d3d12.cpp b/tools/gfx/d3d12/render-d3d12.cpp
index 5fbe0d4a6..4d5845b85 100644
--- a/tools/gfx/d3d12/render-d3d12.cpp
+++ b/tools/gfx/d3d12/render-d3d12.cpp
@@ -3423,6 +3423,34 @@ public:
                 SLANG_UNUSED(samplePositions);
                 SLANG_UNIMPLEMENTED_X("setSamplePositions");
             }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
+                UInt vertexCount,
+                UInt instanceCount,
+                UInt startVertex,
+                UInt startInstanceLocation) override
+            {
+                SLANG_UNUSED(vertexCount);
+                SLANG_UNUSED(instanceCount);
+                SLANG_UNUSED(startVertex);
+                SLANG_UNUSED(startInstanceLocation);
+                SLANG_UNIMPLEMENTED_X("drawInstanced");
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
+                uint32_t indexCount,
+                uint32_t instanceCount,
+                uint32_t startIndexLocation,
+                int32_t baseVertexLocation,
+                uint32_t startInstanceLocation) override
+            {
+                SLANG_UNUSED(indexCount);
+                SLANG_UNUSED(instanceCount);
+                SLANG_UNUSED(startIndexLocation);
+                SLANG_UNUSED(baseVertexLocation);
+                SLANG_UNUSED(startInstanceLocation);
+                SLANG_UNIMPLEMENTED_X("drawIndexedInstanced");
+            }
         };
 
         RenderCommandEncoderImpl m_renderCommandEncoder;
@@ -5669,10 +5697,10 @@ Result D3D12Device::createInputLayout(const InputElementDesc* inputElements, UIn
         dstEle.SemanticName = semanticName;
         dstEle.SemanticIndex = (UINT)srcEle.semanticIndex;
         dstEle.Format = D3DUtil::getMapFormat(srcEle.format);
-        dstEle.InputSlot = 0;
+        dstEle.InputSlot = (UINT)srcEle.bufferSlotIndex;
         dstEle.AlignedByteOffset = (UINT)srcEle.offset;
-        dstEle.InputSlotClass = D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
-        dstEle.InstanceDataStepRate = 0;
+        dstEle.InputSlotClass = D3DUtil::getInputSlotClass(srcEle.slotClass);
+        dstEle.InstanceDataStepRate = (UINT)srcEle.instanceDataStepRate;
     }
 
     returnComPtr(outLayout, layout);
@@ -5871,10 +5899,15 @@ Result D3D12Device::createGraphicsPipelineState(const GraphicsPipelineStateDesc&
         if (framebufferLayout->m_hasDepthStencil)
         {
             psoDesc.DSVFormat = D3DUtil::getMapFormat(framebufferLayout->m_depthStencil.format);
+            psoDesc.SampleDesc.Count = framebufferLayout->m_depthStencil.sampleCount;
         }
         else
         {
             psoDesc.DSVFormat = DXGI_FORMAT_D32_FLOAT;
+            if (framebufferLayout->m_renderTargets.getCount())
+            {
+                psoDesc.SampleDesc.Count = framebufferLayout->m_renderTargets[0].sampleCount;
+            }
         }
         psoDesc.NumRenderTargets = numRenderTargets;
         for (Int i = 0; i < numRenderTargets; i++)
@@ -5883,43 +5916,57 @@ Result D3D12Device::createGraphicsPipelineState(const GraphicsPipelineStateDesc&
                 D3DUtil::getMapFormat(framebufferLayout->m_renderTargets[i].format);
         }
 
-        psoDesc.SampleDesc.Count = 1;
         psoDesc.SampleDesc.Quality = 0;
-
         psoDesc.SampleMask = UINT_MAX;
     }
 
     {
         auto& rs = psoDesc.RasterizerState;
-        rs.FillMode = D3D12_FILL_MODE_SOLID;
-        rs.CullMode = D3D12_CULL_MODE_NONE;
-        rs.FrontCounterClockwise = FALSE;
-        rs.DepthBias = D3D12_DEFAULT_DEPTH_BIAS;
-        rs.DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP;
-        rs.SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
-        rs.DepthClipEnable = TRUE;
-        rs.MultisampleEnable = FALSE;
-        rs.AntialiasedLineEnable = FALSE;
-        rs.ForcedSampleCount = 0;
-        rs.ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
+        rs.FillMode = D3DUtil::getFillMode(desc.rasterizer.fillMode);
+        rs.CullMode = D3DUtil::getCullMode(desc.rasterizer.cullMode);
+        rs.FrontCounterClockwise =
+            desc.rasterizer.frontFace == gfx::FrontFaceMode::CounterClockwise ? TRUE : FALSE;
+        rs.DepthBias = desc.rasterizer.depthBias;
+        rs.DepthBiasClamp = desc.rasterizer.depthBiasClamp;
+        rs.SlopeScaledDepthBias = desc.rasterizer.slopeScaledDepthBias;
+        rs.DepthClipEnable = desc.rasterizer.depthClipEnable ? TRUE : FALSE;
+        rs.MultisampleEnable = desc.rasterizer.multisampleEnable ? TRUE : FALSE;
+        rs.AntialiasedLineEnable = desc.rasterizer.antialiasedLineEnable ? TRUE : FALSE;
+        rs.ForcedSampleCount = desc.rasterizer.forcedSampleCount;
+        rs.ConservativeRaster = desc.rasterizer.enableConservativeRasterization
+                                    ? D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON
+                                    : D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF;
     }
 
     {
         D3D12_BLEND_DESC& blend = psoDesc.BlendState;
-
-        blend.AlphaToCoverageEnable = FALSE;
         blend.IndependentBlendEnable = FALSE;
-        const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc =
-        {
-            FALSE,FALSE,
-            D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
-            D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
-            D3D12_LOGIC_OP_NOOP,
-            D3D12_COLOR_WRITE_ENABLE_ALL,
-        };
-        for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
+        blend.AlphaToCoverageEnable = desc.blend.alphaToCoverageEnable ? TRUE : FALSE;
+        for (uint32_t i = 0; i < desc.blend.targetCount; i++)
+        {
+            auto& d3dDesc = blend.RenderTarget[i];
+            d3dDesc.BlendEnable = desc.blend.targets[i].enableBlend ? TRUE : FALSE;
+            d3dDesc.BlendOp = D3DUtil::getBlendOp(desc.blend.targets[i].color.op);
+            d3dDesc.BlendOpAlpha = D3DUtil::getBlendOp(desc.blend.targets[i].alpha.op);
+            d3dDesc.DestBlend = D3DUtil::getBlendFactor(desc.blend.targets[i].color.dstFactor);
+            d3dDesc.DestBlendAlpha = D3DUtil::getBlendFactor(desc.blend.targets[i].alpha.dstFactor);
+            d3dDesc.LogicOp = D3D12_LOGIC_OP_NOOP;
+            d3dDesc.LogicOpEnable = FALSE;
+            d3dDesc.RenderTargetWriteMask = desc.blend.targets[i].writeMask;
+            d3dDesc.SrcBlend = D3DUtil::getBlendFactor(desc.blend.targets[i].color.srcFactor);
+            d3dDesc.SrcBlendAlpha = D3DUtil::getBlendFactor(desc.blend.targets[i].alpha.srcFactor);
+        }
+        for (uint32_t i = 1; i < desc.blend.targetCount; i++)
+        {
+            if (memcmp(&desc.blend.targets[i], &desc.blend.targets[0], sizeof(desc.blend.targets[0])) != 0)
+            {
+                blend.IndependentBlendEnable = TRUE;
+                break;
+            }
+        }
+        for (uint32_t i = (uint32_t)desc.blend.targetCount; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
         {
-            blend.RenderTarget[i] = defaultRenderTargetBlendDesc;
+            blend.RenderTarget[i] = blend.RenderTarget[0];
         }
     }
 
diff --git a/tools/gfx/debug-layer.cpp b/tools/gfx/debug-layer.cpp
index 0fff101ad..6266a6175 100644
--- a/tools/gfx/debug-layer.cpp
+++ b/tools/gfx/debug-layer.cpp
@@ -1149,6 +1149,26 @@ Result DebugRenderCommandEncoder::setSamplePositions(
     return baseObject->setSamplePositions(samplesPerPixel, pixelCount, samplePositions);
 }
 
+void DebugRenderCommandEncoder::drawInstanced(
+    UInt vertexCount, UInt instanceCount, UInt startVertex, UInt startInstanceLocation)
+{
+    SLANG_GFX_API_FUNC;
+    return baseObject->drawInstanced(
+        vertexCount, instanceCount, startVertex, startInstanceLocation);
+}
+
+void DebugRenderCommandEncoder::drawIndexedInstanced(
+    uint32_t indexCount,
+    uint32_t instanceCount,
+    uint32_t startIndexLocation,
+    int32_t baseVertexLocation,
+    uint32_t startInstanceLocation)
+{
+    SLANG_GFX_API_FUNC;
+    return baseObject->drawIndexedInstanced(
+        indexCount, instanceCount, startIndexLocation, baseVertexLocation, startInstanceLocation);
+}
+
 void DebugResourceCommandEncoder::endEncoding()
 {
     SLANG_GFX_API_FUNC;
diff --git a/tools/gfx/debug-layer.h b/tools/gfx/debug-layer.h
index e7894b390..28ad8c4b5 100644
--- a/tools/gfx/debug-layer.h
+++ b/tools/gfx/debug-layer.h
@@ -367,6 +367,18 @@ public:
         uint32_t samplesPerPixel,
         uint32_t pixelCount,
         const SamplePosition* samplePositions) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
+        UInt vertexCount,
+        UInt instanceCount,
+        UInt startVertex,
+        UInt startInstanceLocation) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
+        uint32_t indexCount,
+        uint32_t instanceCount,
+        uint32_t startIndexLocation,
+        int32_t baseVertexLocation,
+        uint32_t startInstanceLocation) override;
 
 public:
     DebugCommandBuffer* commandBuffer;
diff --git a/tools/gfx/immediate-renderer-base.cpp b/tools/gfx/immediate-renderer-base.cpp
index b4763a881..360370aa0 100644
--- a/tools/gfx/immediate-renderer-base.cpp
+++ b/tools/gfx/immediate-renderer-base.cpp
@@ -194,6 +194,34 @@ public:
             SLANG_UNUSED(samplePositions);
             return SLANG_E_NOT_AVAILABLE;
         }
+
+        virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
+            UInt vertexCount,
+            UInt instanceCount,
+            UInt startVertex,
+            UInt startInstanceLocation) override
+        {
+            SLANG_UNUSED(vertexCount);
+            SLANG_UNUSED(instanceCount);
+            SLANG_UNUSED(startVertex);
+            SLANG_UNUSED(startInstanceLocation);
+            SLANG_UNIMPLEMENTED_X("drawInstanced");
+        }
+
+        virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
+            uint32_t indexCount,
+            uint32_t instanceCount,
+            uint32_t startIndexLocation,
+            int32_t baseVertexLocation,
+            uint32_t startInstanceLocation) override
+        {
+            SLANG_UNUSED(indexCount);
+            SLANG_UNUSED(instanceCount);
+            SLANG_UNUSED(startIndexLocation);
+            SLANG_UNUSED(baseVertexLocation);
+            SLANG_UNUSED(startInstanceLocation);
+            SLANG_UNIMPLEMENTED_X("drawIndexedInstanced");
+        }
     };
 
     RenderCommandEncoderImpl m_renderCommandEncoder;
diff --git a/tools/gfx/vulkan/render-vk.cpp b/tools/gfx/vulkan/render-vk.cpp
index 7dde2b712..5c3e75110 100644
--- a/tools/gfx/vulkan/render-vk.cpp
+++ b/tools/gfx/vulkan/render-vk.cpp
@@ -3991,6 +3991,34 @@ public:
                 SLANG_UNUSED(samplePositions);
                 SLANG_UNIMPLEMENTED_X("setSamplePositions");
             }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
+                UInt vertexCount,
+                UInt instanceCount,
+                UInt startVertex,
+                UInt startInstanceLocation) override
+            {
+                SLANG_UNUSED(vertexCount);
+                SLANG_UNUSED(instanceCount);
+                SLANG_UNUSED(startVertex);
+                SLANG_UNUSED(startInstanceLocation);
+                SLANG_UNIMPLEMENTED_X("drawInstanced");
+            }
+
+            virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
+                uint32_t indexCount,
+                uint32_t instanceCount,
+                uint32_t startIndexLocation,
+                int32_t baseVertexLocation,
+                uint32_t startInstanceLocation) override
+            {
+                SLANG_UNUSED(indexCount);
+                SLANG_UNUSED(instanceCount);
+                SLANG_UNUSED(startIndexLocation);
+                SLANG_UNUSED(baseVertexLocation);
+                SLANG_UNUSED(startInstanceLocation);
+                SLANG_UNIMPLEMENTED_X("drawIndexedInstanced");
+            }
         };
 
         RefPtr<RenderCommandEncoder> m_renderCommandEncoder;
diff --git a/tools/platform/gui.cpp b/tools/platform/gui.cpp
index 1573a848b..53d0a43ba 100644
--- a/tools/platform/gui.cpp
+++ b/tools/platform/gui.cpp
@@ -310,10 +310,10 @@ void GUI::endFrame(ITransientResourceHeap* transientHeap, IFramebuffer* framebuf
             {
                 ScissorRect rect =
                 {
-                    (Int)(command->ClipRect.x - pos.x),
-                    (Int)(command->ClipRect.y - pos.y),
-                    (Int)(command->ClipRect.z - pos.x),
-                    (Int)(command->ClipRect.w - pos.y)
+                    (int32_t)(command->ClipRect.x - pos.x),
+                    (int32_t)(command->ClipRect.y - pos.y),
+                    (int32_t)(command->ClipRect.z - pos.x),
+                    (int32_t)(command->ClipRect.w - pos.y)
                 };
                 renderEncoder->setScissorRects(1, &rect);