COM-ify all slang-gfx interfaces. (#1656)

* COM-ify all slang-gfx interfaces.

1 files changed, 185 insertions, 122 deletions

diff --git a/tools/gfx/d3d11/render-d3d11.cpp b/tools/gfx/d3d11/render-d3d11.cpp
index 97d294e5d..8bf11c39d 100644
--- a/tools/gfx/d3d11/render-d3d11.cpp
+++ b/tools/gfx/d3d11/render-d3d11.cpp
@@ -3,9 +3,10 @@
 #define _CRT_SECURE_NO_WARNINGS
 
 #include "render-d3d11.h"
+#include "core/slang-basic.h"
 
 //WORKING: #include "options.h"
-#include "../render.h"
+#include "../renderer-shared.h"
 #include "../render-graphics-common.h"
 #include "../d3d/d3d-util.h"
 #include "../nvapi/nvapi-util.h"
@@ -60,86 +61,81 @@ public:
         kMaxUAVs = 64,
         kMaxRTVs = 8,
     };
-
     
     // Renderer    implementation
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL initialize(const Desc& desc, void* inWindowHandle) override;
-    virtual SLANG_NO_THROW const List<String>& SLANG_MCALL getFeatures() override
-    {
-        return m_features;
-    }
     virtual SLANG_NO_THROW void SLANG_MCALL setClearColor(const float color[4]) override;
     virtual SLANG_NO_THROW void SLANG_MCALL clearFrame() override;
     virtual SLANG_NO_THROW void SLANG_MCALL presentFrame() override;
     virtual SLANG_NO_THROW TextureResource::Desc SLANG_MCALL getSwapChainTextureDesc() override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
-        Resource::Usage initialUsage,
-        const TextureResource::Desc& desc,
-        const TextureResource::Data* initData,
-        TextureResource** outResource) override;
+        IResource::Usage initialUsage,
+        const ITextureResource::Desc& desc,
+        const ITextureResource::Data* initData,
+        ITextureResource** outResource) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
-        Resource::Usage initialUsage,
-        const BufferResource::Desc& desc,
+        IResource::Usage initialUsage,
+        const IBufferResource::Desc& desc,
         const void* initData,
-        BufferResource** outResource) override;
+        IBufferResource** outResource) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override;
+        createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView(
-        TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override;
+        ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView(
-        BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override;
+        IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout(
         const InputElementDesc* inputElements,
         UInt inputElementCount,
-        InputLayout** outLayout) override;
+        IInputLayout** outLayout) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout(
-        const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override;
+        const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override;
+        createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override;
+        createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override;
+        createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
-        const GraphicsPipelineStateDesc& desc, PipelineState** outState) override;
+        const GraphicsPipelineStateDesc& desc, IPipelineState** outState) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
-        const ComputePipelineStateDesc& desc, PipelineState** outState) override;
+        const ComputePipelineStateDesc& desc, IPipelineState** outState) override;
 
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL
         captureScreenSurface(Surface& surfaceOut) override;
 
-    virtual SLANG_NO_THROW void* SLANG_MCALL map(BufferResource* buffer, MapFlavor flavor) override;
-    virtual SLANG_NO_THROW void SLANG_MCALL unmap(BufferResource* buffer) override;
+    virtual SLANG_NO_THROW void* SLANG_MCALL map(IBufferResource* buffer, MapFlavor flavor) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL unmap(IBufferResource* buffer) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
         setPrimitiveTopology(PrimitiveTopology topology) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet(
         PipelineType pipelineType,
-        PipelineLayout* layout,
+        IPipelineLayout* layout,
         UInt index,
-        DescriptorSet* descriptorSet) override;
+        IDescriptorSet* descriptorSet) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
         UInt startSlot,
         UInt slotCount,
-        BufferResource* const* buffers,
+        IBufferResource* const* buffers,
         const UInt* strides,
         const UInt* offsets) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override;
+        setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setDepthStencilTarget(ResourceView* depthStencilView) override;
+        setDepthStencilTarget(IResourceView* depthStencilView) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
         setViewports(UInt count, Viewport const* viewports) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
         setScissorRects(UInt count, ScissorRect const* rects) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setPipelineState(PipelineType pipelineType, PipelineState* state) override;
+        setPipelineState(PipelineType pipelineType, IPipelineState* state) override;
     virtual SLANG_NO_THROW void SLANG_MCALL draw(UInt vertexCount, UInt startVertex) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
         drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override;
@@ -201,9 +197,17 @@ public:
         CountOf,
     };
 
