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

* COM-ify all slang-gfx interfaces.

5 files changed, 153 insertions, 149 deletions

diff --git a/examples/gpu-printing/main.cpp b/examples/gpu-printing/main.cpp
index 75c083a33..03b20b969 100644
--- a/examples/gpu-printing/main.cpp
+++ b/examples/gpu-printing/main.cpp
@@ -8,6 +8,7 @@ using Slang::ComPtr;
 #include "gfx/render.h"
 #include "gfx/d3d11/render-d3d11.h"
 #include "tools/graphics-app-framework/window.h"
+#include "source/core/slang-basic.h"
 using namespace gfx;
 
 #include <string>
@@ -69,17 +70,17 @@ ComPtr<gfx::IRenderer>      gRenderer;
 
 ComPtr<slang::ISession> gSlangSession;
 ComPtr<slang::IModule>   gSlangModule;
-RefPtr<gfx::ShaderProgram>  gProgram;
+ComPtr<gfx::IShaderProgram> gProgram;
 
-RefPtr<gfx::PipelineLayout> gPipelineLayout;
-RefPtr<gfx::PipelineState>  gPipelineState;
-RefPtr<gfx::DescriptorSet>  gDescriptorSet;
+ComPtr<gfx::IPipelineLayout> gPipelineLayout;
+ComPtr<gfx::IPipelineState> gPipelineState;
+ComPtr<gfx::IDescriptorSet> gDescriptorSet;
 
-Dictionary<int, std::string> gHashedStrings;
+Slang::Dictionary<int, std::string> gHashedStrings;
 
 GPUPrinting gGPUPrinting;
 
-RefPtr<gfx::ShaderProgram> loadComputeProgram(slang::IModule* slangModule, char const* entryPointName)
+ComPtr<gfx::IShaderProgram> loadComputeProgram(slang::IModule* slangModule, char const* entryPointName)
 {
     ComPtr<slang::IEntryPoint> entryPoint;
     slangModule->findEntryPointByName(entryPointName, entryPoint.writeRef());
@@ -95,12 +96,12 @@ RefPtr<gfx::ShaderProgram> loadComputeProgram(slang::IModule* slangModule, char
     char const* code = (char const*) codeBlob->getBufferPointer();
     char const* codeEnd = code + codeBlob->getBufferSize();
 
-    gfx::ShaderProgram::KernelDesc kernelDescs[] =
+    gfx::IShaderProgram::KernelDesc kernelDescs[] =
     {
         { gfx::StageType::Compute,    code,     codeEnd },
     };
 
-    gfx::ShaderProgram::Desc programDesc;
+    gfx::IShaderProgram::Desc programDesc;
     programDesc.pipelineType = gfx::PipelineType::Compute;
     programDesc.kernels = &kernelDescs[0];
     programDesc.kernelCount = 2;
@@ -133,21 +134,21 @@ Result execute()
     gProgram = loadComputeProgram(gSlangModule, "computeMain");
     if(!gProgram) return SLANG_FAIL;
 
-    DescriptorSetLayout::SlotRangeDesc slotRanges[] =
+    IDescriptorSetLayout::SlotRangeDesc slotRanges[] =
     {
-        DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::StorageBuffer),
+        IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::StorageBuffer),
     };
-    DescriptorSetLayout::Desc descriptorSetLayoutDesc;
+    IDescriptorSetLayout::Desc descriptorSetLayoutDesc;
     descriptorSetLayoutDesc.slotRangeCount = 1;
     descriptorSetLayoutDesc.slotRanges = &slotRanges[0];
     auto descriptorSetLayout = gRenderer->createDescriptorSetLayout(descriptorSetLayoutDesc);
     if(!descriptorSetLayout) return SLANG_FAIL;
 
-    PipelineLayout::DescriptorSetDesc descriptorSets[] =
+    IPipelineLayout::DescriptorSetDesc descriptorSets[] =
     {
-        PipelineLayout::DescriptorSetDesc( descriptorSetLayout ),
+        IPipelineLayout::DescriptorSetDesc( descriptorSetLayout ),
     };
-    PipelineLayout::Desc pipelineLayoutDesc;
+    IPipelineLayout::Desc pipelineLayoutDesc;
     pipelineLayoutDesc.renderTargetCount = 1;
     pipelineLayoutDesc.descriptorSetCount = 1;
     pipelineLayoutDesc.descriptorSets = &descriptorSets[0];
@@ -176,14 +177,14 @@ Result execute()
 
     size_t printBufferSize = 4 * 1024; // use a small-ish (4KB) buffer for print output
 
-    BufferResource::Desc printBufferDesc;
+    IBufferResource::Desc printBufferDesc;
     printBufferDesc.init(printBufferSize);
     printBufferDesc.elementSize = sizeof(uint32_t);
-    printBufferDesc.cpuAccessFlags = Resource::AccessFlag::Read; // | Resource::AccessFlag::Write;
-    auto printBuffer = gRenderer->createBufferResource(Resource::Usage::UnorderedAccess, printBufferDesc);
+    printBufferDesc.cpuAccessFlags = IResource::AccessFlag::Read; // | Resource::AccessFlag::Write;
+    auto printBuffer = gRenderer->createBufferResource(IResource::Usage::UnorderedAccess, printBufferDesc);
 
-    ResourceView::Desc printBufferViewDesc;
-    printBufferViewDesc.type = ResourceView::Type::UnorderedAccess;
+    IResourceView::Desc printBufferViewDesc;
+    printBufferViewDesc.type = IResourceView::Type::UnorderedAccess;
     auto printBufferView = gRenderer->createBufferView(printBuffer, printBufferViewDesc);
 
     // TODO: need to copy a zero into the start of the print buffer!
