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

* COM-ify all slang-gfx interfaces.

8 files changed, 154 insertions, 115 deletions

diff --git a/tools/render-test/cpu-compute-util.h b/tools/render-test/cpu-compute-util.h
index 56d510818..b1de6ce85 100644
--- a/tools/render-test/cpu-compute-util.h
+++ b/tools/render-test/cpu-compute-util.h
@@ -20,7 +20,7 @@ struct CPUComputeUtil
         GroupRange,
     };
 
-    struct Resource : public RefObject
+    struct Resource : public Slang::RefObject
     {
         void* getInterface() const { return m_interface; }
         void* m_interface;
@@ -33,10 +33,10 @@ struct CPUComputeUtil
         CPULikeBindRoot m_bindRoot;
 
             /// Buffers are held in same order as entries in layout (useful for dumping out bindings)
-        List<BindSet::Value*> m_buffers;
+        Slang::List<BindSet::Value*> m_buffers;
 
             /// Bindless resource objects
-        Slang::OrderedDictionary<Slang::String, RefPtr<Resource>> m_bindlessResources;
+        Slang::OrderedDictionary<Slang::String, Slang::RefPtr<Resource>> m_bindlessResources;
     };
 
     struct ExecuteInfo
diff --git a/tools/render-test/cuda/cuda-compute-util.h b/tools/render-test/cuda/cuda-compute-util.h
index 8bc7bd8d6..ac0c6bba3 100644
--- a/tools/render-test/cuda/cuda-compute-util.h
+++ b/tools/render-test/cuda/cuda-compute-util.h
@@ -10,7 +10,7 @@ namespace renderer_test {
 
 // Base class for CUDA resources. This includes textures but also
 // memory allocations
-class CUDAResource : public RefObject
+class CUDAResource : public Slang::RefObject
 {
 public:
     virtual uint64_t getBindlessHandle() = 0;
@@ -44,8 +44,8 @@ struct CUDAComputeUtil
         BindSet m_bindSet;
         CPULikeBindRoot m_bindRoot;
             /// Buffers are held in same order as entries in layout (useful for dumping out bindings)
-        List<BindSet::Value*> m_buffers;
-        Slang::OrderedDictionary<Slang::String, RefPtr<CUDAResource>> m_bindlessResources;
+        Slang::List<BindSet::Value*> m_buffers;
+        Slang::OrderedDictionary<Slang::String, Slang::RefPtr<CUDAResource>> m_bindlessResources;
         void releaseBindlessResources();
     };
 
@@ -53,7 +53,10 @@ struct CUDAComputeUtil
 
     static bool hasFeature(const Slang::UnownedStringSlice& feature);
 
-    static SlangResult createTextureResource(const ShaderInputLayoutEntry& srcEntry, slang::TypeLayoutReflection* typeLayout, RefPtr<CUDAResource>& outResource);
+    static SlangResult createTextureResource(
+        const ShaderInputLayoutEntry& srcEntry,
+        slang::TypeLayoutReflection* typeLayout,
+        Slang::RefPtr<CUDAResource>& outResource);
 
     static SlangResult execute(const ShaderCompilerUtil::OutputAndLayout& outputAndLayout, const uint32_t dispatchSize[3], Context& outContext);
 
diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp
index 533932eab..4c05422ee 100644
--- a/tools/render-test/render-test-main.cpp
+++ b/tools/render-test/render-test-main.cpp
@@ -74,7 +74,7 @@ struct ShaderOutputPlan
     struct Item
     {
         Index               inputLayoutEntryIndex;
-        RefPtr<Resource>    resource;
+        ComPtr<IResource>   resource;
     };
 
     List<Item> items;
@@ -118,10 +118,10 @@ protected:
 
     ComPtr<IRenderer> m_renderer;
 
-    RefPtr<InputLayout> m_inputLayout;
-    RefPtr<BufferResource> m_vertexBuffer;
-    RefPtr<ShaderProgram> m_shaderProgram;
-    RefPtr<PipelineState> m_pipelineState;
+    ComPtr<IInputLayout> m_inputLayout;
+    ComPtr<IBufferResource> m_vertexBuffer;
+    ComPtr<IShaderProgram> m_shaderProgram;
+    ComPtr<IPipelineState> m_pipelineState;
 
     ShaderCompilerUtil::OutputAndLayout m_compilationOutput;
 
@@ -147,7 +147,7 @@ public:
 
 protected:
 	uintptr_t m_constantBufferSize;
-	RefPtr<BufferResource>	m_constantBuffer;
+	ComPtr<IBufferResource>	m_constantBuffer;
 	RefPtr<BindingStateImpl>    m_bindingState;
     int m_numAddedConstantBuffers;                      ///< Constant buffers can be added to the binding directly. Will be added at the end.
 };
@@ -165,20 +165,20 @@ public:
     virtual Result writeBindingOutput(BindRoot* bindRoot, const char* fileName) override;
 
 protected:
-    RefPtr<ShaderObject> m_programVars;
+    ComPtr<IShaderObject> m_programVars;
     ShaderOutputPlan m_outputPlan;
 };
 
 SlangResult _assignVarsFromLayout(
     IRenderer*                   renderer,
-    ShaderObject*               shaderObject,
+    IShaderObject*               shaderObject,
     ShaderInputLayout const&    layout,
     ShaderOutputPlan&           ioOutputPlan,
     slang::ProgramLayout*       slangReflection)
 {
     ShaderCursor rootCursor = ShaderCursor(shaderObject);
 
-    const int textureBindFlags = Resource::BindFlag::NonPixelShaderResource | Resource::BindFlag::PixelShaderResource;
+    const int textureBindFlags = IResource::BindFlag::NonPixelShaderResource | IResource::BindFlag::PixelShaderResource;
 
     Index entryCount = layout.entries.getCount();
     for(Index entryIndex = 0; entryIndex < entryCount; ++entryIndex)
@@ -194,7 +194,7 @@ SlangResult _assignVarsFromLayout(
 
         if(!entryCursor.isValid())
         {
-            for(Index i = 0; i < shaderObject->getEntryPointCount(); i++)
+            for(gfx::UInt i = 0; i < shaderObject->getEntryPointCount(); i++)
             {
                 entryCursor = ShaderCursor(shaderObject->getEntryPoint(i)).getPath(entry.name);
                 if(entryCursor.isValid())
@@ -209,7 +209,7 @@ SlangResult _assignVarsFromLayout(
             return SLANG_E_INVALID_ARG;
         }
 
-        RefPtr<Resource> resource;
+        ComPtr<IResource> resource;
         switch(entry.type)
         {
         case ShaderInputType::Uniform:
@@ -267,12 +267,12 @@ SlangResult _assignVarsFromLayout(
                 default:
                     {
 
-                        RefPtr<BufferResource> bufferResource;
+                        ComPtr<IBufferResource> bufferResource;
                         SLANG_RETURN_ON_FAIL(ShaderRendererUtil::createBufferResource(entry.bufferDesc, entry.isOutput, bufferSize, entry.bufferData.getBuffer(), renderer, bufferResource));
                         resource = bufferResource;
 
-                        ResourceView::Desc viewDesc;
-                        viewDesc.type = ResourceView::Type::UnorderedAccess;
+                        IResourceView::Desc viewDesc;
+                        viewDesc.type = IResourceView::Type::UnorderedAccess;
                         viewDesc.format = srcBuffer.format;
                         auto bufferView = renderer->createBufferView(
                             bufferResource,
@@ -315,14 +315,14 @@ SlangResult _assignVarsFromLayout(
 
         case ShaderInputType::CombinedTextureSampler:
             {
-                RefPtr<TextureResource> texture;
+                ComPtr<ITextureResource> texture;
                 SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTextureResource(entry.textureDesc, textureBindFlags, renderer, texture));
                 resource = texture;
 
                 auto sampler = _createSamplerState(renderer, entry.samplerDesc);
 
-                ResourceView::Desc viewDesc;
-                viewDesc.type = ResourceView::Type::ShaderResource;
+                IResourceView::Desc viewDesc;
+                viewDesc.type = IResourceView::Type::ShaderResource;
                 auto textureView = renderer->createTextureView(
                     texture,
                     viewDesc);
@@ -345,14 +345,14 @@ SlangResult _assignVarsFromLayout(
 
         case ShaderInputType::Texture:
             {
-                RefPtr<TextureResource> texture;
+                ComPtr<ITextureResource> texture;
                 SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTextureResource(entry.textureDesc, textureBindFlags, renderer, texture));
                 resource = texture;
 
                 // TODO: support UAV textures...
 
-                ResourceView::Desc viewDesc;
-                viewDesc.type = ResourceView::Type::ShaderResource;
+                IResourceView::Desc viewDesc;
+                viewDesc.type = IResourceView::Type::ShaderResource;
                 auto textureView = renderer->createTextureView(
                     texture,
                     viewDesc);
@@ -395,8 +395,9 @@ SlangResult _assignVarsFromLayout(
                 auto slangType = slangReflection->findTypeByName(typeName.getBuffer());
                 auto slangTypeLayout = slangReflection->getTypeLayout(slangType);
 
-                RefPtr<ShaderObjectLayout> shaderObjectLayout = renderer->createShaderObjectLayout(slangTypeLayout);
-                RefPtr<ShaderObject> shaderObject = renderer->createShaderObject(shaderObjectLayout);
+                ComPtr<IShaderObjectLayout> shaderObjectLayout = renderer->createShaderObjectLayout(slangTypeLayout);
+                ComPtr<IShaderObject> shaderObject =
+                    renderer->createShaderObject(shaderObjectLayout);
 
                 entryCursor.setObject(shaderObject);
             }
@@ -445,12 +446,12 @@ SlangResult LegacyRenderTestApp::initialize(
     // TODO(tfoley): use each API's reflection interface to query the constant-buffer size needed
     m_constantBufferSize = 16 * sizeof(float);
 
-    BufferResource::Desc constantBufferDesc;
+    IBufferResource::Desc constantBufferDesc;
     constantBufferDesc.init(m_constantBufferSize);
-    constantBufferDesc.cpuAccessFlags = Resource::AccessFlag::Write;
+    constantBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write;
 
     m_constantBuffer =
-        renderer->createBufferResource(Resource::Usage::ConstantBuffer, constantBufferDesc);
+        renderer->createBufferResource(IResource::Usage::ConstantBuffer, constantBufferDesc);
     if (!m_constantBuffer)
         return SLANG_FAIL;
 
@@ -458,7 +459,7 @@ SlangResult LegacyRenderTestApp::initialize(
     //
     // TODO: Should probably be more sophisticated than this - with 'dynamic' constant buffer/s
     // binding always being specified in the test file
-    RefPtr<BufferResource> addedConstantBuffer;
+    ComPtr<IBufferResource> addedConstantBuffer;
     switch (m_options.shaderType)
     {
     default:
@@ -490,11 +491,11 @@ SlangResult LegacyRenderTestApp::initialize(
     if (!m_inputLayout)
         return SLANG_FAIL;
 
-    BufferResource::Desc vertexBufferDesc;
+    IBufferResource::Desc vertexBufferDesc;
     vertexBufferDesc.init(kVertexCount * sizeof(Vertex));
 
     m_vertexBuffer = renderer->createBufferResource(
-        Resource::Usage::VertexBuffer, vertexBufferDesc, kVertexData);
+        IResource::Usage::VertexBuffer, vertexBufferDesc, kVertexData);
     if (!m_vertexBuffer)
         return SLANG_FAIL;
 
@@ -555,7 +556,7 @@ SlangResult ShaderObjectRenderTestApp::initialize(
     // Slang's reflection API to tell us what the parameters of the program are.
     //
     auto slangReflection = (slang::ProgramLayout*) spGetReflection(m_compilationOutput.output.getRequestForReflection());
-    RefPtr<ShaderObjectLayout> programLayout = renderer->createRootShaderObjectLayout(slangReflection);
+    ComPtr<IShaderObjectLayout> programLayout = renderer->createRootShaderObjectLayout(slangReflection);
 
     // Once we have determined the layout of all the parameters we need to bind,
     // we will create a shader object to use for storing and binding those parameters.
@@ -583,7 +584,7 @@ SlangResult ShaderObjectRenderTestApp::initialize(
         case Options::ShaderProgramType::Compute:
             {
                 ComputePipelineStateDesc desc;
-                desc.rootShaderObjectLayout = programLayout.Ptr();
+                desc.rootShaderObjectLayout = programLayout.get();
                 desc.program = m_shaderProgram;
 
                 m_pipelineState = renderer->createComputePipelineState(desc);
@@ -608,16 +609,16 @@ SlangResult ShaderObjectRenderTestApp::initialize(
                     { "A", 2, Format::RG_Float32,  offsetof(Vertex, uv) },
                 };
 
-                RefPtr<InputLayout> inputLayout;
+                ComPtr<IInputLayout> inputLayout;
                 SLANG_RETURN_ON_FAIL(renderer->createInputLayout(inputElements, SLANG_COUNT_OF(inputElements), inputLayout.writeRef()));
 
-                BufferResource::Desc vertexBufferDesc;
+                IBufferResource::Desc vertexBufferDesc;
                 vertexBufferDesc.init(kVertexCount * sizeof(Vertex));
 
-                SLANG_RETURN_ON_FAIL(renderer->createBufferResource(Resource::Usage::VertexBuffer, vertexBufferDesc, kVertexData, m_vertexBuffer.writeRef()));
+                SLANG_RETURN_ON_FAIL(renderer->createBufferResource(IResource::Usage::VertexBuffer, vertexBufferDesc, kVertexData, m_vertexBuffer.writeRef()));
 
                 GraphicsPipelineStateDesc desc;
-                desc.rootShaderObjectLayout = programLayout.Ptr();
+                desc.rootShaderObjectLayout = programLayout.get();
                 desc.program = m_shaderProgram;
                 desc.inputLayout = inputLayout;
 
@@ -650,8 +651,8 @@ void LegacyRenderTestApp::setProjectionMatrix()
     if (mappedData)
     {
         const ProjectionStyle projectionStyle =
-            RendererUtil::getProjectionStyle(m_renderer->getRendererType());
-        RendererUtil::getIdentityProjection(projectionStyle, (float*)mappedData);
+            gfxGetProjectionStyle(m_renderer->getRendererType());
+        gfxGetIdentityProjection(projectionStyle, (float*)mappedData);
 
         m_renderer->unmap(m_constantBuffer);
     }
@@ -660,10 +661,10 @@ void LegacyRenderTestApp::setProjectionMatrix()
 void ShaderObjectRenderTestApp::setProjectionMatrix()
 {
     const ProjectionStyle projectionStyle =
-        RendererUtil::getProjectionStyle(m_renderer->getRendererType());
+        gfxGetProjectionStyle(m_renderer->getRendererType());
 
     float projectionMatrix[16];
-    RendererUtil::getIdentityProjection(projectionStyle, projectionMatrix);
+    gfxGetIdentityProjection(projectionStyle, projectionMatrix);
     ShaderCursor(m_programVars)
         .getField("Uniforms")
         .getDereferenced()
@@ -722,10 +723,10 @@ Result LegacyRenderTestApp::writeBindingOutput(BindRoot* bindRoot, const char* f
 
         assert(layoutBinding.isOutput);
         
-        if (binding.resource && binding.resource->isBuffer())
+        if (binding.resource && binding.resource->getType() == IResource::Type::Buffer)
         {
-            BufferResource* bufferResource = static_cast<BufferResource*>(binding.resource.Ptr());
-            const size_t bufferSize = bufferResource->getDesc().sizeInBytes;
+            IBufferResource* bufferResource = static_cast<IBufferResource*>(binding.resource.get());
+            const size_t bufferSize = bufferResource->getDesc()->sizeInBytes;
 
             unsigned int* ptr = (unsigned int*)m_renderer->map(bufferResource, MapFlavor::HostRead);
             if (!ptr)
@@ -768,10 +769,10 @@ Result ShaderObjectRenderTestApp::writeBindingOutput(BindRoot* bindRoot, const c
         assert(inputEntry.isOutput);
 
         auto resource = outputItem.resource;
-        if (resource && resource->isBuffer())
+        if (resource && resource->getType() == IResource::Type::Buffer)
         {
-            BufferResource* bufferResource = static_cast<BufferResource*>(resource.Ptr());
-            const size_t bufferSize = bufferResource->getDesc().sizeInBytes;
+            IBufferResource* bufferResource = static_cast<IBufferResource*>(resource.get());
+            const size_t bufferSize = bufferResource->getDesc()->sizeInBytes;
 
             unsigned int* ptr = (unsigned int*)m_renderer->map(bufferResource, MapFlavor::HostRead);
             if (!ptr)
@@ -1054,7 +1055,7 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi
     input.profile = options.profileName ? options.profileName : input.profile;
 
     StringBuilder rendererName;
-    rendererName << "[" << RendererUtil::toText(options.rendererType) << "] ";
+    rendererName << "[" << gfxGetRendererName(options.rendererType) << "] ";
     if (options.adapter.getLength())
     {
         rendererName << "'" << options.adapter << "'";
@@ -1217,7 +1218,7 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi
 
     Slang::ComPtr<IRenderer> renderer;
     {
-        RendererUtil::CreateFunc createFunc = RendererUtil::getCreateFunc(options.rendererType);
+        SGRendererCreateFunc createFunc = gfxGetCreateFunc(options.rendererType);
         if (createFunc)
         {
             createFunc(renderer.writeRef());
@@ -1235,8 +1236,12 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi
         IRenderer::Desc desc;
         desc.width = gWindowWidth;
         desc.height = gWindowHeight;
-        desc.adapter = options.adapter;
-        desc.requiredFeatures = options.renderFeatures;
+        desc.adapter = options.adapter.getBuffer();
+        List<const char*> requiredFeatureList;
+        for (auto & name : options.renderFeatures)
+            requiredFeatureList.add(name.getBuffer());
+        desc.requiredFeatures = requiredFeatureList.getBuffer();
+        desc.requiredFeatureCount = requiredFeatureList.getCount();
         desc.nvapiExtnSlot = int(nvapiExtnSlot);
 
         window = renderer_test::Window::create();
@@ -1254,10 +1259,10 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi
             return res;
         }
 
-        for (const auto& feature : options.renderFeatures)
+        for (const auto& feature : requiredFeatureList)
         {
             // If doesn't have required feature... we have to give up
-            if (!renderer->hasFeature(feature.getUnownedSlice()))
+            if (!renderer->hasFeature(feature))
             {
                 return SLANG_E_NOT_AVAILABLE;
             }
diff --git a/tools/render-test/shader-input-layout.h b/tools/render-test/shader-input-layout.h
index 437da820b..51463eca6 100644
--- a/tools/render-test/shader-input-layout.h
+++ b/tools/render-test/shader-input-layout.h
@@ -140,7 +140,7 @@ public:
     static SlangResult writeBinding(BindRoot* bindRoot, const ShaderInputLayoutEntry& entry, const void* data, size_t sizeInBytes, Slang::WriterHelper writer);
 
         /// Write all bindings, using data from buffers
-    static SlangResult writeBindings(BindRoot* bindRoot, const ShaderInputLayout& layout, const List<BindSet::Value*>& buffers, Slang::WriterHelper writer);
+    static SlangResult writeBindings(BindRoot* bindRoot, const ShaderInputLayout& layout, const Slang::List<BindSet::Value*>& buffers, Slang::WriterHelper writer);
 
         /// Write bindings from values in memory from buffers
     static SlangResult writeBindings(BindRoot* bindRoot, const ShaderInputLayout& layout, const Slang::List<BindSet::Value*>& buffers, const Slang::String& fileName);
diff --git a/tools/render-test/shader-renderer-util.cpp b/tools/render-test/shader-renderer-util.cpp
index d24909bca..c90d197f4 100644
--- a/tools/render-test/shader-renderer-util.cpp
+++ b/tools/render-test/shader-renderer-util.cpp
@@ -20,7 +20,7 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType)
     const InputTextureDesc& inputDesc,
     int bindFlags,
     IRenderer* renderer,
-    RefPtr<TextureResource>& textureOut)
+    ComPtr<ITextureResource>& textureOut)
 {
     TextureData texData;
     generateTextureData(texData, inputDesc);
@@ -32,10 +32,10 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType)
     const TextureData& texData,
     int bindFlags,
     IRenderer* renderer,
-    RefPtr<TextureResource>& textureOut)
+    ComPtr<ITextureResource>& textureOut)
 {
-    TextureResource::Desc textureResourceDesc;
-    textureResourceDesc.init(Resource::Type::Unknown);
+    ITextureResource::Desc textureResourceDesc;
+    textureResourceDesc.init(IResource::Type::Unknown);
 
     // Default to RGBA_Unorm_UInt8
     const Format format = (inputDesc.format == Format::Unknown) ? Format::RGBA_Unorm_UInt8 : inputDesc.format;
@@ -50,19 +50,19 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType)
     {
         case 1:
         {
-            textureResourceDesc.type = Resource::Type::Texture1D;
+            textureResourceDesc.type = IResource::Type::Texture1D;
             textureResourceDesc.size.init(inputDesc.size);
             break;
         }
         case 2:
         {
-            textureResourceDesc.type = inputDesc.isCube ? Resource::Type::TextureCube : Resource::Type::Texture2D;
+            textureResourceDesc.type = inputDesc.isCube ? IResource::Type::TextureCube : IResource::Type::Texture2D;
             textureResourceDesc.size.init(inputDesc.size, inputDesc.size);
             break;
         }
         case 3:
         {
-            textureResourceDesc.type = Resource::Type::Texture3D;
+            textureResourceDesc.type = IResource::Type::Texture3D;
             textureResourceDesc.size.init(inputDesc.size, inputDesc.size, inputDesc.size);
             break;
         }
@@ -71,8 +71,8 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType)
     const int effectiveArraySize = textureResourceDesc.calcEffectiveArraySize();
     const int numSubResources = textureResourceDesc.calcNumSubResources();
 
-    Resource::Usage initialUsage = Resource::Usage::GenericRead;
-    TextureResource::Data initData;
+    IResource::Usage initialUsage = IResource::Usage::GenericRead;
+    ITextureResource::Data initData;
 
     List<ptrdiff_t> mipRowStrides;
     mipRowStrides.setCount(textureResourceDesc.numMipLevels);
@@ -82,7 +82,7 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType)
     // Set up the src row strides
     for (int i = 0; i < textureResourceDesc.numMipLevels; i++)
     {
-        const int mipWidth = TextureResource::calcMipSize(textureResourceDesc.size.width, i);
+        const int mipWidth = ITextureResource::Size::calcMipSize(textureResourceDesc.size.width, i);
         mipRowStrides[i] = mipWidth * sizeof(uint32_t);
     }
 
@@ -103,7 +103,7 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType)
     initData.numSubResources = numSubResources;
     initData.subResources = subResources.getBuffer();
 
-    textureOut = renderer->createTextureResource(Resource::Usage::GenericRead, textureResourceDesc, &initData);
+    textureOut = renderer->createTextureResource(IResource::Usage::GenericRead, textureResourceDesc, &initData);
 
     return textureOut ? SLANG_OK : SLANG_FAIL;
 }
@@ -114,36 +114,36 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType)
     size_t bufferSize,
     const void* initData,
     IRenderer* renderer,
-    Slang::RefPtr<BufferResource>& bufferOut)
+    Slang::ComPtr<IBufferResource>& bufferOut)
 {
-    Resource::Usage initialUsage = Resource::Usage::GenericRead;
+    IResource::Usage initialUsage = IResource::Usage::GenericRead;
 
-    BufferResource::Desc srcDesc;
+    IBufferResource::Desc srcDesc;
     srcDesc.init(bufferSize);
     srcDesc.format = inputDesc.format;
 
     int bindFlags = 0;
     if (inputDesc.type == InputBufferType::ConstantBuffer)
     {
-        bindFlags |= Resource::BindFlag::ConstantBuffer;
-        srcDesc.cpuAccessFlags |= Resource::AccessFlag::Write;
-        initialUsage = Resource::Usage::ConstantBuffer;
+        bindFlags |= IResource::BindFlag::ConstantBuffer;
+        srcDesc.cpuAccessFlags |= IResource::AccessFlag::Write;
+        initialUsage = IResource::Usage::ConstantBuffer;
     }
     else
     {
-        bindFlags |= Resource::BindFlag::UnorderedAccess | Resource::BindFlag::PixelShaderResource | Resource::BindFlag::NonPixelShaderResource;
+        bindFlags |= IResource::BindFlag::UnorderedAccess | IResource::BindFlag::PixelShaderResource | IResource::BindFlag::NonPixelShaderResource;
         srcDesc.elementSize = inputDesc.stride;
-        initialUsage = Resource::Usage::UnorderedAccess;
+        initialUsage = IResource::Usage::UnorderedAccess;
     }
 
     if (isOutput)
     {
-        srcDesc.cpuAccessFlags |= Resource::AccessFlag::Read;
+        srcDesc.cpuAccessFlags |= IResource::AccessFlag::Read;
     }
 
     srcDesc.bindFlags = bindFlags;
 
-    RefPtr<BufferResource> bufferResource = renderer->createBufferResource(initialUsage, srcDesc, initData);
+    ComPtr<IBufferResource> bufferResource = renderer->createBufferResource(initialUsage, srcDesc, initData);
     if (!bufferResource)
     {
         return SLANG_FAIL;
@@ -153,9 +153,9 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType)
     return SLANG_OK;
 }
 
-static SamplerState::Desc _calcSamplerDesc(const InputSamplerDesc& srcDesc)
+static ISamplerState::Desc _calcSamplerDesc(const InputSamplerDesc& srcDesc)
 {
-    SamplerState::Desc dstDesc;
+    ISamplerState::Desc dstDesc;
     if (srcDesc.isCompareSampler)
     {
         dstDesc.reductionOp = TextureReductionOp::Comparison;
@@ -164,7 +164,7 @@ static SamplerState::Desc _calcSamplerDesc(const InputSamplerDesc& srcDesc)
     return dstDesc;
 }
 
-RefPtr<SamplerState> _createSamplerState(IRenderer* renderer,
+ComPtr<ISamplerState> _createSamplerState(IRenderer* renderer,
     const InputSamplerDesc& srcDesc)
 {
     return renderer->createSamplerState(_calcSamplerDesc(srcDesc));
@@ -173,19 +173,19 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer,
 /* static */ Result ShaderRendererUtil::createBindingState(
     const ShaderInputLayout& layout,
     IRenderer* renderer,
-    BufferResource* addedConstantBuffer,
+    IBufferResource* addedConstantBuffer,
     BindingStateImpl** outBindingState)
 {
     auto srcEntries = layout.entries.getBuffer();
     auto numEntries = layout.entries.getCount();
 
-    const int textureBindFlags = Resource::BindFlag::NonPixelShaderResource | Resource::BindFlag::PixelShaderResource;
+    const int textureBindFlags = IResource::BindFlag::NonPixelShaderResource | IResource::BindFlag::PixelShaderResource;
 
-    List<DescriptorSetLayout::SlotRangeDesc> slotRangeDescs;
+    List<IDescriptorSetLayout::SlotRangeDesc> slotRangeDescs;
 
     if(addedConstantBuffer)
     {
-        DescriptorSetLayout::SlotRangeDesc slotRangeDesc;
+        IDescriptorSetLayout::SlotRangeDesc slotRangeDesc;
         slotRangeDesc.type = DescriptorSlotType::UniformBuffer;
 
         slotRangeDescs.add(slotRangeDesc);
@@ -196,7 +196,7 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer,
         const ShaderInputLayoutEntry& srcEntry = srcEntries[i];
         SLANG_ASSERT(srcEntry.onlyCPULikeBinding == false);
 
-        DescriptorSetLayout::SlotRangeDesc slotRangeDesc;
+        IDescriptorSetLayout::SlotRangeDesc slotRangeDesc;
 
         switch (srcEntry.type)
         {
@@ -259,17 +259,17 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer,
         slotRangeDescs.add(slotRangeDesc);
     }
 
-    DescriptorSetLayout::Desc descriptorSetLayoutDesc;
+    IDescriptorSetLayout::Desc descriptorSetLayoutDesc;
     descriptorSetLayoutDesc.slotRangeCount = slotRangeDescs.getCount();
     descriptorSetLayoutDesc.slotRanges = slotRangeDescs.getBuffer();
 
     auto descriptorSetLayout = renderer->createDescriptorSetLayout(descriptorSetLayoutDesc);
     if(!descriptorSetLayout) return SLANG_FAIL;
 
-    List<PipelineLayout::DescriptorSetDesc> pipelineDescriptorSets;
-    pipelineDescriptorSets.add(PipelineLayout::DescriptorSetDesc(descriptorSetLayout));
+    List<IPipelineLayout::DescriptorSetDesc> pipelineDescriptorSets;
+    pipelineDescriptorSets.add(IPipelineLayout::DescriptorSetDesc(descriptorSetLayout));
 
-    PipelineLayout::Desc pipelineLayoutDesc;
+    IPipelineLayout::Desc pipelineLayoutDesc;
     pipelineLayoutDesc.renderTargetCount = layout.numRenderTargets;
     pipelineLayoutDesc.descriptorSetCount = pipelineDescriptorSets.getCount();
     pipelineLayoutDesc.descriptorSets = pipelineDescriptorSets.getBuffer();
@@ -313,7 +313,7 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer,
                         break;
                     }
 
-                    RefPtr<BufferResource> bufferResource;
+                    ComPtr<IBufferResource> bufferResource;
                     SLANG_RETURN_ON_FAIL(createBufferResource(srcEntry.bufferDesc, srcEntry.isOutput, bufferSize, srcEntry.bufferData.getBuffer(), renderer, bufferResource));
 
                     switch(srcBuffer.type)
@@ -324,8 +324,8 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer,
 
                     case InputBufferType::StorageBuffer:
                         {
-                            ResourceView::Desc viewDesc;
-                            viewDesc.type = ResourceView::Type::UnorderedAccess;
+                            IResourceView::Desc viewDesc;
+                            viewDesc.type = IResourceView::Type::UnorderedAccess;
                             viewDesc.format = srcBuffer.format;
                             auto bufferView = renderer->createBufferView(
                                 bufferResource,
@@ -347,13 +347,13 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer,
 
             case ShaderInputType::CombinedTextureSampler:
                 {
-                    RefPtr<TextureResource> texture;
+                    ComPtr<ITextureResource> texture;
                     SLANG_RETURN_ON_FAIL(generateTextureResource(srcEntry.textureDesc, textureBindFlags, renderer, texture));
 
                     auto sampler = _createSamplerState(renderer, srcEntry.samplerDesc);
 
-                    ResourceView::Desc viewDesc;
-                    viewDesc.type = ResourceView::Type::ShaderResource;
+                    IResourceView::Desc viewDesc;
+                    viewDesc.type = IResourceView::Type::ShaderResource;
                     auto textureView = renderer->createTextureView(
                         texture,
                         viewDesc);
@@ -372,13 +372,13 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer,
 
             case ShaderInputType::Texture:
                 {
-                    RefPtr<TextureResource> texture;
+                    ComPtr<ITextureResource> texture;
                     SLANG_RETURN_ON_FAIL(generateTextureResource(srcEntry.textureDesc, textureBindFlags, renderer, texture));
 
                     // TODO: support UAV textures...
 
-                    ResourceView::Desc viewDesc;
-                    viewDesc.type = ResourceView::Type::ShaderResource;
+                    IResourceView::Desc viewDesc;
+                    viewDesc.type = IResourceView::Type::ShaderResource;
                     auto textureView = renderer->createTextureView(
                         texture,
                         viewDesc);
diff --git a/tools/render-test/shader-renderer-util.h b/tools/render-test/shader-renderer-util.h
index 5bb2d342e..045f501c3 100644
--- a/tools/render-test/shader-renderer-util.h
+++ b/tools/render-test/shader-renderer-util.h
@@ -37,17 +37,17 @@ struct BindingStateImpl : public Slang::RefObject
 
     struct OutputBinding
     {
-        RefPtr<Resource>    resource;
+        ComPtr<IResource>    resource;
         Slang::UInt         entryIndex;
     };
     List<OutputBinding> outputBindings;
 
-    RefPtr<PipelineLayout>  pipelineLayout;
-    RefPtr<DescriptorSet>   descriptorSet;
+    ComPtr<IPipelineLayout>  pipelineLayout;
+    ComPtr<IDescriptorSet> descriptorSet;
     int m_numRenderTargets = 1;
 };
 
-RefPtr<SamplerState> _createSamplerState(
+ComPtr<ISamplerState> _createSamplerState(
     IRenderer*               renderer,
     const InputSamplerDesc& srcDesc);
 
@@ -55,7 +55,7 @@ RefPtr<SamplerState> _createSamplerState(
 struct ShaderRendererUtil
 {
         /// Generate a texture using the InputTextureDesc and construct a TextureResource using the Renderer with the contents
-    static Slang::Result generateTextureResource(const InputTextureDesc& inputDesc, int bindFlags, IRenderer* renderer, Slang::RefPtr<TextureResource>& textureOut);
+    static Slang::Result generateTextureResource(const InputTextureDesc& inputDesc, int bindFlags, IRenderer* renderer, ComPtr<ITextureResource>& textureOut);
 
         /// Create texture resource using inputDesc, and texData to describe format, and contents
     static Slang::Result createTextureResource(
@@ -63,7 +63,7 @@ struct ShaderRendererUtil
         const TextureData& texData,
         int bindFlags,
         IRenderer* renderer,
-        Slang::RefPtr<TextureResource>& textureOut);
+        ComPtr<ITextureResource>& textureOut);
 
         /// Create the BufferResource using the renderer from the contents of inputDesc
     static Slang::Result createBufferResource(
@@ -72,13 +72,13 @@ struct ShaderRendererUtil
         size_t bufferSize,
         const void* initData,
         IRenderer* renderer,
-        Slang::RefPtr<BufferResource>& bufferOut);
+        ComPtr<IBufferResource>& bufferOut);
 
         /// Create BindingState::Desc from the contents of layout
     static Slang::Result createBindingState(
         const ShaderInputLayout& layout,
         IRenderer* renderer,
-        BufferResource* addedConstantBuffer,
+        IBufferResource* addedConstantBuffer,
         BindingStateImpl** outBindingState);
 
 private:
@@ -87,7 +87,7 @@ private:
         ShaderInputLayoutEntry* srcEntries,
         int numEntries,
         IRenderer* renderer,
-        BufferResource* addedConstantBuffer,
+        IBufferResource* addedConstantBuffer,
         BindingStateImpl** outBindingState);
 };
 
diff --git a/tools/render-test/slang-support.cpp b/tools/render-test/slang-support.cpp
index baa745b14..300cab4d7 100644
--- a/tools/render-test/slang-support.cpp
+++ b/tools/render-test/slang-support.cpp
@@ -205,7 +205,7 @@ gfx::StageType translateStage(SlangStage slangStage)
         actualEntryPoints = request.entryPoints;
     }
 
-    List<ShaderProgram::KernelDesc> kernelDescs;
+    Slang::List<IShaderProgram::KernelDesc> kernelDescs;
 
     Index actualEntryPointCount = actualEntryPoints.getCount();
     for(Index ee = 0; ee < actualEntryPointCount; ++ee)
@@ -217,7 +217,7 @@ gfx::StageType translateStage(SlangStage slangStage)
 
         auto gfxStage = translateStage(actualEntryPoint.slangStage);
 
-        ShaderProgram::KernelDesc kernelDesc;
+        IShaderProgram::KernelDesc kernelDesc;
         kernelDesc.stage = gfxStage;
         kernelDesc.codeBegin = code;
         kernelDesc.codeEnd = code + codeSize;
diff --git a/tools/render-test/slang-support.h b/tools/render-test/slang-support.h
index a0a7ef276..06651ec73 100644
--- a/tools/render-test/slang-support.h
+++ b/tools/render-test/slang-support.h
@@ -12,6 +12,37 @@ namespace renderer_test {
 
 gfx::StageType translateStage(SlangStage slangStage);
 
+struct ShaderCompileRequest
+{
+    struct SourceInfo
+    {
+        char const* path;
+
+        // The data may either be source text (in which
+        // case it can be assumed to be nul-terminated with
+        // `dataEnd` pointing at the terminator), or
+        // raw binary data (in which case `dataEnd` points
+        // at the end of the buffer).
+        char const* dataBegin;
+        char const* dataEnd;
+    };
+
+    struct EntryPoint
+    {
+        char const* name = nullptr;
+        SlangStage slangStage;
+    };
+
+    SourceInfo source;
+    Slang::List<EntryPoint> entryPoints;
+
+    Slang::List<Slang::String> globalSpecializationArgs;
+    Slang::List<Slang::String> entryPointSpecializationArgs;
+
+    Slang::List<Slang::CommandLine::Arg> compileArgs;
+};
+
+
 struct ShaderCompilerUtil
 {
     struct Input
@@ -27,7 +58,7 @@ struct ShaderCompilerUtil
 
     struct Output
     {
-        void set(PipelineType pipelineType, const ShaderProgram::KernelDesc* inKernelDescs, Slang::Index kernelDescCount)
+        void set(PipelineType pipelineType, const IShaderProgram::KernelDesc* inKernelDescs, Slang::Index kernelDescCount)
         {
             kernelDescs.clear();
             kernelDescs.addRange(inKernelDescs, kernelDescCount);
@@ -73,8 +104,8 @@ struct ShaderCompilerUtil
             return -1;
         }
 
-        List<ShaderProgram::KernelDesc> kernelDescs;
-        ShaderProgram::Desc desc;
+        Slang::List<IShaderProgram::KernelDesc> kernelDescs;
+        IShaderProgram::Desc desc;
 
             /// Compile request that owns the lifetime of compiled kernel code.
         SlangCompileRequest* m_requestForKernels = nullptr;
@@ -98,7 +129,7 @@ struct ShaderCompilerUtil
 
     static SlangResult compileWithLayout(SlangSession* session, const Options& options, const ShaderCompilerUtil::Input& input, OutputAndLayout& output);
 
-    static SlangResult readSource(const Slang::String& inSourcePath, List<char>& outSourceText);
+    static SlangResult readSource(const Slang::String& inSourcePath, Slang::List<char>& outSourceText);
 
     static SlangResult _compileProgramImpl(SlangSession* session, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out);
     static SlangResult compileProgram(SlangSession* session, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out);