-    class DescriptorSetLayoutImpl : public DescriptorSetLayout
+    class DescriptorSetLayoutImpl : public IDescriptorSetLayout, public RefObject
     {
     public:
+        SLANG_REF_OBJECT_IUNKNOWN_ALL
+        IDescriptorSetLayout* getInterface(const Guid& guid)
+        {
+            if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IDescriptorSetLayout)
+                return static_cast<IDescriptorSetLayout*>(this);
+            return nullptr;
+        }
+    public:
         // Each descriptor set for the D3D11 renderer stores distinct
         // arrays for each kind of shader-visible entity D3D11 understands:
         // shader resource views (SRVs), unordered access views (UAVs),
@@ -267,9 +271,19 @@ public:
         UInt m_counts[int(D3D11DescriptorSlotType::CountOf)];
     };
 
-    class PipelineLayoutImpl : public PipelineLayout
+    class PipelineLayoutImpl : public IPipelineLayout, public RefObject
     {
     public:
+        SLANG_REF_OBJECT_IUNKNOWN_ALL
+        IPipelineLayout* getInterface(const Guid& guid)
+        {
+            if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineLayout)
+            {
+                return static_cast<IPipelineLayout*>(this);
+            }
+            return nullptr;
+        }
+    public:
         struct DescriptorSetInfo
         {
             RefPtr<DescriptorSetLayoutImpl> layout;
@@ -280,18 +294,30 @@ public:
         UINT                        m_uavCount;
     };
 
-    class DescriptorSetImpl : public DescriptorSet
+    class DescriptorSetImpl : public IDescriptorSet, public RefObject
     {
     public:
-        virtual void setConstantBuffer(UInt range, UInt index, BufferResource* buffer) override;
-        virtual void setResource(UInt range, UInt index, ResourceView* view) override;
-        virtual void setSampler(UInt range, UInt index, SamplerState* sampler) override;
-        virtual void setCombinedTextureSampler(
+        SLANG_REF_OBJECT_IUNKNOWN_ALL
+        IDescriptorSet* getInterface(const Guid& guid)
+        {
+            if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IDescriptorSet)
+                return static_cast<IDescriptorSet*>(this);
+            return nullptr;
+        }
+    public:
+        virtual SLANG_NO_THROW void SLANG_MCALL
+            setConstantBuffer(UInt range, UInt index, IBufferResource* buffer) override;
+        virtual SLANG_NO_THROW void SLANG_MCALL
+            setResource(UInt range, UInt index, IResourceView* view) override;
+        virtual SLANG_NO_THROW void SLANG_MCALL
+            setSampler(UInt range, UInt index, ISamplerState* sampler) override;
+        virtual SLANG_NO_THROW void SLANG_MCALL setCombinedTextureSampler(
             UInt range,
             UInt index,
-            ResourceView*   textureView,
-            SamplerState*   sampler) override;
-        virtual void setRootConstants(
+            IResourceView*   textureView,
+            ISamplerState*   sampler) override;
+        virtual SLANG_NO_THROW void SLANG_MCALL
+            setRootConstants(
             UInt range,
             UInt offset,
             UInt size,
@@ -307,9 +333,17 @@ public:
         List<ComPtr<ID3D11SamplerState>>        m_samplers;
     };
 
-    class ShaderProgramImpl: public ShaderProgram
+    class ShaderProgramImpl : public IShaderProgram, public RefObject
     {
     public:
+        SLANG_REF_OBJECT_IUNKNOWN_ALL
+        IShaderProgram* getInterface(const Guid& guid)
+        {
+            if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IShaderProgram)
+                return static_cast<IShaderProgram*>(this);
+            return nullptr;
+        }
+    public:
         ComPtr<ID3D11VertexShader> m_vertexShader;
         ComPtr<ID3D11PixelShader> m_pixelShader;
         ComPtr<ID3D11ComputeShader> m_computeShader;
@@ -317,10 +351,10 @@ public:
 
     class BufferResourceImpl: public BufferResource
     {
-		public:
+	public:
         typedef BufferResource Parent;
 
-        BufferResourceImpl(const Desc& desc, Usage initialUsage):
+        BufferResourceImpl(const IBufferResource::Desc& desc, IResource::Usage initialUsage):
             Parent(desc),
             m_initialUsage(initialUsage)
         {
@@ -346,16 +380,32 @@ public:
 
     };
 
-    class SamplerStateImpl : public SamplerState
+    class SamplerStateImpl : public ISamplerState, public RefObject
     {
     public:
+        SLANG_REF_OBJECT_IUNKNOWN_ALL
+        ISamplerState* getInterface(const Guid& guid)
+        {
+            if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_ISamplerState)
+                return static_cast<ISamplerState*>(this);
+            return nullptr;
+        }
+    public:
         ComPtr<ID3D11SamplerState> m_sampler;
     };
 
 
-    class ResourceViewImpl : public ResourceView
+    class ResourceViewImpl : public IResourceView, public RefObject
     {
     public:
+        SLANG_REF_OBJECT_IUNKNOWN_ALL
+        IResourceView* getInterface(const Guid& guid)
+        {
+            if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IResourceView)
+                return static_cast<IResourceView*>(this);
+            return nullptr;
+        }
+    public:
         enum class Type
         {
             SRV,
@@ -390,15 +440,31 @@ public:
         ComPtr<ID3D11RenderTargetView>      m_rtv;
     };
 
-    class InputLayoutImpl: public InputLayout
+    class InputLayoutImpl: public IInputLayout, public RefObject
 	{
-		public:
+    public:
+        SLANG_REF_OBJECT_IUNKNOWN_ALL
+        IInputLayout* getInterface(const Guid& guid)
+        {
+            if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IInputLayout)
+                return static_cast<IInputLayout*>(this);
+            return nullptr;
+        }
+    public:
 		ComPtr<ID3D11InputLayout> m_layout;
 	};
 