diff --git a/examples/hello-world/main.cpp b/examples/hello-world/main.cpp
index da35f3f0a..77ca8a978 100644
--- a/examples/hello-world/main.cpp
+++ b/examples/hello-world/main.cpp
@@ -36,8 +36,10 @@
 #include "gfx/d3d11/render-d3d11.h"
 #include "tools/graphics-app-framework/window.h"
 #include "slang-com-ptr.h"
+#include "source/core/slang-basic.h"
 
 using namespace gfx;
+using namespace Slang;
 
 // For the purposes of a small example, we will define the vertex data for a
 // single triangle directly in the source file. It should be easy to extend
@@ -72,7 +74,7 @@ struct HelloWorld
 // Slang API. This function is representative of code that a user
 // might write to integrate Slang into their renderer/engine.
 //
-RefPtr<gfx::ShaderProgram> loadShaderProgram(gfx::IRenderer* renderer)
+ComPtr<gfx::IShaderProgram> loadShaderProgram(gfx::IRenderer* renderer)
 {
     // First, we need to create a "session" for interacting with the Slang
     // compiler. This scopes all of our application's interactions
@@ -183,13 +185,13 @@ RefPtr<gfx::ShaderProgram> loadShaderProgram(gfx::IRenderer* renderer)
     // Reminder: this section does not involve the Slang API at all.
     //
 
-    gfx::ShaderProgram::KernelDesc kernelDescs[] =
+    gfx::IShaderProgram::KernelDesc kernelDescs[] =
     {
         { gfx::StageType::Vertex,    vertexCode,     vertexCodeEnd },
         { gfx::StageType::Fragment,  fragmentCode,   fragmentCodeEnd },
     };
 
-    gfx::ShaderProgram::Desc programDesc;
+    gfx::IShaderProgram::Desc programDesc;
     programDesc.pipelineType = gfx::PipelineType::Graphics;
     programDesc.kernels = &kernelDescs[0];
     programDesc.kernelCount = 2;
@@ -230,19 +232,19 @@ int gWindowHeight = 768;
 gfx::ApplicationContext*    gAppContext;
 gfx::Window*                gWindow;
 Slang::ComPtr<gfx::IRenderer>       gRenderer;
-RefPtr<gfx::BufferResource> gConstantBuffer;
+ComPtr<gfx::IBufferResource> gConstantBuffer;
 
-RefPtr<gfx::PipelineLayout> gPipelineLayout;
-RefPtr<gfx::PipelineState>  gPipelineState;
-RefPtr<gfx::DescriptorSet>  gDescriptorSet;
+ComPtr<gfx::IPipelineLayout> gPipelineLayout;
+ComPtr<gfx::IPipelineState> gPipelineState;
+ComPtr<gfx::IDescriptorSet> gDescriptorSet;
 
-RefPtr<gfx::BufferResource> gVertexBuffer;
+ComPtr<gfx::IBufferResource> gVertexBuffer;
 
 // Now that we've covered the function that actually loads and
 // compiles our Slang shade code, we can go through the rest
 // of the application code without as much commentary.
 //
-Result initialize()
+Slang::Result initialize()
 {
     // Create a window for our application to render into.
     //
@@ -264,7 +266,7 @@ Result initialize()
     rendererDesc.width = gWindowWidth;
     rendererDesc.height = gWindowHeight;
     {
-        Result res = gRenderer->initialize(rendererDesc, getPlatformWindowHandle(gWindow));
+        gfx::Result res = gRenderer->initialize(rendererDesc, getPlatformWindowHandle(gWindow));
         if(SLANG_FAILED(res)) return res;
     }
 
@@ -278,13 +280,13 @@ Result initialize()
     //
     int constantBufferSize = 16 * sizeof(float);
 
-    BufferResource::Desc constantBufferDesc;
+    IBufferResource::Desc constantBufferDesc;
     constantBufferDesc.init(constantBufferSize);
-    constantBufferDesc.setDefaults(Resource::Usage::ConstantBuffer);
-    constantBufferDesc.cpuAccessFlags = Resource::AccessFlag::Write;
+    constantBufferDesc.setDefaults(IResource::Usage::ConstantBuffer);
+    constantBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write;
 
     gConstantBuffer = gRenderer->createBufferResource(
-        Resource::Usage::ConstantBuffer,
+        IResource::Usage::ConstantBuffer,
         constantBufferDesc);
     if(!gConstantBuffer) return SLANG_FAIL;
 
@@ -305,11 +307,11 @@ Result initialize()
     // Next we allocate a vertex buffer for our pre-initialized
     // vertex data.
     //
-    BufferResource::Desc vertexBufferDesc;
+    IBufferResource::Desc vertexBufferDesc;
     vertexBufferDesc.init(kVertexCount * sizeof(Vertex));
-    vertexBufferDesc.setDefaults(Resource::Usage::VertexBuffer);
+    vertexBufferDesc.setDefaults(IResource::Usage::VertexBuffer);
     gVertexBuffer = gRenderer->createBufferResource(
-        Resource::Usage::VertexBuffer,
+        IResource::Usage::VertexBuffer,
         vertexBufferDesc,
         &kVertexData[0]);
     if(!gVertexBuffer) return SLANG_FAIL;
@@ -317,7 +319,7 @@ Result initialize()
     // Now we will use our `loadShaderProgram` function to load
     // the code from `shaders.slang` into the graphics API.
     //
-    RefPtr<ShaderProgram> shaderProgram = loadShaderProgram(gRenderer);
+    ComPtr<IShaderProgram> shaderProgram = loadShaderProgram(gRenderer);
     if(!shaderProgram) return SLANG_FAIL;
 
     // Our example graphics API usess a "modern" D3D12/Vulkan style
@@ -326,11 +328,11 @@ Result initialize()
     //
     // First, we need to construct a descriptor set *layout*.
     //
-    DescriptorSetLayout::SlotRangeDesc slotRanges[] =
+    IDescriptorSetLayout::SlotRangeDesc slotRanges[] =
     {
-        DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::UniformBuffer),
+        IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::UniformBuffer),
     };