-    class PipelineStateImpl : public PipelineState
+    class PipelineStateImpl : public IPipelineState, public RefObject
     {
     public:
+        SLANG_REF_OBJECT_IUNKNOWN_ALL
+        IPipelineState* getInterface(const Guid& guid)
+        {
+            if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineState)
+                return static_cast<IPipelineState*>(this);
+            return nullptr;
+        }
+    public:
         RefPtr<ShaderProgramImpl>   m_program;
         RefPtr<PipelineLayoutImpl>  m_pipelineLayout;
     };
@@ -436,15 +502,15 @@ public:
     ComPtr<ID3D11Texture2D> m_backBufferTexture;
 
     RefPtr<TextureResourceImpl>     m_primaryRenderTargetTexture;
-    RefPtr<RenderTargetViewImpl>    m_primaryRenderTargetView;
+    RefPtr<RenderTargetViewImpl> m_primaryRenderTargetView;
 
 //    List<ComPtr<ID3D11RenderTargetView> > m_renderTargetViews;
 //    List<ComPtr<ID3D11Texture2D> > m_renderTargetTextures;
 
     bool m_renderTargetBindingsDirty = false;
 
-    RefPtr<GraphicsPipelineStateImpl>   m_currentGraphicsState;
-    RefPtr<ComputePipelineStateImpl>    m_currentComputeState;
+    ComPtr<GraphicsPipelineStateImpl> m_currentGraphicsState;
+    ComPtr<ComputePipelineStateImpl> m_currentComputeState;
 
     ComPtr<ID3D11RenderTargetView>      m_rtvBindings[kMaxRTVs];
     ComPtr<ID3D11DepthStencilView>      m_dsvBinding;
@@ -455,12 +521,10 @@ public:
 
     float m_clearColor[4] = { 0, 0, 0, 0 };
 
-    List<String> m_features;
-
     bool m_nvapi = false;
 };
 
-SlangResult createD3D11Renderer(IRenderer** outRenderer)
+SlangResult SLANG_MCALL createD3D11Renderer(IRenderer** outRenderer)
 {
     *outRenderer = new D3D11Renderer();
     (*outRenderer)->addRef();
@@ -654,10 +718,10 @@ SlangResult D3D11Renderer::initialize(const Desc& desc, void* inWindowHandle)
 
             // If we have an adapter set on the desc, look it up. We only need to do so for hardware
             ComPtr<IDXGIAdapter> adapter;
-            if (desc.adapter.getLength() &&  (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice))
+            if (desc.adapter &&  (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice))
             {
                 List<ComPtr<IDXGIAdapter>> dxgiAdapters;
-                D3DUtil::findAdapters(deviceCheckFlags, desc.adapter.getUnownedSlice(), dxgiAdapters);
+                D3DUtil::findAdapters(deviceCheckFlags, Slang::UnownedStringSlice(desc.adapter), dxgiAdapters);
                 if (dxgiAdapters.getCount() == 0)
                 {
                     continue;
@@ -762,19 +826,19 @@ SlangResult D3D11Renderer::initialize(const Desc& desc, void* inWindowHandle)
         SLANG_RETURN_ON_FAIL(m_device->CreateRenderTargetView(texture, &rtvDesc, rtv.writeRef()));
 
         TextureResource::Desc resourceDesc;
-        resourceDesc.init2D(Resource::Type::Texture2D, Format::RGBA_Unorm_UInt8, textureDesc.Width, textureDesc.Height, 1);
+        resourceDesc.init2D(IResource::Type::Texture2D, Format::RGBA_Unorm_UInt8, textureDesc.Width, textureDesc.Height, 1);
 
-        RefPtr<TextureResource> primaryRenderTargetTexture;
-        SLANG_RETURN_ON_FAIL(createTextureResource(Resource::Usage::RenderTarget, resourceDesc, nullptr, primaryRenderTargetTexture.writeRef()));
+        ComPtr<ITextureResource> primaryRenderTargetTexture;
+        SLANG_RETURN_ON_FAIL(createTextureResource(IResource::Usage::RenderTarget, resourceDesc, nullptr, primaryRenderTargetTexture.writeRef()));
 
-        ResourceView::Desc viewDesc;
+        IResourceView::Desc viewDesc;
         viewDesc.format = resourceDesc.format;
-        viewDesc.type = ResourceView::Type::RenderTarget;
-        RefPtr<ResourceView> primaryRenderTargetView;
+        viewDesc.type = IResourceView::Type::RenderTarget;
+        ComPtr<IResourceView> primaryRenderTargetView;
         SLANG_RETURN_ON_FAIL(createTextureView(primaryRenderTargetTexture, viewDesc, primaryRenderTargetView.writeRef()));
 
-        m_primaryRenderTargetTexture = (TextureResourceImpl*) primaryRenderTargetTexture.Ptr();
-        m_primaryRenderTargetView = (RenderTargetViewImpl*) primaryRenderTargetView.Ptr();
+        m_primaryRenderTargetTexture = dynamic_cast<TextureResourceImpl*>(primaryRenderTargetTexture.get());
+        m_primaryRenderTargetView = dynamic_cast<RenderTargetViewImpl*>(primaryRenderTargetView.get());
     }
 
 //    m_immediateContext->OMSetRenderTargets(1, m_primaryRenderTargetView->m_rtv.readRef(), nullptr);
@@ -822,7 +886,7 @@ TextureResource::Desc D3D11Renderer::getSwapChainTextureDesc()
     ((ID3D11Texture2D*)m_primaryRenderTargetTexture->m_resource.get())->GetDesc(&dxDesc);
 
     TextureResource::Desc desc;
-    desc.init2D(Resource::Type::Texture2D, Format::Unknown, dxDesc.Width, dxDesc.Height, 1);
+    desc.init2D(IResource::Type::Texture2D, Format::Unknown, dxDesc.Width, dxDesc.Height, 1);
 
     return desc;
 }
@@ -832,9 +896,9 @@ SlangResult D3D11Renderer::captureScreenSurface(Surface& surfaceOut)
     return captureTextureToSurface(m_device, m_immediateContext, (ID3D11Texture2D*) m_primaryRenderTargetTexture->m_resource.get(), surfaceOut);
 }
 