-    DescriptorSetLayout::Desc descriptorSetLayoutDesc;
+    IDescriptorSetLayout::Desc descriptorSetLayoutDesc;
     descriptorSetLayoutDesc.slotRangeCount = 1;
     descriptorSetLayoutDesc.slotRanges = &slotRanges[0];
     auto descriptorSetLayout = gRenderer->createDescriptorSetLayout(descriptorSetLayoutDesc);
@@ -340,11 +342,11 @@ Result initialize()
     // that we will render with only a single descriptor set bound.
     //
 
-    PipelineLayout::DescriptorSetDesc descriptorSets[] =
+    IPipelineLayout::DescriptorSetDesc descriptorSets[] =
     {
-        PipelineLayout::DescriptorSetDesc( descriptorSetLayout ),
+        IPipelineLayout::DescriptorSetDesc( descriptorSetLayout ),
     };
-    PipelineLayout::Desc pipelineLayoutDesc;
+    IPipelineLayout::Desc pipelineLayoutDesc;
     pipelineLayoutDesc.renderTargetCount = 1;
     pipelineLayoutDesc.descriptorSetCount = 1;
     pipelineLayoutDesc.descriptorSets = &descriptorSets[0];
diff --git a/examples/heterogeneous-hello-world/main.cpp b/examples/heterogeneous-hello-world/main.cpp
index 51aff0a17..0446ea1a7 100644
--- a/examples/heterogeneous-hello-world/main.cpp
+++ b/examples/heterogeneous-hello-world/main.cpp
@@ -37,20 +37,22 @@
 #include "gfx/d3d11/render-d3d11.h"
 #include "tools/graphics-app-framework/window.h"
 #include "../../prelude/slang-cpp-types.h"
+#include "source/core/slang-basic.h"
+
 using namespace gfx;
 
 // We create global ref pointers to avoid dereferencing values
 //
-RefPtr<gfx::ShaderProgram>         gShaderProgram;
-RefPtr<gfx::ApplicationContext>    gAppContext;
+ComPtr<gfx::IShaderProgram>         gShaderProgram;
+Slang::RefPtr<gfx::ApplicationContext> gAppContext;
 Slang::ComPtr<gfx::IRenderer>      gRenderer;
 
-RefPtr<gfx::BufferResource>        gStructuredBuffer;
+ComPtr<gfx::IBufferResource> gStructuredBuffer;
 
-RefPtr<gfx::PipelineLayout>        gPipelineLayout;
-RefPtr<gfx::PipelineState>         gPipelineState;
-RefPtr<gfx::DescriptorSetLayout>   gDescriptorSetLayout;
-RefPtr<gfx::DescriptorSet>         gDescriptorSet;
+ComPtr<gfx::IPipelineLayout> gPipelineLayout;
+ComPtr<gfx::IPipelineState> gPipelineState;
+ComPtr<gfx::IDescriptorSetLayout> gDescriptorSetLayout;
+ComPtr<gfx::IDescriptorSet> gDescriptorSet;
 
 // Boilerplate types to help the slan-generated file
 //
@@ -67,7 +69,7 @@ bool executeComputation_0();
 extern unsigned char __computeMain[];
 extern size_t __computeMainSize;
 
-gfx::ShaderProgram* loadShaderProgram(gfx::IRenderer* renderer, unsigned char computeCode[], size_t computeCodeSize)
+gfx::IShaderProgram* loadShaderProgram(gfx::IRenderer* renderer, unsigned char computeCode[], size_t computeCodeSize)
 {
     // We extract the begin/end pointers to the output code buffers directly
     //
@@ -79,12 +81,12 @@ gfx::ShaderProgram* loadShaderProgram(gfx::IRenderer* renderer, unsigned char co
     // Reminder: this section does not involve the Slang API at all.
     //
 
-    gfx::ShaderProgram::KernelDesc kernelDescs[] =
+    gfx::IShaderProgram::KernelDesc kernelDescs[] =
     {
         { gfx::StageType::Compute,    computeCode,     computeCodeEnd },
     };
 
-    gfx::ShaderProgram::Desc programDesc;
+    gfx::IShaderProgram::Desc programDesc;
     programDesc.pipelineType = gfx::PipelineType::Compute;
     programDesc.kernels = &kernelDescs[0];
     programDesc.kernelCount = 1;
@@ -133,26 +135,26 @@ gfx::IRenderer* createRenderer(
     return gRenderer;
 }
 
-gfx::BufferResource* createStructuredBuffer(gfx::IRenderer* renderer, float* initialArray)
+gfx::IBufferResource* createStructuredBuffer(gfx::IRenderer* renderer, float* initialArray)
 {
     // Create a structured buffer for storing the data for computation
     //
     int structuredBufferSize = 4 * sizeof(float);
 
-    BufferResource::Desc structuredBufferDesc;
+    IBufferResource::Desc structuredBufferDesc;
     structuredBufferDesc.init(structuredBufferSize);
-    structuredBufferDesc.setDefaults(Resource::Usage::UnorderedAccess);
+    structuredBufferDesc.setDefaults(IResource::Usage::UnorderedAccess);
     structuredBufferDesc.elementSize = 4;
-    structuredBufferDesc.cpuAccessFlags = Resource::AccessFlag::Read;
+    structuredBufferDesc.cpuAccessFlags = IResource::AccessFlag::Read;
 
     gStructuredBuffer = renderer->createBufferResource(
-        Resource::Usage::UnorderedAccess,
+        IResource::Usage::UnorderedAccess,
         structuredBufferDesc,
         initialArray);
     return gStructuredBuffer;
 }
 
-gfx::DescriptorSetLayout* buildDescriptorSetLayout(gfx::IRenderer* renderer)
+gfx::IDescriptorSetLayout* buildDescriptorSetLayout(gfx::IRenderer* renderer)
 {
     // Our example graphics API usess a "modern" D3D12/Vulkan style
     // of resource binding, so now we will dive into describing and
@@ -160,28 +162,28 @@ gfx::DescriptorSetLayout* buildDescriptorSetLayout(gfx::IRenderer* renderer)
     //
     // First, we need to construct a descriptor set *layout*.
     //
-    DescriptorSetLayout::SlotRangeDesc slotRanges[] =
+    IDescriptorSetLayout::SlotRangeDesc slotRanges[] =
     {
-        DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::StorageBuffer),
+        IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::StorageBuffer),
     };
-    DescriptorSetLayout::Desc descriptorSetLayoutDesc;
+    IDescriptorSetLayout::Desc descriptorSetLayoutDesc;
     descriptorSetLayoutDesc.slotRangeCount = 1;
     descriptorSetLayoutDesc.slotRanges = &slotRanges[0];
     gDescriptorSetLayout = renderer->createDescriptorSetLayout(descriptorSetLayoutDesc);
     return gDescriptorSetLayout;
 }
 