-static D3D11_BIND_FLAG _calcResourceFlag(Resource::BindFlag::Enum bindFlag)
+static D3D11_BIND_FLAG _calcResourceFlag(IResource::BindFlag::Enum bindFlag)
 {
-    typedef Resource::BindFlag BindFlag;
+    typedef IResource::BindFlag BindFlag;
     switch (bindFlag)
     {
         case BindFlag::VertexBuffer:            return D3D11_BIND_VERTEX_BUFFER;
@@ -857,7 +921,7 @@ static int _calcResourceBindFlags(int bindFlags)
     {
         int lsb = bindFlags & -bindFlags;
 
-        dstFlags |= _calcResourceFlag(Resource::BindFlag::Enum(lsb));
+        dstFlags |= _calcResourceFlag(IResource::BindFlag::Enum(lsb));
         bindFlags &= ~lsb;
     }
     return dstFlags;
@@ -868,15 +932,15 @@ static int _calcResourceAccessFlags(int accessFlags)
     switch (accessFlags)
     {
         case 0:         return 0;
-        case Resource::AccessFlag::Read:            return D3D11_CPU_ACCESS_READ;
-        case Resource::AccessFlag::Write:           return D3D11_CPU_ACCESS_WRITE;
-        case Resource::AccessFlag::Read |
-             Resource::AccessFlag::Write:           return D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
+        case IResource::AccessFlag::Read:            return D3D11_CPU_ACCESS_READ;
+        case IResource::AccessFlag::Write:           return D3D11_CPU_ACCESS_WRITE;
+        case IResource::AccessFlag::Read |
+             IResource::AccessFlag::Write:           return D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
         default: assert(!"Invalid flags"); return 0;
     }
 }
 
-Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& descIn, const TextureResource::Data* initData, TextureResource** outResource)
+Result D3D11Renderer::createTextureResource(IResource::Usage initialUsage, const ITextureResource::Desc& descIn, const ITextureResource::Data* initData, ITextureResource** outResource)
 {
     TextureResource::Desc srcDesc(descIn);
     srcDesc.setDefaults(initialUsage);
@@ -908,7 +972,7 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const
             {
                 for (int j = 0; j < srcDesc.numMipLevels; j++)
                 {
-                    const int mipHeight = TextureResource::calcMipSize(srcDesc.size.height, j);
+                    const int mipHeight = ITextureResource::Size::calcMipSize(srcDesc.size.height, j);
 
                     D3D11_SUBRESOURCE_DATA& data = subRes[subResourceIndex];
 
@@ -927,10 +991,10 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const
     const int accessFlags = _calcResourceAccessFlags(srcDesc.cpuAccessFlags);
 
     RefPtr<TextureResourceImpl> texture(new TextureResourceImpl(srcDesc, initialUsage));
-
+    
     switch (srcDesc.type)
     {
-        case Resource::Type::Texture1D:
+        case IResource::Type::Texture1D:
         {
             D3D11_TEXTURE1D_DESC desc = { 0 };
             desc.BindFlags = bindFlags;
@@ -948,8 +1012,8 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const
             texture->m_resource = texture1D;
             break;
         }
-        case Resource::Type::TextureCube:
-        case Resource::Type::Texture2D:
+        case IResource::Type::TextureCube:
+        case IResource::Type::Texture2D:
         {
             D3D11_TEXTURE2D_DESC desc = { 0 };
             desc.BindFlags = bindFlags;
@@ -965,7 +1029,7 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const
             desc.SampleDesc.Count = srcDesc.sampleDesc.numSamples;
             desc.SampleDesc.Quality = srcDesc.sampleDesc.quality;
 
-            if (srcDesc.type == Resource::Type::TextureCube)
+            if (srcDesc.type == IResource::Type::TextureCube)
             {
                 desc.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE;
             }
@@ -976,7 +1040,7 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const
             texture->m_resource = texture2D;
             break;
         }
-        case Resource::Type::Texture3D:
+        case IResource::Type::Texture3D:
         {
             D3D11_TEXTURE3D_DESC desc = { 0 };
             desc.BindFlags = bindFlags;
@@ -1003,9 +1067,9 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const
     return SLANG_OK;
 }
 
-Result D3D11Renderer::createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& descIn, const void* initData, BufferResource** outResource)
+Result D3D11Renderer::createBufferResource(IResource::Usage initialUsage, const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource)
 {
-    BufferResource::Desc srcDesc(descIn);
+    IBufferResource::Desc srcDesc(descIn);
     srcDesc.setDefaults(initialUsage);
 
     auto d3dBindFlags = _calcResourceBindFlags(srcDesc.bindFlags);
@@ -1031,18 +1095,19 @@ Result D3D11Renderer::createBufferResource(Resource::Usage initialUsage, const B
     bufferDesc.ByteWidth = UINT(alignedSizeInBytes);
     bufferDesc.BindFlags = d3dBindFlags;
     // For read we'll need to do some staging
-    bufferDesc.CPUAccessFlags = _calcResourceAccessFlags(descIn.cpuAccessFlags & Resource::AccessFlag::Write);
+    bufferDesc.CPUAccessFlags =
+        _calcResourceAccessFlags(descIn.cpuAccessFlags & IResource::AccessFlag::Write);
     bufferDesc.Usage = D3D11_USAGE_DEFAULT;
 
     // If written by CPU, make it dynamic
-    if (descIn.cpuAccessFlags & Resource::AccessFlag::Write)
+    if (descIn.cpuAccessFlags & IResource::AccessFlag::Write)
     {
         bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
     }
 
     switch (initialUsage)
     {
-        case Resource::Usage::ConstantBuffer:
+    case IResource::Usage::ConstantBuffer:
         {
             // We'll just assume ConstantBuffers are dynamic for now
             bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
@@ -1077,7 +1142,7 @@ Result D3D11Renderer::createBufferResource(Resource::Usage initialUsage, const B
 
     SLANG_RETURN_ON_FAIL(m_device->CreateBuffer(&bufferDesc, initData ? &subResourceData : nullptr, buffer->m_buffer.writeRef()));
 
-    if (srcDesc.cpuAccessFlags & Resource::AccessFlag::Read)
+    if (srcDesc.cpuAccessFlags & IResource::AccessFlag::Read)
     {
         D3D11_BUFFER_DESC bufDesc = {};
         bufDesc.BindFlags = 0;
@@ -1171,7 +1236,7 @@ static D3D11_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func)
     }
 }
 
-Result D3D11Renderer::createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler)
+Result D3D11Renderer::createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler)
 {
     D3D11_FILTER_REDUCTION_TYPE dxReduction = translateFilterReduction(desc.reductionOp);
     D3D11_FILTER dxFilter;
@@ -1212,7 +1277,7 @@ Result D3D11Renderer::createSamplerState(SamplerState::Desc const& desc, Sampler
     return SLANG_OK;
 }
 
-Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView)
+Result D3D11Renderer::createTextureView(ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView)
 {
     auto resourceImpl = (TextureResourceImpl*) texture;
 
@@ -1221,7 +1286,7 @@ Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView::
     default:
         return SLANG_FAIL;
 
-    case ResourceView::Type::RenderTarget:
+    case IResourceView::Type::RenderTarget:
         {
             ComPtr<ID3D11RenderTargetView> rtv;
             SLANG_RETURN_ON_FAIL(m_device->CreateRenderTargetView(resourceImpl->m_resource, nullptr, rtv.writeRef()));
@@ -1234,7 +1299,7 @@ Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView::
         }
         break;
 
-    case ResourceView::Type::DepthStencil:
+    case IResourceView::Type::DepthStencil:
         {
             ComPtr<ID3D11DepthStencilView> dsv;
             SLANG_RETURN_ON_FAIL(m_device->CreateDepthStencilView(resourceImpl->m_resource, nullptr, dsv.writeRef()));
@@ -1247,7 +1312,7 @@ Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView::
         }
         break;
 
-    case ResourceView::Type::UnorderedAccess:
+    case IResourceView::Type::UnorderedAccess:
         {
             ComPtr<ID3D11UnorderedAccessView> uav;
             SLANG_RETURN_ON_FAIL(m_device->CreateUnorderedAccessView(resourceImpl->m_resource, nullptr, uav.writeRef()));
@@ -1260,7 +1325,7 @@ Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView::
         }
         break;
 
-    case ResourceView::Type::ShaderResource:
+    case IResourceView::Type::ShaderResource:
         {
             ComPtr<ID3D11ShaderResourceView> srv;
             SLANG_RETURN_ON_FAIL(m_device->CreateShaderResourceView(resourceImpl->m_resource, nullptr, srv.writeRef()));
@@ -1275,17 +1340,17 @@ Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView::
     }
 }
 
-Result D3D11Renderer::createBufferView(BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView)
+Result D3D11Renderer::createBufferView(IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView)
 {
     auto resourceImpl = (BufferResourceImpl*) buffer;
-    auto resourceDesc = resourceImpl->getDesc();
+    auto resourceDesc = *resourceImpl->getDesc();
 
     switch (desc.type)
     {
     default:
         return SLANG_FAIL;
 
-    case ResourceView::Type::UnorderedAccess:
+    case IResourceView::Type::UnorderedAccess:
         {
             D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
             uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
@@ -1304,7 +1369,7 @@ Result D3D11Renderer::createBufferView(BufferResource* buffer, ResourceView::Des
             }
             else
             {
-                uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / RendererUtil::getFormatSize(desc.format));
+                uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / gfxGetFormatSize(desc.format));
             }
 
             ComPtr<ID3D11UnorderedAccessView> uav;
@@ -1318,7 +1383,7 @@ Result D3D11Renderer::createBufferView(BufferResource* buffer, ResourceView::Des
         }
         break;
 
-    case ResourceView::Type::ShaderResource:
+    case IResourceView::Type::ShaderResource:
         {
             D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
             srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
@@ -1349,7 +1414,7 @@ Result D3D11Renderer::createBufferView(BufferResource* buffer, ResourceView::Des
             }
             else
             {
-                srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / RendererUtil::getFormatSize(desc.format));
+                srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / gfxGetFormatSize(desc.format));
             }
 
             ComPtr<ID3D11ShaderResourceView> srv;
@@ -1365,7 +1430,7 @@ Result D3D11Renderer::createBufferView(BufferResource* buffer, ResourceView::Des
     }
 }
 
-Result D3D11Renderer::createInputLayout(const InputElementDesc* inputElementsIn, UInt inputElementCount, InputLayout** outLayout)
+Result D3D11Renderer::createInputLayout(const InputElementDesc* inputElementsIn, UInt inputElementCount, IInputLayout** outLayout)
 {
     D3D11_INPUT_ELEMENT_DESC inputElements[16] = {};
 
@@ -1432,7 +1497,7 @@ Result D3D11Renderer::createInputLayout(const InputElementDesc* inputElementsIn,
     return SLANG_OK;
 }
 
-void* D3D11Renderer::map(BufferResource* bufferIn, MapFlavor flavor)
+void* D3D11Renderer::map(IBufferResource* bufferIn, MapFlavor flavor)
 {
     BufferResourceImpl* bufferResource = static_cast<BufferResourceImpl*>(bufferIn);
 
@@ -1475,7 +1540,7 @@ void* D3D11Renderer::map(BufferResource* bufferIn, MapFlavor flavor)
     return mappedSub.pData;
 }
 
-void D3D11Renderer::unmap(BufferResource* bufferIn)
+void D3D11Renderer::unmap(IBufferResource* bufferIn)
 {
     BufferResourceImpl* bufferResource = static_cast<BufferResourceImpl*>(bufferIn);
     ID3D11Buffer* buffer = (bufferResource->m_mapFlavor == MapFlavor::HostRead) ? bufferResource->m_staging : bufferResource->m_buffer;
@@ -1495,7 +1560,7 @@ void D3D11Renderer::setPrimitiveTopology(PrimitiveTopology topology)
     m_immediateContext->IASetPrimitiveTopology(D3DUtil::getPrimitiveTopology(topology));
 }
 
-void D3D11Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource*const* buffersIn, const UInt* stridesIn, const UInt* offsetsIn)
+void D3D11Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, IBufferResource*const* buffersIn, const UInt* stridesIn, const UInt* offsetsIn)
 {
     static const int kMaxVertexBuffers = 16;
 	assert(slotCount <= kMaxVertexBuffers);
@@ -1516,13 +1581,13 @@ void D3D11Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResou
     m_immediateContext->IASetVertexBuffers((UINT)startSlot, (UINT)slotCount, dxBuffers, &vertexStrides[0], &vertexOffsets[0]);
 }
 
-void D3D11Renderer::setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset)
+void D3D11Renderer::setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset)
 {
     DXGI_FORMAT dxFormat = D3DUtil::getMapFormat(indexFormat);
     m_immediateContext->IASetIndexBuffer(((BufferResourceImpl*)buffer)->m_buffer, dxFormat, UINT(offset));
 }
 