-gfx::PipelineLayout* buildPipeline(gfx::IRenderer* renderer, gfx::DescriptorSetLayout* descriptorSetLayout)
+gfx::IPipelineLayout* buildPipeline(gfx::IRenderer* renderer, gfx::IDescriptorSetLayout* descriptorSetLayout)
 {
     // Next we will allocate a pipeline layout, which specifies
     // that we will render with only a single descriptor set bound.
     //
 
-    PipelineLayout::DescriptorSetDesc descriptorSets[] =
+    IPipelineLayout::DescriptorSetDesc descriptorSets[] =
     {
-        PipelineLayout::DescriptorSetDesc(descriptorSetLayout),
+        IPipelineLayout::DescriptorSetDesc(descriptorSetLayout),
     };
-    PipelineLayout::Desc pipelineLayoutDesc;
+    IPipelineLayout::Desc pipelineLayoutDesc;
     pipelineLayoutDesc.renderTargetCount = 1;
     pipelineLayoutDesc.descriptorSetCount = 1;
     pipelineLayoutDesc.descriptorSets = &descriptorSets[0];
@@ -190,10 +192,10 @@ gfx::PipelineLayout* buildPipeline(gfx::IRenderer* renderer, gfx::DescriptorSetL
     return gPipelineLayout;
 }
 
-gfx::DescriptorSet* buildDescriptorSet(
+gfx::IDescriptorSet* buildDescriptorSet(
     gfx::IRenderer* renderer,
-    gfx::DescriptorSetLayout* descriptorSetLayout,
-    gfx::BufferResource* structuredBuffer)
+    gfx::IDescriptorSetLayout* descriptorSetLayout,
+    gfx::IBufferResource* structuredBuffer)
 {
     // Once we have the descriptor set layout, we can allocate
     // and fill in a descriptor set to hold our parameters.
@@ -204,18 +206,18 @@ gfx::DescriptorSet* buildDescriptorSet(
     // Once we have the bufferResource created, we can fill in
     // a descriptor set for creating a structured buffer
     //
-    ResourceView::Desc resourceViewDesc;
-    resourceViewDesc.type = ResourceView::Type::UnorderedAccess;
+    IResourceView::Desc resourceViewDesc;
+    resourceViewDesc.type = IResourceView::Type::UnorderedAccess;
     auto resourceView = renderer->createBufferView(structuredBuffer, resourceViewDesc);
     gDescriptorSet->setResource(0, 0, resourceView);
 
     return gDescriptorSet;
 }
 
-gfx::PipelineState* buildPipelineState(
-    gfx::ShaderProgram* shaderProgram,
+gfx::IPipelineState* buildPipelineState(
+    gfx::IShaderProgram* shaderProgram,
     gfx::IRenderer* renderer,
-    gfx::PipelineLayout* pipelineLayout)
+    gfx::IPipelineLayout* pipelineLayout)
 {
     // Following the D3D12/Vulkan style of API, we need a pipeline state object
     // (PSO) to encapsulate the configuration of the overall graphics pipeline.
@@ -240,9 +242,9 @@ void printInitialValues(float* initialArray, int length)
 
 void dispatchComputation(
     gfx::IRenderer* gRenderer,
-    gfx::PipelineState* gPipelineState,
-    gfx::PipelineLayout* gPipelineLayout,
-    gfx::DescriptorSet* gDescriptorSet,
+    gfx::IPipelineState* gPipelineState,
+    gfx::IPipelineLayout* gPipelineLayout,
+    gfx::IDescriptorSet* gDescriptorSet,
     unsigned int gridDimsX,
     unsigned int gridDimsY,
     unsigned int gridDimsZ)
@@ -256,7 +258,7 @@ void dispatchComputation(
 
 void print_output(
     gfx::IRenderer* renderer,
-    gfx::BufferResource* structuredBuffer,
+    gfx::IBufferResource* structuredBuffer,
     int length)
 {
     if (float* outputData = (float*)renderer->map(structuredBuffer, MapFlavor::HostRead))
@@ -301,22 +303,22 @@ gfx_DescriptorSetLayout_0* buildDescriptorSetLayout_0(gfx_Renderer_0* _0)
 
 gfx_PipelineLayout_0* buildPipeline_0(gfx_Renderer_0* _0, gfx_DescriptorSetLayout_0* _1)
 {
-    return (gfx_PipelineLayout_0*)buildPipeline((gfx::IRenderer*)_0, (gfx::DescriptorSetLayout*)_1);
+    return (gfx_PipelineLayout_0*)buildPipeline((gfx::IRenderer*)_0, (gfx::IDescriptorSetLayout*)_1);
 }
 
 gfx_DescriptorSet_0* buildDescriptorSet_0(gfx_Renderer_0* _0, gfx_DescriptorSetLayout_0* _1, gfx_BufferResource_0* _2)
 {
     return (gfx_DescriptorSet_0*)buildDescriptorSet(
         (gfx::IRenderer*)_0,
-        (gfx::DescriptorSetLayout*)_1,
-        (gfx::BufferResource*)_2);
+        (gfx::IDescriptorSetLayout*)_1,
+        (gfx::IBufferResource*)_2);
 }
 
 gfx_PipelineState_0* buildPipelineState_0(gfx_ShaderProgram_0* _0, gfx_Renderer_0* _1, gfx_PipelineLayout_0* _2)
 {
     return (gfx_PipelineState_0*)buildPipelineState(
-        (gfx::ShaderProgram*)_0, (gfx::IRenderer*)_1,
-        (gfx::PipelineLayout*)_2);
+        (gfx::IShaderProgram*)_0, (gfx::IRenderer*)_1,
+        (gfx::IPipelineLayout*)_2);
 }
 
 void printInitialValues_0(FixedArray<float, 4> _0, int32_t _1)
@@ -328,9 +330,9 @@ void dispatchComputation_0(gfx_Renderer_0* _0, gfx_PipelineState_0* _1, gfx_Pipe
 {
     dispatchComputation(
         (gfx::IRenderer*)_0,
-        (gfx::PipelineState*)_1,
-        (gfx::PipelineLayout*)_2,
-        (gfx::DescriptorSet*)_3,
+        (gfx::IPipelineState*)_1,
+        (gfx::IPipelineLayout*)_2,
+        (gfx::IDescriptorSet*)_3,
         gridDimsX,
         gridDimsY,
         gridDimsZ);
@@ -348,7 +350,7 @@ gfx_BufferResource_0* unconvertBuffer_0(RWStructuredBuffer<float> _0) {
 
 void print_output_0(gfx_Renderer_0* _0, gfx_BufferResource_0* _1, int32_t _2)
 {
-    print_output((gfx::IRenderer*)_0, (gfx::BufferResource*)_1, _2);
+    print_output((gfx::IRenderer*)_0, (gfx::IBufferResource*)_1, _2);
 }
 
 // This "inner" main function is used by the platform abstraction
diff --git a/examples/model-viewer/main.cpp b/examples/model-viewer/main.cpp
index 2dc7df3b5..387ec7293 100644
--- a/examples/model-viewer/main.cpp
+++ b/examples/model-viewer/main.cpp
@@ -23,7 +23,8 @@
 #include "graphics-app-framework/window.h"
 #include "graphics-app-framework/gui.h"
 using namespace gfx;
-
+using Slang::RefObject;
+using Slang::RefPtr;
 // We will use a few utilities from the C++ standard library,
 // just to keep the code short. Note that the Slang API does
 // not use or require any C++ standard library features.
@@ -382,7 +383,7 @@ struct ParameterBlockLayout : RefObject
 
     // API-specific layout information computes from `slangTypelayout`.
     //
-    RefPtr<gfx::DescriptorSetLayout>     descriptorSetLayout;
+    ComPtr<gfx::IDescriptorSetLayout>     descriptorSetLayout;
 };
 //
 // A parameter block layout can be computed for any `struct` type
@@ -423,7 +424,7 @@ RefPtr<ParameterBlockLayout> getParameterBlockLayout(
     // create a graphics-API-level descriptor-set layout that
     // is compatible with the original declaration.
     //
-    std::vector<gfx::DescriptorSetLayout::SlotRangeDesc> slotRanges;
+    std::vector<gfx::IDescriptorSetLayout::SlotRangeDesc> slotRanges;
 
     // If the type has any ordinary data, then the descriptor set
     // will need a constant buffer to be the first thing it stores.
@@ -438,7 +439,7 @@ RefPtr<ParameterBlockLayout> getParameterBlockLayout(
     if(primaryConstantBufferSize)
     {
         slotRanges.push_back(
-            gfx::DescriptorSetLayout::SlotRangeDesc(
+            gfx::IDescriptorSetLayout::SlotRangeDesc(
                 gfx::DescriptorSlotType::UniformBuffer));
     }
 
@@ -453,7 +454,7 @@ RefPtr<ParameterBlockLayout> getParameterBlockLayout(
     // Now that we've collected the graphics-API level binding
     // information, we can construct a graphics API descriptor set
     // layout.
-    gfx::DescriptorSetLayout::Desc descriptorSetLayoutDesc;
+    gfx::IDescriptorSetLayout::Desc descriptorSetLayoutDesc;
     descriptorSetLayoutDesc.slotRangeCount = slotRanges.size();
     descriptorSetLayoutDesc.slotRanges = slotRanges.data();
     auto descriptorSetLayout = renderer->createDescriptorSetLayout(descriptorSetLayoutDesc);
@@ -552,7 +553,7 @@ struct ParameterBlockEncoder
 
     // The underlying descriptor set being filled in.
     //
-    gfx::DescriptorSet* descriptorSet = nullptr;
+    gfx::IDescriptorSet* descriptorSet = nullptr;
 
     // The Slang type information for the part of the
     // block that we are filling in. This might be the
@@ -648,11 +649,11 @@ struct ParameterBlock : RefObject
     // The (optional) constant buffer that holds the values
     // for any ordinay fields. This will be null if
     // `layout->primaryConstantBufferSize` is zero.
-    RefPtr<BufferResource>          primaryConstantBuffer;
+    ComPtr<IBufferResource>          primaryConstantBuffer;
 
     // The graphics-API descriptor set that provides storage
     // for any resource fields.
-    RefPtr<gfx::DescriptorSet>           descriptorSet;
+    ComPtr<gfx::IDescriptorSet> descriptorSet;
 
     ParameterBlockEncoder beginEncoding();
 };
@@ -674,15 +675,15 @@ RefPtr<ParameterBlock> allocateParameterBlockImpl(
     // If the parameter block has any ordinary data, then it requires
     // a "primary" constant buffer to hold that data.
     //
-    RefPtr<gfx::BufferResource> primaryConstantBuffer = nullptr;
+    ComPtr<gfx::IBufferResource> primaryConstantBuffer = nullptr;
     if(auto primaryConstantBufferSize = layout->primaryConstantBufferSize)
     {
-        gfx::BufferResource::Desc bufferDesc;
+        gfx::IBufferResource::Desc bufferDesc;
         bufferDesc.init(primaryConstantBufferSize);
-        bufferDesc.setDefaults(gfx::Resource::Usage::ConstantBuffer);
-        bufferDesc.cpuAccessFlags = gfx::Resource::AccessFlag::Write;
+        bufferDesc.setDefaults(gfx::IResource::Usage::ConstantBuffer);
+        bufferDesc.cpuAccessFlags = gfx::IResource::AccessFlag::Write;
         primaryConstantBuffer = renderer->createBufferResource(
-            gfx::Resource::Usage::ConstantBuffer,
+            gfx::IResource::Usage::ConstantBuffer,
             bufferDesc);
 
         // The primary constant buffer will always be the first thing
@@ -774,7 +775,7 @@ struct Effect : RefObject
 
     // Additional state corresponding to the data needed
     // to create a graphics-API pipeline state object.
-    RefPtr<gfx::InputLayout>    inputLayout;
+    ComPtr<gfx::IInputLayout>    inputLayout;
     Int                         renderTargetCount;
 };
 
@@ -791,8 +792,8 @@ struct EffectVariant : RefObject
     // that need to be bound in order to use this
     // effect.
     //
-    RefPtr<gfx::PipelineLayout>  pipelineLayout;
-    RefPtr<gfx::PipelineState>   pipelineState;
+    ComPtr<gfx::IPipelineLayout>  pipelineLayout;
+    ComPtr<gfx::IPipelineState> pipelineState;
 };
 //
 // A specialized variant is created based on a base effect
@@ -839,13 +840,13 @@ RefPtr<EffectVariant> createEffectVaraint(
     // be determined based on the descriptor-set layouts
     // already cached in the given parameter block layouts.
     //
-    std::vector<PipelineLayout::DescriptorSetDesc> descriptorSets;
+    std::vector<IPipelineLayout::DescriptorSetDesc> descriptorSets;
     for(UInt pp = 0; pp < parameterBlockCount; ++pp)
     {
         descriptorSets.emplace_back(
             parameterBlockLayouts[pp]->descriptorSetLayout);
     }
-    PipelineLayout::Desc pipelineLayoutDesc;
+    IPipelineLayout::Desc pipelineLayoutDesc;
     pipelineLayoutDesc.renderTargetCount = 1;
     pipelineLayoutDesc.descriptorSetCount = descriptorSets.size();
     pipelineLayoutDesc.descriptorSets = descriptorSets.data();
@@ -927,7 +928,7 @@ RefPtr<EffectVariant> createEffectVaraint(
     // to the graphics APIs loading logic.
     //
     std::vector<ISlangBlob*> kernelBlobs;
-    std::vector<gfx::ShaderProgram::KernelDesc> kernelDescs;
+    std::vector<gfx::IShaderProgram::KernelDesc> kernelDescs;
     for(int ii = 0; ii < entryPointCount; ++ii)
     {
         auto entryPoint = program->entryPoints[ii];
@@ -937,7 +938,7 @@ RefPtr<EffectVariant> createEffectVaraint(
 
         kernelBlobs.push_back(blob);
 
-        ShaderProgram::KernelDesc kernelDesc;
+        IShaderProgram::KernelDesc kernelDesc;
 
         char const* codeBegin = (char const*) blob->getBufferPointer();
         char const* codeEnd = codeBegin + blob->getBufferSize();
@@ -960,7 +961,7 @@ RefPtr<EffectVariant> createEffectVaraint(
     spDestroyCompileRequest(slangRequest);
 
     // We use the graphics API to load a program into the GPU
-    gfx::ShaderProgram::Desc programDesc;
+    gfx::IShaderProgram::Desc programDesc;
     programDesc.pipelineType = gfx::PipelineType::Graphics;
     programDesc.kernels = kernelDescs.data();
     programDesc.kernelCount = kernelDescs.size();
@@ -1020,11 +1021,11 @@ struct ShaderCache : RefObject
 
         Slang::HashCode getHashCode() const
         {
-            auto hash = ::getHashCode(effect);
-            hash = combineHash(hash, ::getHashCode(parameterBlockCount));
+            auto hash = Slang::getHashCode(effect);
+            hash = Slang::combineHash(hash, Slang::getHashCode(parameterBlockCount));
             for( UInt ii = 0; ii < parameterBlockCount; ++ii )
             {
-                hash = combineHash(hash, ::getHashCode(parameterBlockLayouts[ii]));
+                hash = Slang::combineHash(hash, Slang::getHashCode(parameterBlockLayouts[ii]));
             }
             return hash;
         }
@@ -1033,7 +1034,7 @@ struct ShaderCache : RefObject
     // The shader cache is mostly just a dictionary mapping
     // variant keys to the associated variant, generated on-demand.
     //
-    Dictionary<VariantKey, RefPtr<EffectVariant> > variants;
+    Slang::Dictionary<VariantKey, RefPtr<EffectVariant> > variants;
 
     // Getting a variant is just a matter of looking for an
     // existing entry in the dictionary, and creating one
@@ -1372,8 +1373,8 @@ struct Model : RefObject
 {
     typedef ModelLoader::Vertex Vertex;
 
-    RefPtr<BufferResource>      vertexBuffer;
-    RefPtr<BufferResource>      indexBuffer;
+    ComPtr<IBufferResource>     vertexBuffer;
+    ComPtr<IBufferResource>     indexBuffer;
     PrimitiveTopology           primitiveTopology;
     int                         vertexCount;
     int                         indexCount;
@@ -1911,7 +1912,7 @@ struct ModelViewer {
 
 Window* gWindow;
 Slang::ComPtr<gfx::IRenderer> gRenderer;
-RefPtr<gfx::ResourceView> gDepthTarget;
+ComPtr<gfx::IResourceView> gDepthTarget;
 
 // We keep a pointer to the one effect we are using (for a forward
 // rendering pass), plus the parameter-block layouts for our `PerView`
@@ -2069,16 +2070,16 @@ Result initialize()
     // Because we are rendering more than a single triangle this time, we
     // require a depth buffer to resolve visibility.
     //
-    TextureResource::Desc depthBufferDesc = gRenderer->getSwapChainTextureDesc();
+    ITextureResource::Desc depthBufferDesc = gRenderer->getSwapChainTextureDesc();
     depthBufferDesc.format = Format::D_Float32;
-    depthBufferDesc.setDefaults(Resource::Usage::DepthWrite);
+    depthBufferDesc.setDefaults(IResource::Usage::DepthWrite);
     auto depthTexture = gRenderer->createTextureResource(
-        Resource::Usage::DepthWrite,
+        IResource::Usage::DepthWrite,
         depthBufferDesc);
     if(!depthTexture) return SLANG_FAIL;
 
-    ResourceView::Desc textureViewDesc;
-    textureViewDesc.type = ResourceView::Type::DepthStencil;
+    IResourceView::Desc textureViewDesc;
+    textureViewDesc.type = IResourceView::Type::DepthStencil;
     auto depthTarget = gRenderer->createTextureView(depthTexture, textureViewDesc);
     if (!depthTarget) return SLANG_FAIL;
 
diff --git a/examples/shader-toy/main.cpp b/examples/shader-toy/main.cpp
index 89a40b794..e2efc325c 100644
--- a/examples/shader-toy/main.cpp
+++ b/examples/shader-toy/main.cpp
@@ -22,6 +22,8 @@ using Slang::ComPtr;
 #include "gfx/render.h"
 #include "gfx/d3d11/render-d3d11.h"
 #include "tools/graphics-app-framework/window.h"
+#include "source/core/slang-basic.h"
+
 using namespace gfx;
 
 // In order to display a shader toy effect using rasterization-based shader
@@ -88,7 +90,7 @@ void diagnoseIfNeeded(slang::IBlob* diagnosticsBlob)
 // The main interesting part of the host application code is where we
 // load, compile, inspect, and compose the Slang shader code.
 //
-Result loadShaderProgram(gfx::IRenderer* renderer, RefPtr<gfx::ShaderProgram>& outShaderProgram)
+Result loadShaderProgram(gfx::IRenderer* renderer, ComPtr<gfx::IShaderProgram>& outShaderProgram)
 {
     // The first step in interacting with the Slang API is to create a "global session,"
     // which represents an instance of the Slang API loaded from the library.
@@ -192,7 +194,7 @@ Result loadShaderProgram(gfx::IRenderer* renderer, RefPtr<gfx::ShaderProgram>& o
     // other pieces, and that is what we are going to do with our module
     // and entry points.
     //
-    List<slang::IComponentType*> componentTypes;
+    Slang::List<slang::IComponentType*> componentTypes;
     componentTypes.add(module);
 
     // Later on when we go to extract compiled kernel code for our vertex
@@ -266,7 +268,7 @@ Result loadShaderProgram(gfx::IRenderer* renderer, RefPtr<gfx::ShaderProgram>& o
     // Because a shader program could have zero or more specialization parameters,
     // we need to build up an array of specialization arguments.
     //
-    List<slang::SpecializationArg> specializationArgs;
+    Slang::List<slang::SpecializationArg> specializationArgs;
 
     {
         // In our case, we only have a single specialization argument we plan
@@ -344,13 +346,13 @@ Result loadShaderProgram(gfx::IRenderer* renderer, RefPtr<gfx::ShaderProgram>& o
     char const* fragmentCode = (char const*) fragmentShaderBlob->getBufferPointer();
     char const* fragmentCodeEnd = fragmentCode + fragmentShaderBlob->getBufferSize();
 
-    gfx::ShaderProgram::KernelDesc kernelDescs[] =
+    gfx::IShaderProgram::KernelDesc kernelDescs[] =
     {
         { gfx::StageType::Vertex,    vertexCode,     vertexCodeEnd },
         { gfx::StageType::Fragment,  fragmentCode,   fragmentCodeEnd },
     };
 
-    gfx::ShaderProgram::Desc programDesc;
+    gfx::IShaderProgram::Desc programDesc;
     programDesc.pipelineType = gfx::PipelineType::Graphics;
     programDesc.kernels = &kernelDescs[0];
     programDesc.kernelCount = 2;
@@ -367,13 +369,11 @@ int gWindowHeight = 768;
 gfx::ApplicationContext*    gAppContext;
 gfx::Window*                gWindow;
 Slang::ComPtr<gfx::IRenderer> gRenderer;
-RefPtr<gfx::BufferResource> gConstantBuffer;
-
-RefPtr<gfx::PipelineLayout> gPipelineLayout;
-RefPtr<gfx::PipelineState>  gPipelineState;
-RefPtr<gfx::DescriptorSet>  gDescriptorSet;
-
-RefPtr<gfx::BufferResource> gVertexBuffer;
+ComPtr<gfx::IBufferResource> gConstantBuffer;
+ComPtr<gfx::IPipelineLayout> gPipelineLayout;
+ComPtr<gfx::IPipelineState> gPipelineState;
+ComPtr<gfx::IDescriptorSet> gDescriptorSet;
+ComPtr<gfx::IBufferResource> gVertexBuffer;
 
 Result initialize()
 {
@@ -396,13 +396,13 @@ Result initialize()
 
     int constantBufferSize = sizeof(Uniforms);
 
-    BufferResource::Desc constantBufferDesc;
+    IBufferResource::Desc constantBufferDesc;
     constantBufferDesc.init(constantBufferSize);
-    constantBufferDesc.setDefaults(Resource::Usage::ConstantBuffer);
-    constantBufferDesc.cpuAccessFlags = Resource::AccessFlag::Write;
+    constantBufferDesc.setDefaults(IResource::Usage::ConstantBuffer);
+    constantBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write;
 
     gConstantBuffer = gRenderer->createBufferResource(
-        Resource::Usage::ConstantBuffer,
+        IResource::Usage::ConstantBuffer,
         constantBufferDesc);
     if(!gConstantBuffer) return SLANG_FAIL;
 
@@ -414,33 +414,33 @@ Result initialize()
         SLANG_COUNT_OF(inputElements));
     if(!inputLayout) return SLANG_FAIL;
 
-    BufferResource::Desc vertexBufferDesc;
+    IBufferResource::Desc vertexBufferDesc;
     vertexBufferDesc.init(FullScreenTriangle::kVertexCount * sizeof(FullScreenTriangle::Vertex));
-    vertexBufferDesc.setDefaults(Resource::Usage::VertexBuffer);
+    vertexBufferDesc.setDefaults(IResource::Usage::VertexBuffer);
     gVertexBuffer = gRenderer->createBufferResource(
-        Resource::Usage::VertexBuffer,
+        IResource::Usage::VertexBuffer,
         vertexBufferDesc,
         &FullScreenTriangle::kVertices[0]);
     if(!gVertexBuffer) return SLANG_FAIL;
 
-    RefPtr<ShaderProgram> shaderProgram;
+    ComPtr<IShaderProgram> shaderProgram;
     SLANG_RETURN_ON_FAIL(loadShaderProgram(gRenderer, shaderProgram));
 
-    DescriptorSetLayout::SlotRangeDesc slotRanges[] =
+    IDescriptorSetLayout::SlotRangeDesc slotRanges[] =
     {
-        DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::UniformBuffer),
+        IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::UniformBuffer),
     };
-    DescriptorSetLayout::Desc descriptorSetLayoutDesc;
+    IDescriptorSetLayout::Desc descriptorSetLayoutDesc;
     descriptorSetLayoutDesc.slotRangeCount = 1;
     descriptorSetLayoutDesc.slotRanges = &slotRanges[0];
     auto descriptorSetLayout = gRenderer->createDescriptorSetLayout(descriptorSetLayoutDesc);
     if(!descriptorSetLayout) return SLANG_FAIL;
 
-    PipelineLayout::DescriptorSetDesc descriptorSets[] =
+    IPipelineLayout::DescriptorSetDesc descriptorSets[] =
     {
-        PipelineLayout::DescriptorSetDesc( descriptorSetLayout ),
+        IPipelineLayout::DescriptorSetDesc( descriptorSetLayout ),
     };
-    PipelineLayout::Desc pipelineLayoutDesc;
+    IPipelineLayout::Desc pipelineLayoutDesc;
     pipelineLayoutDesc.renderTargetCount = 1;
     pipelineLayoutDesc.descriptorSetCount = 1;
     pipelineLayoutDesc.descriptorSets = &descriptorSets[0];
@@ -526,9 +526,7 @@ void renderFrame()
     gRenderer->presentFrame();
 }
 
-void finalize()
-{
-}
+void finalize() { destroyWindow(gWindow); }
 
 void handleEvent(Event const& event)
 {