-void D3D11Renderer::setDepthStencilTarget(ResourceView* depthStencilView)
+void D3D11Renderer::setDepthStencilTarget(IResourceView* depthStencilView)
 {
     m_dsvBinding = ((DepthStencilViewImpl*) depthStencilView)->m_dsv;
     m_targetBindingsDirty[int(PipelineType::Graphics)] = true;
@@ -1571,7 +1636,7 @@ void D3D11Renderer::setScissorRects(UInt count, ScissorRect const* rects)
 }
 
 
-void D3D11Renderer::setPipelineState(PipelineType pipelineType, PipelineState* state)
+void D3D11Renderer::setPipelineState(PipelineType pipelineType, IPipelineState* state)
 {
     switch(pipelineType)
     {
@@ -1650,7 +1715,7 @@ void D3D11Renderer::drawIndexed(UInt indexCount, UInt startIndex, UInt baseVerte
     m_immediateContext->DrawIndexed((UINT)indexCount, (UINT)startIndex, (INT)baseVertex);
 }
 
-Result D3D11Renderer::createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram)
+Result D3D11Renderer::createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram)
 {
     if (desc.pipelineType == PipelineType::Compute)
     {
@@ -1822,7 +1887,7 @@ D3D11_COLOR_WRITE_ENABLE translateRenderTargetWriteMask(RenderTargetWriteMaskT m
     return D3D11_COLOR_WRITE_ENABLE(result);
 }
 
-Result D3D11Renderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, PipelineState** outState)
+Result D3D11Renderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, IPipelineState** outState)
 {
     GraphicsPipelineStateDesc desc = inDesc;
     preparePipelineDesc(desc);
@@ -1954,7 +2019,7 @@ Result D3D11Renderer::createGraphicsPipelineState(const GraphicsPipelineStateDes
     return SLANG_OK;
 }
 
-Result D3D11Renderer::createComputePipelineState(const ComputePipelineStateDesc& inDesc, PipelineState** outState)
+Result D3D11Renderer::createComputePipelineState(const ComputePipelineStateDesc& inDesc, IPipelineState** outState)
 {
     ComputePipelineStateDesc desc = inDesc;
     preparePipelineDesc(desc);
@@ -1976,7 +2041,7 @@ void D3D11Renderer::dispatchCompute(int x, int y, int z)
     m_immediateContext->Dispatch(x, y, z);
 }
 
-Result D3D11Renderer::createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout)
+Result D3D11Renderer::createDescriptorSetLayout(const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout)
 {
     RefPtr<DescriptorSetLayoutImpl> descriptorSetLayoutImpl = new DescriptorSetLayoutImpl();
 
@@ -2072,7 +2137,7 @@ Result D3D11Renderer::createDescriptorSetLayout(const DescriptorSetLayout::Desc&
     return SLANG_OK;
 }
 
-Result D3D11Renderer::createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout)
+Result D3D11Renderer::createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout)
 {
     RefPtr<PipelineLayoutImpl> pipelineLayoutImpl = new PipelineLayoutImpl();
 
@@ -2101,7 +2166,7 @@ Result D3D11Renderer::createPipelineLayout(const PipelineLayout::Desc& desc, Pip
     return SLANG_OK;
 }
 
-Result D3D11Renderer::createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet)
+Result D3D11Renderer::createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet)
 {
     auto layoutImpl = (DescriptorSetLayoutImpl*)layout;
 
@@ -2168,7 +2233,7 @@ void D3D11Renderer::_flushGraphicsState()
     {
         m_targetBindingsDirty[pipelineType] = false;
 
-        auto pipelineState = m_currentGraphicsState.Ptr();
+        auto pipelineState = m_currentGraphicsState.get();
 
         auto rtvCount = pipelineState->m_rtvCount;
         auto uavCount = pipelineState->m_pipelineLayout->m_uavCount;
@@ -2191,7 +2256,7 @@ void D3D11Renderer::_flushComputeState()
     {
         m_targetBindingsDirty[pipelineType] = false;
 
-        auto pipelineState = m_currentComputeState.Ptr();
+        auto pipelineState = m_currentComputeState.get();
 
         auto uavCount = pipelineState->m_pipelineLayout->m_uavCount;
 
@@ -2203,7 +2268,7 @@ void D3D11Renderer::_flushComputeState()
     }
 }
 
-void D3D11Renderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, BufferResource* buffer)
+void D3D11Renderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, IBufferResource* buffer)
 {
     auto bufferImpl = (BufferResourceImpl*) buffer;
     auto& rangeInfo = m_layout->m_ranges[range];
@@ -2213,7 +2278,7 @@ void D3D11Renderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index,
     m_cbs[rangeInfo.arrayIndex + index] = bufferImpl->m_buffer;
 }
 
-void D3D11Renderer::DescriptorSetImpl::setResource(UInt range, UInt index, ResourceView* view)
+void D3D11Renderer::DescriptorSetImpl::setResource(UInt range, UInt index, IResourceView* view)
 {
     auto viewImpl = (ResourceViewImpl*)view;
     auto& rangeInfo = m_layout->m_ranges[range];
@@ -2257,7 +2322,7 @@ void D3D11Renderer::DescriptorSetImpl::setResource(UInt range, UInt index, Resou
     }
 }
 
-void D3D11Renderer::DescriptorSetImpl::setSampler(UInt range, UInt index, SamplerState* sampler)
+void D3D11Renderer::DescriptorSetImpl::setSampler(UInt range, UInt index, ISamplerState* sampler)
 {
     auto samplerImpl = (SamplerStateImpl*) sampler;
     auto& rangeInfo = m_layout->m_ranges[range];
@@ -2270,8 +2335,8 @@ void D3D11Renderer::DescriptorSetImpl::setSampler(UInt range, UInt index, Sample
 void D3D11Renderer::DescriptorSetImpl::setCombinedTextureSampler(
     UInt            range,
     UInt            index,
-    ResourceView*   textureView,
-    SamplerState*   sampler)
+    IResourceView*   textureView,
+    ISamplerState*   sampler)
 {
     auto viewImpl = (ResourceViewImpl*) textureView;
     auto samplerImpl = (SamplerStateImpl*)sampler;
@@ -2327,7 +2392,7 @@ void D3D11Renderer::DescriptorSetImpl::setRootConstants(
     dxContext->Unmap(dxBuffer, 0);
 }
 
-void D3D11Renderer::setDescriptorSet(PipelineType pipelineType, PipelineLayout* layout, UInt index, DescriptorSet* descriptorSet)
+void D3D11Renderer::setDescriptorSet(PipelineType pipelineType, IPipelineLayout* layout, UInt index, IDescriptorSet* descriptorSet)
 {
     auto pipelineLayoutImpl = (PipelineLayoutImpl*)layout;
     auto descriptorSetImpl = (DescriptorSetImpl*) descriptorSet;
@@ -2414,8 +2479,6 @@ void D3D11Renderer::setDescriptorSet(PipelineType pipelineType, PipelineLayout*
             m_targetBindingsDirty[int(pipelineType)] = true;
         }
     }
-
-
 }
 
 } // renderer_test