Make `gfx::Renderer` a COM interface. (#1653)

* Make `gfx::Renderer` a COM interface. This is a first step towards making the `gfx` library expose a COM compatible DLL interface. Remaining classes will come as separate PRs. * Fixup project files * Fix calling conventions * Make gfx::create*Renderer() functions increase ref count by 1 * Make renderer createFunc return via out parameter
author: Yong He <yonghe@outlook.com> 2021-01-11 09:11:52 -0800
committer: GitHub <noreply@github.com> 2021-01-11 09:11:52 -0800
commit: 5554777188225266e2295db3588f6cb17cae0c4d (patch)
tree: 9d15992cd24d752cde1047745cf75a25e841f494
parent: e24c5a6cb9c3347477b83abe084a09ae8f9fde0a (diff)
25 files changed, 716 insertions, 397 deletions
diff --git a/examples/gpu-printing/main.cpp b/examples/gpu-printing/main.cpp
index 10af0eef7..75c083a33 100644
--- a/examples/gpu-printing/main.cpp
+++ b/examples/gpu-printing/main.cpp
@@ -14,7 +14,7 @@ using namespace gfx;
 
 #include "gpu-printing.h"
 
-ComPtr<slang::ISession> createSlangSession(gfx::Renderer* renderer)
+ComPtr<slang::ISession> createSlangSession(gfx::IRenderer* renderer)
 {
     ComPtr<slang::IGlobalSession> slangGlobalSession;
     slangGlobalSession.attach(spCreateSession(NULL));
@@ -65,7 +65,7 @@ int gWindowHeight = 480;
 
 gfx::ApplicationContext*    gAppContext;
 gfx::Window*                gWindow;
-RefPtr<gfx::Renderer>       gRenderer;
+ComPtr<gfx::IRenderer>      gRenderer;
 
 ComPtr<slang::ISession> gSlangSession;
 ComPtr<slang::IModule>   gSlangModule;
@@ -118,8 +118,8 @@ Result execute()
     windowDesc.height = gWindowHeight;
     gWindow = createWindow(windowDesc);
 
-    gRenderer = createD3D11Renderer();
-    Renderer::Desc rendererDesc;
+    createD3D11Renderer(gRenderer.writeRef());
+    IRenderer::Desc rendererDesc;
     rendererDesc.width = gWindowWidth;
     rendererDesc.height = gWindowHeight;
     {
diff --git a/examples/hello-world/main.cpp b/examples/hello-world/main.cpp
index 9618b8c4d..da35f3f0a 100644
--- a/examples/hello-world/main.cpp
+++ b/examples/hello-world/main.cpp
@@ -35,6 +35,8 @@
 #include "gfx/render.h"
 #include "gfx/d3d11/render-d3d11.h"
 #include "tools/graphics-app-framework/window.h"
+#include "slang-com-ptr.h"
+
 using namespace gfx;
 
 // For the purposes of a small example, we will define the vertex data for a
@@ -70,7 +72,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::Renderer* renderer)
+RefPtr<gfx::ShaderProgram> 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
@@ -227,7 +229,7 @@ int gWindowHeight = 768;
 //
 gfx::ApplicationContext*    gAppContext;
 gfx::Window*                gWindow;
-RefPtr<gfx::Renderer>       gRenderer;
+Slang::ComPtr<gfx::IRenderer>       gRenderer;
 RefPtr<gfx::BufferResource> gConstantBuffer;
 
 RefPtr<gfx::PipelineLayout> gPipelineLayout;
@@ -257,8 +259,8 @@ Result initialize()
     // A future version of this example may support multiple
     // platforms/APIs.
     //
-    gRenderer = createD3D11Renderer();
-    Renderer::Desc rendererDesc;
+    createD3D11Renderer(gRenderer.writeRef());
+    IRenderer::Desc rendererDesc;
     rendererDesc.width = gWindowWidth;
     rendererDesc.height = gWindowHeight;
     {
diff --git a/examples/heterogeneous-hello-world/main.cpp b/examples/heterogeneous-hello-world/main.cpp
index 8c31e7a4c..51aff0a17 100644
--- a/examples/heterogeneous-hello-world/main.cpp
+++ b/examples/heterogeneous-hello-world/main.cpp
@@ -32,6 +32,7 @@
 // with Slang may depend on an application/engine making certain
 // design choices in their abstraction layer.
 //
+#include "slang-com-ptr.h"
 #include "gfx/render.h"
 #include "gfx/d3d11/render-d3d11.h"
 #include "tools/graphics-app-framework/window.h"
@@ -42,7 +43,7 @@ using namespace gfx;
 //
 RefPtr<gfx::ShaderProgram>         gShaderProgram;
 RefPtr<gfx::ApplicationContext>    gAppContext;
-RefPtr<gfx::Renderer>              gRenderer;
+Slang::ComPtr<gfx::IRenderer>      gRenderer;
 
 RefPtr<gfx::BufferResource>        gStructuredBuffer;
 
@@ -66,7 +67,7 @@ bool executeComputation_0();
 extern unsigned char __computeMain[];
 extern size_t __computeMainSize;
 
-gfx::ShaderProgram* loadShaderProgram(gfx::Renderer* renderer, unsigned char computeCode[], size_t computeCodeSize)
+gfx::ShaderProgram* loadShaderProgram(gfx::IRenderer* renderer, unsigned char computeCode[], size_t computeCodeSize)
 {
     // We extract the begin/end pointers to the output code buffers directly
     //
@@ -109,7 +110,7 @@ gfx::Window* createWindow(int windowWidth, int windowHeight)
     //return globalWindow;
 }
 
-gfx::Renderer* createRenderer(
+gfx::IRenderer* createRenderer(
     int windowWidth,
     int windowHeight,
     gfx::Window* window)
@@ -121,8 +122,8 @@ gfx::Renderer* createRenderer(
     // A future version of this example may support multiple
     // platforms/APIs.
     //
-    gRenderer = createD3D11Renderer();
-    Renderer::Desc rendererDesc;
+    createD3D11Renderer(gRenderer.writeRef());
+    IRenderer::Desc rendererDesc;
     rendererDesc.width = windowWidth;
     rendererDesc.height = windowHeight;
     {
@@ -132,7 +133,7 @@ gfx::Renderer* createRenderer(
     return gRenderer;
 }
 
-gfx::BufferResource* createStructuredBuffer(gfx::Renderer* renderer, float* initialArray)
+gfx::BufferResource* createStructuredBuffer(gfx::IRenderer* renderer, float* initialArray)
 {
     // Create a structured buffer for storing the data for computation
     //
@@ -151,7 +152,7 @@ gfx::BufferResource* createStructuredBuffer(gfx::Renderer* renderer, float* init
     return gStructuredBuffer;
 }
 
-gfx::DescriptorSetLayout* buildDescriptorSetLayout(gfx::Renderer* renderer)
+gfx::DescriptorSetLayout* 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
@@ -170,7 +171,7 @@ gfx::DescriptorSetLayout* buildDescriptorSetLayout(gfx::Renderer* renderer)
     return gDescriptorSetLayout;
 }
 
-gfx::PipelineLayout* buildPipeline(gfx::Renderer* renderer, gfx::DescriptorSetLayout* descriptorSetLayout)
+gfx::PipelineLayout* buildPipeline(gfx::IRenderer* renderer, gfx::DescriptorSetLayout* descriptorSetLayout)
 {
     // Next we will allocate a pipeline layout, which specifies
     // that we will render with only a single descriptor set bound.
@@ -190,7 +191,7 @@ gfx::PipelineLayout* buildPipeline(gfx::Renderer* renderer, gfx::DescriptorSetLa
 }
 
 gfx::DescriptorSet* buildDescriptorSet(
-    gfx::Renderer* renderer,
+    gfx::IRenderer* renderer,
     gfx::DescriptorSetLayout* descriptorSetLayout,
     gfx::BufferResource* structuredBuffer)
 {
@@ -213,7 +214,7 @@ gfx::DescriptorSet* buildDescriptorSet(
 
 gfx::PipelineState* buildPipelineState(
     gfx::ShaderProgram* shaderProgram,
-    gfx::Renderer* renderer,
+    gfx::IRenderer* renderer,
     gfx::PipelineLayout* pipelineLayout)
 {
     // Following the D3D12/Vulkan style of API, we need a pipeline state object
@@ -238,7 +239,7 @@ void printInitialValues(float* initialArray, int length)
 }
 
 void dispatchComputation(
-    gfx::Renderer* gRenderer,
+    gfx::IRenderer* gRenderer,
     gfx::PipelineState* gPipelineState,
     gfx::PipelineLayout* gPipelineLayout,
     gfx::DescriptorSet* gDescriptorSet,
@@ -254,7 +255,7 @@ void dispatchComputation(
 }
 
 void print_output(
-    gfx::Renderer* renderer,
+    gfx::IRenderer* renderer,
     gfx::BufferResource* structuredBuffer,
     int length)
 {
@@ -285,28 +286,28 @@ gfx_Renderer_0* createRenderer_0(int32_t _0, int32_t _1, gfx_Window_0* _2)
 
 gfx_BufferResource_0* createStructuredBuffer_0(gfx_Renderer_0* _0, FixedArray<float, 4> _1)
 {
-    return (gfx_BufferResource_0*)createStructuredBuffer((gfx::Renderer*)_0, (float*)&_1);
+    return (gfx_BufferResource_0*)createStructuredBuffer((gfx::IRenderer*)_0, (float*)&_1);
 }
 
 gfx_ShaderProgram_0* loadShaderProgram_0(gfx_Renderer_0* _0, unsigned char _1[], size_t _2)
 {
-    return (gfx_ShaderProgram_0*)loadShaderProgram((gfx::Renderer*)_0, _1, _2);
+    return (gfx_ShaderProgram_0*)loadShaderProgram((gfx::IRenderer*)_0, _1, _2);
 }
 
 gfx_DescriptorSetLayout_0* buildDescriptorSetLayout_0(gfx_Renderer_0* _0)
 {
-    return (gfx_DescriptorSetLayout_0*)buildDescriptorSetLayout((gfx::Renderer*)_0);
+    return (gfx_DescriptorSetLayout_0*)buildDescriptorSetLayout((gfx::IRenderer*)_0);
 }
 
 gfx_PipelineLayout_0* buildPipeline_0(gfx_Renderer_0* _0, gfx_DescriptorSetLayout_0* _1)
 {
-    return (gfx_PipelineLayout_0*)buildPipeline((gfx::Renderer*)_0, (gfx::DescriptorSetLayout*)_1);
+    return (gfx_PipelineLayout_0*)buildPipeline((gfx::IRenderer*)_0, (gfx::DescriptorSetLayout*)_1);
 }
 
 gfx_DescriptorSet_0* buildDescriptorSet_0(gfx_Renderer_0* _0, gfx_DescriptorSetLayout_0* _1, gfx_BufferResource_0* _2)
 {
     return (gfx_DescriptorSet_0*)buildDescriptorSet(
-        (gfx::Renderer*)_0,
+        (gfx::IRenderer*)_0,
         (gfx::DescriptorSetLayout*)_1,
         (gfx::BufferResource*)_2);
 }
@@ -314,8 +315,7 @@ gfx_DescriptorSet_0* buildDescriptorSet_0(gfx_Renderer_0* _0, gfx_DescriptorSetL
 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::Renderer*)_1,
+        (gfx::ShaderProgram*)_0, (gfx::IRenderer*)_1,
         (gfx::PipelineLayout*)_2);
 }
 
@@ -327,7 +327,7 @@ void printInitialValues_0(FixedArray<float, 4> _0, int32_t _1)
 void dispatchComputation_0(gfx_Renderer_0* _0, gfx_PipelineState_0* _1, gfx_PipelineLayout_0* _2, gfx_DescriptorSet_0* _3, unsigned int gridDimsX, unsigned int gridDimsY, unsigned int gridDimsZ)
 {
     dispatchComputation(
-        (gfx::Renderer*)_0,
+        (gfx::IRenderer*)_0,
         (gfx::PipelineState*)_1,
         (gfx::PipelineLayout*)_2,
         (gfx::DescriptorSet*)_3,
@@ -348,7 +348,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::Renderer*)_0, (gfx::BufferResource*)_1, _2);
+    print_output((gfx::IRenderer*)_0, (gfx::BufferResource*)_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 9507f2e2f..2dc7df3b5 100644
--- a/examples/model-viewer/main.cpp
+++ b/examples/model-viewer/main.cpp
@@ -12,7 +12,7 @@
 // We still need to include the Slang header to use the Slang API
 //
 #include <slang.h>
-
+#include "slang-com-helper.h"
 // We will again make use of a simple graphics API abstraction
 // layer, just to keep the examples short and to the point.
 //
@@ -67,7 +67,7 @@ struct ShaderModule : RefObject
 
     // Reference to the renderer, used to service requests
     // that load graphics API objects based on the module.
-    RefPtr<gfx::Renderer>       renderer;
+    Slang::ComPtr<gfx::IRenderer>       renderer;
 };
 //
 // In order to load a shader module from a `.slang` file on
@@ -78,7 +78,7 @@ struct ShaderModule : RefObject
 // example's `loadShaderProgram()` function, and how this function
 // loads a module for reflection purposes.
 //
-RefPtr<ShaderModule> loadShaderModule(Renderer* renderer, char const* inputPath)
+RefPtr<ShaderModule> loadShaderModule(IRenderer* renderer, char const* inputPath)
 {
     auto slangSession = getSlangSession();
     SlangCompileRequest* slangRequest = spCreateCompileRequest(slangSession);
@@ -361,7 +361,7 @@ struct ParameterBlockLayout : RefObject
     // The graphics API device that should be used to allocate parameter
     // block instances.
     //
-    RefPtr<gfx::Renderer>                renderer;
+    Slang::ComPtr<gfx::IRenderer> renderer;
 
     // The name of the type, as it appears in Slang code.
     //
@@ -640,7 +640,7 @@ struct ParameterBlockEncoder
 struct ParameterBlock : RefObject
 {
     // The graphics API device used to allocate this block.
-    RefPtr<gfx::Renderer>           renderer;
+    Slang::ComPtr<gfx::IRenderer>   renderer;
 
     // The associated parameter block layout.
     RefPtr<ParameterBlockLayout>    layout;
@@ -1100,7 +1100,7 @@ private:
     // Our current abstraction layer lumps this all together
     // with the "device."
     //
-    RefPtr<gfx::Renderer>               renderer;
+    Slang::ComPtr<gfx::IRenderer> renderer;
 
     // We also retain a pointer to the shader cache, which
     // will be used to implement lookup of the right
@@ -1165,7 +1165,7 @@ private:
 public:
     // Initializing a render context just sets its pointer to the GPU API device
     RenderContext(
-        gfx::Renderer*  renderer,
+        gfx::IRenderer*  renderer,
         ShaderCache*    shaderCache)
         : renderer(renderer)
         , shaderCache(shaderCache)
@@ -1386,7 +1386,7 @@ struct Model : RefObject
 // used for its representation.
 //
 RefPtr<Model> loadModel(
-    Renderer*               renderer,
+    IRenderer*               renderer,
     char const*             inputPath,
     ModelLoader::LoadFlags  loadFlags = 0,
     float                   scale = 1.0f)
@@ -1910,7 +1910,7 @@ struct LightEnv : public RefObject
 struct ModelViewer {
 
 Window* gWindow;
-RefPtr<gfx::Renderer> gRenderer;
+Slang::ComPtr<gfx::IRenderer> gRenderer;
 RefPtr<gfx::ResourceView> gDepthTarget;
 
 // We keep a pointer to the one effect we are using (for a forward
@@ -2050,8 +2050,8 @@ Result initialize()
     windowDesc.userData = this;
     gWindow = createWindow(windowDesc);
 
-    gRenderer = createD3D11Renderer();
-    Renderer::Desc rendererDesc;
+    createD3D11Renderer(gRenderer.writeRef());
+    IRenderer::Desc rendererDesc;
     rendererDesc.width = gWindowWidth;
     rendererDesc.height = gWindowHeight;
     gRenderer->initialize(rendererDesc, getPlatformWindowHandle(gWindow));
diff --git a/examples/shader-toy/main.cpp b/examples/shader-toy/main.cpp
index 403456036..89a40b794 100644
--- a/examples/shader-toy/main.cpp
+++ b/examples/shader-toy/main.cpp
@@ -88,7 +88,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::Renderer* renderer, RefPtr<gfx::ShaderProgram>& outShaderProgram)
+Result loadShaderProgram(gfx::IRenderer* renderer, RefPtr<gfx::ShaderProgram>& 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.
@@ -366,7 +366,7 @@ int gWindowHeight = 768;
 
 gfx::ApplicationContext*    gAppContext;
 gfx::Window*                gWindow;
-RefPtr<gfx::Renderer>       gRenderer;
+Slang::ComPtr<gfx::IRenderer> gRenderer;
 RefPtr<gfx::BufferResource> gConstantBuffer;
 
 RefPtr<gfx::PipelineLayout> gPipelineLayout;
@@ -385,8 +385,8 @@ Result initialize()
     windowDesc.userData = this;
     gWindow = createWindow(windowDesc);
 
-    gRenderer = createD3D11Renderer();
-    Renderer::Desc rendererDesc;
+    createD3D11Renderer(gRenderer.writeRef());
+    IRenderer::Desc rendererDesc;
     rendererDesc.width = gWindowWidth;
     rendererDesc.height = gWindowHeight;
     {
diff --git a/tools/gfx/cuda/render-cuda.cpp b/tools/gfx/cuda/render-cuda.cpp
index f12e8ee89..03bf41d38 100644
--- a/tools/gfx/cuda/render-cuda.cpp
+++ b/tools/gfx/cuda/render-cuda.cpp
@@ -1,11 +1,11 @@
 #include "render-cuda.h"
+#include "slang.h"
 
 #ifdef GFX_ENABLE_CUDA
 #include "../render.h"
 #include <cuda.h>
 #include <cuda_runtime_api.h>
 #include "core/slang-std-writers.h"
-#include "slang.h"
 #endif
 
 namespace gfx
@@ -13,6 +13,9 @@ namespace gfx
 #ifdef GFX_ENABLE_CUDA
 using namespace Slang;
 
+static const Guid IID_ISlangUnknown = SLANG_UUID_ISlangUnknown;
+static const Guid IID_IRenderer = SLANG_UUID_IRenderer;
+
 SLANG_FORCE_INLINE static bool _isError(CUresult result) { return result != 0; }
 SLANG_FORCE_INLINE static bool _isError(cudaError_t result) { return result != 0; }
 
@@ -414,9 +417,9 @@ public:
     List<RefPtr<CUDAShaderObject>> objects;
     List<RefPtr<CUDAResourceView>> resources;
 
-    virtual SlangResult init(Renderer* renderer, CUDAShaderObjectLayout* typeLayout);
+    virtual SlangResult init(IRenderer* renderer, CUDAShaderObjectLayout* typeLayout);
 
-    virtual SlangResult initBuffer(Renderer* renderer, size_t bufferSize)
+    virtual SlangResult initBuffer(IRenderer* renderer, size_t bufferSize)
     {
         BufferResource::Desc bufferDesc;
         bufferDesc.init(bufferSize);
@@ -536,7 +539,7 @@ public:
     void* hostBuffer = nullptr;
     size_t uniformBufferSize = 0;
     // Override buffer allocation so we store all uniform data on host memory instead of device memory.
-    virtual SlangResult initBuffer(Renderer* renderer, size_t bufferSize) override
+    virtual SlangResult initBuffer(IRenderer* renderer, size_t bufferSize) override
     {
         uniformBufferSize = bufferSize;
         hostBuffer = malloc(bufferSize);
@@ -573,14 +576,22 @@ class CUDARootShaderObject : public CUDAShaderObject
 {
 public:
     List<RefPtr<CUDAEntryPointShaderObject>> entryPointObjects;
-    virtual SlangResult init(Renderer* renderer, CUDAShaderObjectLayout* typeLayout) override;
+    virtual SlangResult init(IRenderer* renderer, CUDAShaderObjectLayout* typeLayout) override;
     virtual Slang::Index getEntryPointCount() override { return entryPointObjects.getCount(); }
     virtual ShaderObject* getEntryPoint(Slang::Index index) override { return entryPointObjects[index].Ptr(); }
 
 };
 
-class CUDARenderer : public Renderer
+class CUDARenderer : public IRenderer, public RefObject
 {
+public:
+    SLANG_REF_OBJECT_IUNKNOWN_ALL
+    IRenderer* getInterface(const Guid& guid)
+    {
+        return (guid == IID_ISlangUnknown || guid == IID_IRenderer) ? static_cast<IRenderer*>(this)
+                                                                    : nullptr;
+    }
+
 private:
     static const CUDAReportStyle reportType = CUDAReportStyle::Normal;
     static int _calcSMCountPerMultiProcessor(int major, int minor)
@@ -709,7 +720,7 @@ private:
             cuCtxDestroy(m_context);
         }
     }
-    virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) override
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL initialize(const Desc& desc, void* inWindowHandle) override
     {
         SLANG_RETURN_ON_FAIL(_initCuda(reportType));
 
@@ -728,7 +739,7 @@ private:
         return SLANG_OK;
     }
 
-    virtual Result createTextureResource(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
         Resource::Usage initialUsage,
         const TextureResource::Desc& desc,
         const TextureResource::Data* initData,
@@ -1096,7 +1107,7 @@ private:
         return SLANG_OK;
     }
 
-    virtual Result createBufferResource(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
         Resource::Usage initialUsage,
         const BufferResource::Desc& desc,
         const void* initData,
@@ -1112,7 +1123,7 @@ private:
         return SLANG_OK;
     }
 
-    virtual Result createTextureView(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView(
         TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override
     {
         RefPtr<CUDAResourceView> view = new CUDAResourceView();
@@ -1122,7 +1133,7 @@ private:
         return SLANG_OK;
     }
 
-    virtual Result createBufferView(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView(
         BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override
     {
         RefPtr<CUDAResourceView> view = new CUDAResourceView();
@@ -1132,7 +1143,7 @@ private:
         return SLANG_OK;
     }
 
-    virtual Result createShaderObjectLayout(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObjectLayout(
         slang::TypeLayoutReflection* typeLayout, ShaderObjectLayout** outLayout) override
     {
         RefPtr<CUDAShaderObjectLayout> cudaLayout;
@@ -1141,7 +1152,7 @@ private:
         return SLANG_OK;
     }
 
-    virtual Result createRootShaderObjectLayout(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObjectLayout(
         slang::ProgramLayout* layout, ShaderObjectLayout** outLayout) override
     {
         RefPtr<CUDAProgramLayout> cudaLayout;
@@ -1151,7 +1162,8 @@ private:
         return SLANG_OK;
     }
 
-    virtual Result createShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) override
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) override
     {
         RefPtr<CUDAShaderObject> result = new CUDAShaderObject();
         SLANG_RETURN_ON_FAIL(result->init(this, dynamic_cast<CUDAShaderObjectLayout*>(layout)));
@@ -1159,7 +1171,8 @@ private:
         return SLANG_OK;
     }
 
-    virtual Result createRootShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) override
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createRootShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) override
     {
         RefPtr<CUDARootShaderObject> result = new CUDARootShaderObject();
         SLANG_RETURN_ON_FAIL(result->init(this, dynamic_cast<CUDAShaderObjectLayout*>(layout)));
@@ -1167,7 +1180,8 @@ private:
         return SLANG_OK;
     }
 
-    virtual Result bindRootShaderObject(PipelineType pipelineType, ShaderObject* object) override
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindRootShaderObject(PipelineType pipelineType, ShaderObject* object) override
     {
         currentRootObject = dynamic_cast<CUDARootShaderObject*>(object);
         if (currentRootObject)
@@ -1175,7 +1189,8 @@ private:
         return SLANG_E_INVALID_ARG;
     }
 
-    virtual Result createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override
     {
         if (desc.kernelCount != 1)
             return SLANG_E_INVALID_ARG;
@@ -1188,7 +1203,8 @@ private:
         return SLANG_OK;
     }
 
-    virtual Result createComputePipelineState(const ComputePipelineStateDesc& desc, PipelineState** outState) override
+    virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
+        const ComputePipelineStateDesc& desc, PipelineState** outState) override
     {
         RefPtr<CUDAPipelineState> state = new CUDAPipelineState();
         state->shaderProgram = dynamic_cast<CUDAShaderProgram*>(desc.program);
@@ -1196,23 +1212,24 @@ private:
         return Result();
     }
 
-    virtual void* map(BufferResource* buffer, MapFlavor flavor) override
+    virtual SLANG_NO_THROW void* SLANG_MCALL map(BufferResource* buffer, MapFlavor flavor) override
     {
         return dynamic_cast<MemoryCUDAResource*>(buffer)->m_cudaMemory;
     }
 
-    virtual void unmap(BufferResource* buffer) override
+    virtual SLANG_NO_THROW void SLANG_MCALL unmap(BufferResource* buffer) override
     {
         SLANG_UNUSED(buffer);
     }
 
-    virtual void setPipelineState(PipelineType pipelineType, PipelineState* state) override
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setPipelineState(PipelineType pipelineType, PipelineState* state) override
     {
         SLANG_ASSERT(pipelineType == PipelineType::Compute);
         currentPipeline = dynamic_cast<CUDAPipelineState*>(state);
     }
 
-    virtual void dispatchCompute(int x, int y, int z) override
+    virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override
     {
         // Find out thread group size from program reflection.
         auto& kernelName = currentPipeline->shaderProgram->kernelName;
@@ -1240,7 +1257,7 @@ private:
 
             CUdeviceptr globalParamsCUDAData =
                 currentRootObject->bufferResource
-                    ? currentRootObject->bufferResource->getBindlessHandle()
+                    ? (CUdeviceptr)currentRootObject->bufferResource->getBindlessHandle()
                     : 0;
             cudaMemcpyAsync(
                 (void*)globalParamsSymbol,
@@ -1283,42 +1300,46 @@ private:
         SLANG_ASSERT(cudaLaunchResult == CUDA_SUCCESS);
     }
 
-    virtual void submitGpuWork() override {}
+    virtual SLANG_NO_THROW void SLANG_MCALL submitGpuWork() override {}
 
-    virtual void waitForGpu() override
+    virtual SLANG_NO_THROW void SLANG_MCALL waitForGpu() override
     {
         auto result = cudaDeviceSynchronize();
         SLANG_ASSERT(result == CUDA_SUCCESS);
     }
 
-    virtual RendererType getRendererType() const override { return RendererType::CUDA; }
+    virtual SLANG_NO_THROW RendererType SLANG_MCALL getRendererType() const override
+    {
+        return RendererType::CUDA;
+    }
 
 public:
     // Unused public interfaces. These functions are not supported on CUDA.
-    virtual const Slang::List<Slang::String>& getFeatures() override
+    virtual SLANG_NO_THROW const Slang::List<Slang::String>& SLANG_MCALL getFeatures() override
     {
         static Slang::List<Slang::String> featureSet;
         return featureSet;
     }
-    virtual void setClearColor(const float color[4]) override
+    virtual SLANG_NO_THROW void SLANG_MCALL setClearColor(const float color[4]) override
     {
         SLANG_UNUSED(color);
     }
-    virtual void clearFrame() override {}
-    virtual void presentFrame() override {}
-    virtual TextureResource::Desc getSwapChainTextureDesc() 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
     {
         return TextureResource::Desc();
     }
     
-    virtual Result createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override
     {
         SLANG_UNUSED(desc);
         *outSampler = nullptr;
         return SLANG_OK;
     }
     
-    virtual Result createInputLayout(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout(
         const InputElementDesc* inputElements,
         UInt inputElementCount,
         InputLayout** outLayout) override
@@ -1328,41 +1349,46 @@ public:
         SLANG_UNUSED(outLayout);
         return SLANG_E_NOT_AVAILABLE;
     }
-    virtual Result createDescriptorSetLayout(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout(
         const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override
     {
         SLANG_UNUSED(desc);
         SLANG_UNUSED(outLayout);
         return SLANG_E_NOT_AVAILABLE;
     }
-    virtual Result createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override
     {
         SLANG_UNUSED(desc);
         SLANG_UNUSED(outLayout);
         return SLANG_E_NOT_AVAILABLE;
     }
-    virtual Result createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override
     {
         SLANG_UNUSED(layout);
         SLANG_UNUSED(outDescriptorSet);
         return SLANG_E_NOT_AVAILABLE;
     }
-    virtual Result createGraphicsPipelineState(const GraphicsPipelineStateDesc& desc, PipelineState** outState) override
+    virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
+        const GraphicsPipelineStateDesc& desc, PipelineState** outState) override
     {
         SLANG_UNUSED(desc);
         SLANG_UNUSED(outState);
         return SLANG_E_NOT_AVAILABLE;
     }
-    virtual SlangResult captureScreenSurface(Surface& surfaceOut) override
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+        captureScreenSurface(Surface& surfaceOut) override
     {
         SLANG_UNUSED(surfaceOut);
         return SLANG_E_NOT_AVAILABLE;
     }
-    virtual void setPrimitiveTopology(PrimitiveTopology topology) override
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setPrimitiveTopology(PrimitiveTopology topology) override
     {
         SLANG_UNUSED(topology);
     }
-    virtual void setDescriptorSet(
+    virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet(
         PipelineType pipelineType,
         PipelineLayout* layout,
         UInt index,
@@ -1373,7 +1399,7 @@ public:
         SLANG_UNUSED(index);
         SLANG_UNUSED(descriptorSet);
     }
-    virtual void setVertexBuffers(
+    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
         UInt startSlot,
         UInt slotCount,
         BufferResource* const* buffers,
@@ -1386,32 +1412,37 @@ public:
         SLANG_UNUSED(strides);
         SLANG_UNUSED(offsets);
     }
-    virtual void setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset = 0) override
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset = 0) override
     {
         SLANG_UNUSED(buffer);
         SLANG_UNUSED(indexFormat);
         SLANG_UNUSED(offset);
     }
-    virtual void setDepthStencilTarget(ResourceView* depthStencilView) override
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setDepthStencilTarget(ResourceView* depthStencilView) override
     {
         SLANG_UNUSED(depthStencilView);
     }
-    virtual void setViewports(UInt count, Viewport const* viewports) override
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setViewports(UInt count, Viewport const* viewports) override
     {
         SLANG_UNUSED(count);
         SLANG_UNUSED(viewports);
     }
-    virtual void setScissorRects(UInt count, ScissorRect const* rects) override
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setScissorRects(UInt count, ScissorRect const* rects) override
     {
         SLANG_UNUSED(count);
         SLANG_UNUSED(rects);
     }
-    virtual void draw(UInt vertexCount, UInt startVertex) override
+    virtual SLANG_NO_THROW void SLANG_MCALL draw(UInt vertexCount, UInt startVertex) override
     {
         SLANG_UNUSED(vertexCount);
         SLANG_UNUSED(startVertex);
     }
-    virtual void drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override
     {
         SLANG_UNUSED(indexCount);
         SLANG_UNUSED(startIndex);
@@ -1419,7 +1450,7 @@ public:
     }
 };
 
-SlangResult CUDAShaderObject::init(Renderer* renderer, CUDAShaderObjectLayout* typeLayout)
+SlangResult CUDAShaderObject::init(IRenderer* renderer, CUDAShaderObjectLayout* typeLayout)
 {
     this->layout = typeLayout;
     
@@ -1477,7 +1508,7 @@ SlangResult CUDAShaderObject::init(Renderer* renderer, CUDAShaderObjectLayout* t
     return SLANG_OK;
 }
 
-SlangResult CUDARootShaderObject::init(Renderer* renderer, CUDAShaderObjectLayout* typeLayout)
+SlangResult CUDARootShaderObject::init(IRenderer* renderer, CUDAShaderObjectLayout* typeLayout)
 {
     SLANG_RETURN_ON_FAIL(CUDAShaderObject::init(renderer, typeLayout));
     auto programLayout = dynamic_cast<CUDAProgramLayout*>(typeLayout);
@@ -1490,9 +1521,18 @@ SlangResult CUDARootShaderObject::init(Renderer* renderer, CUDAShaderObjectLayou
     return SLANG_OK;
 }
 
-Renderer* createCUDARenderer() { return new CUDARenderer(); }
+SlangResult createCUDARenderer(IRenderer** outRenderer)
+{
+    *outRenderer = new CUDARenderer();
+    (*outRenderer)->addRef();
+    return SLANG_OK;
+}
 #else
-Renderer* createCUDARenderer() { return nullptr; }
+SlangResult createCUDARenderer(IRenderer** outRenderer)
+{
+    *outRenderer = nullptr;
+    return SLANG_OK;
+}
 #endif
 
 }
diff --git a/tools/gfx/cuda/render-cuda.h b/tools/gfx/cuda/render-cuda.h
index cf63113c8..3b403287a 100644
--- a/tools/gfx/cuda/render-cuda.h
+++ b/tools/gfx/cuda/render-cuda.h
@@ -1,8 +1,10 @@
 #pragma once
 
+#include <cstdint>
+
 namespace gfx
 {
-class Renderer;
+class IRenderer;
 
-Renderer* createCUDARenderer();
+int32_t createCUDARenderer(IRenderer** outRenderer);
 }
diff --git a/tools/gfx/d3d11/render-d3d11.cpp b/tools/gfx/d3d11/render-d3d11.cpp
index 5c04eccf1..97d294e5d 100644
--- a/tools/gfx/d3d11/render-d3d11.cpp
+++ b/tools/gfx/d3d11/render-d3d11.cpp
@@ -63,50 +63,93 @@ public:
 
     
     // Renderer    implementation
-    virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) override;
-    virtual const List<String>& getFeatures() override { return m_features; }
-    virtual void setClearColor(const float color[4]) override;
-    virtual void clearFrame() override;
-    virtual void presentFrame() override;
-    TextureResource::Desc getSwapChainTextureDesc() override;
-
-    Result createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& desc, const TextureResource::Data* initData, TextureResource** outResource) override;
-    Result createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& desc, const void* initData, BufferResource** outResource) override;
-    Result createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override;
-
-    Result createTextureView(TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override;
-    Result createBufferView(BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override;
-
-    Result createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount, InputLayout** outLayout) override;
-
-    Result createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override;
-    Result createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override;
-    Result createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override;
-
-    Result createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override;
-    Result createGraphicsPipelineState(const GraphicsPipelineStateDesc& desc, PipelineState** outState) override;
-    Result createComputePipelineState(const ComputePipelineStateDesc& desc, PipelineState** outState) override;
-
-    virtual SlangResult captureScreenSurface(Surface& surfaceOut) override;
-
-    virtual void* map(BufferResource* buffer, MapFlavor flavor) override;
-    virtual void unmap(BufferResource* buffer) override;
-    virtual void setPrimitiveTopology(PrimitiveTopology topology) override;
-
-    virtual void setDescriptorSet(PipelineType pipelineType, PipelineLayout* layout, UInt index, DescriptorSet* descriptorSet) override;
-
-    virtual void setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource*const* buffers, const UInt* strides,  const UInt* offsets) override;
-    virtual void setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override;
-    virtual void setDepthStencilTarget(ResourceView* depthStencilView) override;
-    void setViewports(UInt count, Viewport const* viewports) override;
-    void setScissorRects(UInt count, ScissorRect const* rects) override;
-    virtual void setPipelineState(PipelineType pipelineType, PipelineState* state) override;
-    virtual void draw(UInt vertexCount, UInt startVertex) override;
-    virtual void drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override;
-    virtual void dispatchCompute(int x, int y, int z) override;
-    virtual void submitGpuWork() override {}
-    virtual void waitForGpu() override {}
-    virtual RendererType getRendererType() const override { return RendererType::DirectX11; }
+    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;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
+        Resource::Usage initialUsage,
+        const BufferResource::Desc& desc,
+        const void* initData,
+        BufferResource** outResource) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView(
+        TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView(
+        BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout(
+        const InputElementDesc* inputElements,
+        UInt inputElementCount,
+        InputLayout** outLayout) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout(
+        const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
+        const GraphicsPipelineStateDesc& desc, PipelineState** outState) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
+        const ComputePipelineStateDesc& desc, PipelineState** 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
+        setPrimitiveTopology(PrimitiveTopology topology) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet(
+        PipelineType pipelineType,
+        PipelineLayout* layout,
+        UInt index,
+        DescriptorSet* descriptorSet) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
+        UInt startSlot,
+        UInt slotCount,
+        BufferResource* const* buffers,
+        const UInt* strides,
+        const UInt* offsets) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setDepthStencilTarget(ResourceView* 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;
+    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;
+    virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL submitGpuWork() override {}
+    virtual SLANG_NO_THROW void SLANG_MCALL waitForGpu() override {}
+    virtual SLANG_NO_THROW RendererType SLANG_MCALL getRendererType() const override
+    {
+        return RendererType::DirectX11;
+    }
 
     ~D3D11Renderer() {}
 
@@ -417,9 +460,11 @@ public:
     bool m_nvapi = false;
 };
 
-Renderer* createD3D11Renderer()
+SlangResult createD3D11Renderer(IRenderer** outRenderer)
 {
-    return new D3D11Renderer();
+    *outRenderer = new D3D11Renderer();
+    (*outRenderer)->addRef();
+    return SLANG_OK;
 }
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!ScopeNVAPI !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
diff --git a/tools/gfx/d3d11/render-d3d11.h b/tools/gfx/d3d11/render-d3d11.h
index 9e671d541..63b4818ce 100644
--- a/tools/gfx/d3d11/render-d3d11.h
+++ b/tools/gfx/d3d11/render-d3d11.h
@@ -1,10 +1,12 @@
 // render-d3d11.h
 #pragma once
 
+#include <cstdint>
+
 namespace gfx {
 
-class Renderer;
+class IRenderer;
 
-Renderer* createD3D11Renderer();
+int32_t createD3D11Renderer(IRenderer** outRenderer);
 
 } // gfx
diff --git a/tools/gfx/d3d12/render-d3d12.cpp b/tools/gfx/d3d12/render-d3d12.cpp
index 0376ee304..c533fe1fd 100644
--- a/tools/gfx/d3d12/render-d3d12.cpp
+++ b/tools/gfx/d3d12/render-d3d12.cpp
@@ -66,51 +66,93 @@ class D3D12Renderer : public GraphicsAPIRenderer
 {
 public:
     // Renderer    implementation
-    virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) override;
-    virtual const List<String>& getFeatures() override { return m_features; }
-    virtual void setClearColor(const float color[4]) override;
-    virtual void clearFrame() override;
-    virtual void presentFrame() override;
-    TextureResource::Desc getSwapChainTextureDesc() override;
-
-    Result createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& desc, const TextureResource::Data* initData, TextureResource** outResource) override;
-    Result createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& desc, const void* initData, BufferResource** outResource) override;
-    Result createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override;
-
-    Result createTextureView(TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override;
-    Result createBufferView(BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override;
-
-    Result createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount, InputLayout** outLayout) override;
-
-    Result createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override;
-    Result createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override;
-    Result createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override;
-
-    Result createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override;
-    Result createGraphicsPipelineState(const GraphicsPipelineStateDesc& desc, PipelineState** outState) override;
-    Result createComputePipelineState(const ComputePipelineStateDesc& desc, PipelineState** outState) override;
-
-    virtual SlangResult captureScreenSurface(Surface& surfaceOut) override;
-
-    virtual void* map(BufferResource* buffer, MapFlavor flavor) override;
-    virtual void unmap(BufferResource* buffer) override;
-//    virtual void setInputLayout(InputLayout* inputLayout) override;
-    virtual void setPrimitiveTopology(PrimitiveTopology topology) override;
-
-    virtual void setDescriptorSet(PipelineType pipelineType, PipelineLayout* layout, UInt index, DescriptorSet* descriptorSet) override;
-
-    virtual void setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource*const* buffers, const UInt* strides, const UInt* offsets) override;
-    virtual void setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override;
-    virtual void setDepthStencilTarget(ResourceView* depthStencilView) override;
-    void setViewports(UInt count, Viewport const* viewports) override;
-    void setScissorRects(UInt count, ScissorRect const* rects) override;
-    virtual void setPipelineState(PipelineType pipelineType, PipelineState* state) override;
-    virtual void draw(UInt vertexCount, UInt startVertex) override;
-    virtual void drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override;
-    virtual void dispatchCompute(int x, int y, int z) override;
-    virtual void submitGpuWork() override;
-    virtual void waitForGpu() override;
-    virtual RendererType getRendererType() const override { return RendererType::DirectX12; }
+    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;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
+        Resource::Usage initialUsage,
+        const BufferResource::Desc& desc,
+        const void* initData,
+        BufferResource** outResource) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView(
+        TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView(
+        BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout(
+        const InputElementDesc* inputElements,
+        UInt inputElementCount,
+        InputLayout** outLayout) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout(
+        const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
+        const GraphicsPipelineStateDesc& desc, PipelineState** outState) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
+        const ComputePipelineStateDesc& desc, PipelineState** 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 void setInputLayout(InputLayout* inputLayout) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setPrimitiveTopology(PrimitiveTopology topology) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet(
+        PipelineType pipelineType,
+        PipelineLayout* layout,
+        UInt index,
+        DescriptorSet* descriptorSet) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
+        UInt startSlot,
+        UInt slotCount,
+        BufferResource* const* buffers,
+        const UInt* strides,
+        const UInt* offsets) override;
+    virtual SLANG_NO_THROW void
+        SLANG_MCALL setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override;
+    virtual void SLANG_MCALL setDepthStencilTarget(ResourceView* 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;
+    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;
+    virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL submitGpuWork() override;
+    virtual SLANG_NO_THROW void SLANG_MCALL waitForGpu() override;
+    virtual SLANG_NO_THROW RendererType SLANG_MCALL getRendererType() const override
+    {
+        return RendererType::DirectX12;
+    }
 
     ~D3D12Renderer();
 
@@ -706,9 +748,11 @@ protected:
     bool m_nvapi = false;
 };
 
-Renderer* createD3D12Renderer()
+SlangResult createD3D12Renderer(IRenderer** outRenderer)
 {
-    return new D3D12Renderer;
+    *outRenderer = new D3D12Renderer();
+    (*outRenderer)->addRef();
+    return SLANG_OK;
 }
 
 /* static */PROC D3D12Renderer::loadProc(HMODULE module, char const* name)
diff --git a/tools/gfx/d3d12/render-d3d12.h b/tools/gfx/d3d12/render-d3d12.h
index b8a3104c0..cdbbc3996 100644
--- a/tools/gfx/d3d12/render-d3d12.h
+++ b/tools/gfx/d3d12/render-d3d12.h
@@ -1,10 +1,12 @@
 // render-d3d12.h
 #pragma once
 
+#include <cstdint>
+
 namespace gfx {
 
-class Renderer;
+class IRenderer;
 
-Renderer* createD3D12Renderer();
+int32_t createD3D12Renderer(IRenderer** outRenderer);
 
 } // gfx
diff --git a/tools/gfx/open-gl/render-gl.cpp b/tools/gfx/open-gl/render-gl.cpp
index 8be8165aa..4874c4c69 100644
--- a/tools/gfx/open-gl/render-gl.cpp
+++ b/tools/gfx/open-gl/render-gl.cpp
@@ -82,50 +82,93 @@ class GLRenderer : public GraphicsAPIRenderer
 public:
 
     // Renderer    implementation
-    virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) override;
-    virtual const List<String>& getFeatures() override { return m_features; }
-    virtual void setClearColor(const float color[4]) override;
-    virtual void clearFrame() override;
-    virtual void presentFrame() override;
-    TextureResource::Desc getSwapChainTextureDesc() override;
-
-    Result createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& desc, const TextureResource::Data* initData, TextureResource** outResource) override;
-    Result createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& desc, const void* initData, BufferResource** outResource) override;
-    Result createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override;
-
-    Result createTextureView(TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override;
-    Result createBufferView(BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override;
-
-    Result createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount, InputLayout** outLayout) override;
-
-    Result createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override;
-    Result createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override;
-    Result createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override;
-
-    Result createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override;
-    Result createGraphicsPipelineState(const GraphicsPipelineStateDesc& desc, PipelineState** outState) override;
-    Result createComputePipelineState(const ComputePipelineStateDesc& desc, PipelineState** outState) override;
-
-    virtual SlangResult captureScreenSurface(Surface& surfaceOut) override;
-
-    virtual void* map(BufferResource* buffer, MapFlavor flavor) override;
-    virtual void unmap(BufferResource* buffer) override;
-    virtual void setPrimitiveTopology(PrimitiveTopology topology) override;
-
-    virtual void setDescriptorSet(PipelineType pipelineType, PipelineLayout* layout, UInt index, DescriptorSet* descriptorSet) override;
-
-    virtual void setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource*const* buffers, const UInt* strides, const UInt* offsets) override;
-    virtual void setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override;
-    virtual void setDepthStencilTarget(ResourceView* depthStencilView) override;
-    void setViewports(UInt count, Viewport const* viewports) override;
-    void setScissorRects(UInt count, ScissorRect const* rects) override;
-    virtual void setPipelineState(PipelineType pipelineType, PipelineState* state) override;
-    virtual void draw(UInt vertexCount, UInt startVertex) override;
-    virtual void drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override;
-    virtual void dispatchCompute(int x, int y, int z) override;
-    virtual void submitGpuWork() override {}
-    virtual void waitForGpu() override {}
-    virtual RendererType getRendererType() const override { return RendererType::OpenGl; }
+    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;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
+        Resource::Usage initialUsage,
+        const BufferResource::Desc& desc,
+        const void* initData,
+        BufferResource** outResource) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView(
+        TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView(
+        BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout(
+        const InputElementDesc* inputElements,
+        UInt inputElementCount,
+        InputLayout** outLayout) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout(
+        const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
+        const GraphicsPipelineStateDesc& desc, PipelineState** outState) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
+        const ComputePipelineStateDesc& desc, PipelineState** 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
+        setPrimitiveTopology(PrimitiveTopology topology) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet(
+        PipelineType pipelineType,
+        PipelineLayout* layout,
+        UInt index,
+        DescriptorSet* descriptorSet) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
+        UInt startSlot,
+        UInt slotCount,
+        BufferResource* const* buffers,
+        const UInt* strides,
+        const UInt* offsets) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setDepthStencilTarget(ResourceView* 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;
+    virtual SLANG_NO_THROW void SLANG_MCALL draw(UInt vertexCount, UInt startVertex) override;
+    virtual void SLANG_MCALL
+        drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL submitGpuWork() override {}
+    virtual SLANG_NO_THROW void SLANG_MCALL waitForGpu() override {}
+    virtual SLANG_NO_THROW RendererType SLANG_MCALL getRendererType() const override
+    {
+        return RendererType::OpenGl;
+    }
 
     GLRenderer();
     ~GLRenderer();
@@ -395,9 +438,11 @@ public:
     SLANG_COMPILE_TIME_ASSERT(SLANG_COUNT_OF(s_pixelFormatInfos) == int(GlPixelFormat::CountOf));
 }
 
-Renderer* createGLRenderer()
+SlangResult createGLRenderer(IRenderer** outRenderer)
 {
-    return new GLRenderer();
+    *outRenderer = new GLRenderer();
+    (*outRenderer)->addRef();
+    return SLANG_OK;
 }
 
 void GLRenderer::debugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message)
diff --git a/tools/gfx/open-gl/render-gl.h b/tools/gfx/open-gl/render-gl.h
index 055031d38..04a6eaa9f 100644
--- a/tools/gfx/open-gl/render-gl.h
+++ b/tools/gfx/open-gl/render-gl.h
@@ -1,10 +1,12 @@
 // render-d3d11.h
 #pragma once
 
+#include <cstdint>
+
 namespace gfx {
 
-class Renderer;
+class IRenderer;
 
-Renderer* createGLRenderer();
+int32_t createGLRenderer(IRenderer** outRenderer);
 
 } // gfx
diff --git a/tools/gfx/render-graphics-common.cpp b/tools/gfx/render-graphics-common.cpp
index d3d469fc2..beaa6a55c 100644
--- a/tools/gfx/render-graphics-common.cpp
+++ b/tools/gfx/render-graphics-common.cpp
@@ -4,6 +4,9 @@ using namespace Slang;
 namespace gfx
 {
 
+static const Slang::Guid IID_ISlangUnknown = SLANG_UUID_ISlangUnknown;
+static const Slang::Guid IID_IRenderer = SLANG_UUID_IRenderer;
+
 gfx::StageType translateStage(SlangStage slangStage)
 {
     switch (slangStage)
@@ -65,7 +68,7 @@ public:
     struct Builder
     {
     public:
-        Builder(Renderer* renderer)
+        Builder(IRenderer* renderer)
             : m_renderer(renderer)
         {}
 
@@ -339,12 +342,12 @@ public:
             return SLANG_OK;
         }
 
-        Renderer* m_renderer = nullptr;
+        IRenderer* m_renderer = nullptr;
         slang::TypeLayoutReflection* m_elementTypeLayout = nullptr;
     };
 
     static Result createForElementType(
-        Renderer* renderer,
+        IRenderer* renderer,
         slang::TypeLayoutReflection* elementType,
         GraphicsCommonShaderObjectLayout** outLayout)
     {
@@ -371,7 +374,7 @@ public:
     SubObjectRangeInfo const& getSubObjectRange(Index index) { return m_subObjectRanges[index]; }
     List<SubObjectRangeInfo> const& getSubObjectRanges() { return m_subObjectRanges; }
 
-    Renderer* getRenderer() { return m_renderer; }
+    IRenderer* getRenderer() { return m_renderer; }
 
 protected:
     Result _init(Builder const* builder)
@@ -410,7 +413,7 @@ protected:
         return SLANG_OK;
     }
 
-    Renderer* m_renderer;
+    IRenderer* m_renderer;
     List<RefPtr<DescriptorSetInfo>> m_descriptorSets;
     List<BindingRangeInfo> m_bindingRanges;
     slang::TypeLayoutReflection* m_elementTypeLayout;
@@ -434,7 +437,7 @@ public:
 
     struct Builder : Super::Builder
     {
-        Builder(Renderer* renderer)
+        Builder(IRenderer* renderer)
             : Super::Builder(renderer)
         {}
 
@@ -539,7 +542,7 @@ public:
 
     struct Builder : Super::Builder
     {
-        Builder(Renderer* renderer)
+        Builder(IRenderer* renderer)
             : Super::Builder(renderer)
         {}
 
@@ -670,7 +673,7 @@ class GraphicsCommonShaderObject : public ShaderObject
 {
 public:
     static Result create(
-        Renderer* renderer,
+        IRenderer* renderer,
         GraphicsCommonShaderObjectLayout* layout,
         GraphicsCommonShaderObject** outShaderObject)
     {
@@ -681,7 +684,7 @@ public:
         return SLANG_OK;
     }
 
-    Renderer* getRenderer() { return m_layout->getRenderer(); }
+    IRenderer* getRenderer() { return m_layout->getRenderer(); }
 
     Index getEntryPointCount() { return 0; }
 
@@ -693,7 +696,7 @@ public:
 
     SlangResult setData(ShaderOffset const& offset, void const* data, size_t size)
     {
-        Renderer* renderer = getRenderer();
+        IRenderer* renderer = getRenderer();
 
         char* dest = (char*)renderer->map(m_buffer, MapFlavor::HostWrite);
         memcpy(dest + offset.uniformOffset, data, size);
@@ -807,7 +810,7 @@ public:
 protected:
     friend class ProgramVars;
 
-    Result init(Renderer* renderer, GraphicsCommonShaderObjectLayout* layout)
+    Result init(IRenderer* renderer, GraphicsCommonShaderObjectLayout* layout)
     {
         m_layout = layout;
 
@@ -883,7 +886,7 @@ protected:
     }
 
     Result apply(
-        Renderer* renderer,
+        IRenderer* renderer,
         PipelineType pipelineType,
         PipelineLayout* pipelineLayout,
         Index& ioRootIndex)
@@ -1093,7 +1096,7 @@ class EntryPointVars : public GraphicsCommonShaderObject
 
 public:
     static Result
-    create(Renderer* renderer, EntryPointLayout* layout, EntryPointVars** outShaderObject)
+    create(IRenderer* renderer, EntryPointLayout* layout, EntryPointVars** outShaderObject)
     {
         RefPtr<EntryPointVars> object = new EntryPointVars();
         SLANG_RETURN_ON_FAIL(object->init(renderer, layout));
@@ -1105,7 +1108,7 @@ public:
     EntryPointLayout* getLayout() { return static_cast<EntryPointLayout*>(m_layout.Ptr()); }
 
 protected:
-    Result init(Renderer* renderer, EntryPointLayout* layout)
+    Result init(IRenderer* renderer, EntryPointLayout* layout)
     {
         SLANG_RETURN_ON_FAIL(Super::init(renderer, layout));
         return SLANG_OK;
@@ -1117,7 +1120,7 @@ class ProgramVars : public GraphicsCommonShaderObject
     typedef GraphicsCommonShaderObject Super;
 
 public:
-    static Result create(Renderer* renderer, GraphicsCommonProgramLayout* layout, ProgramVars** outShaderObject)
+    static Result create(IRenderer* renderer, GraphicsCommonProgramLayout* layout, ProgramVars** outShaderObject)
     {
         RefPtr<ProgramVars> object = new ProgramVars();
         SLANG_RETURN_ON_FAIL(object->init(renderer, layout));
@@ -1128,7 +1131,7 @@ public:
 
     GraphicsCommonProgramLayout* getLayout() { return static_cast<GraphicsCommonProgramLayout*>(m_layout.Ptr()); }
 
-    void apply(Renderer* renderer, PipelineType pipelineType)
+    void apply(IRenderer* renderer, PipelineType pipelineType)
     {
         auto pipelineLayout = getLayout()->getPipelineLayout();
 
@@ -1177,7 +1180,7 @@ protected:
         return SLANG_OK;
     }
 
-    Result init(Renderer* renderer, GraphicsCommonProgramLayout* layout)
+    Result init(IRenderer* renderer, GraphicsCommonProgramLayout* layout)
     {
         SLANG_RETURN_ON_FAIL(Super::init(renderer, layout));
 
@@ -1286,4 +1289,11 @@ void GraphicsAPIRenderer::preparePipelineDesc(ComputePipelineStateDesc& desc)
     }
 }
 
+IRenderer* gfx::GraphicsAPIRenderer::getInterface(const Guid& guid)
+{
+    return (guid == IID_ISlangUnknown || guid == IID_IRenderer)
+               ? static_cast<IRenderer*>(this)
+               : nullptr;
+}
+
 }
diff --git a/tools/gfx/render-graphics-common.h b/tools/gfx/render-graphics-common.h
index 5bb4cb59e..af2677905 100644
--- a/tools/gfx/render-graphics-common.h
+++ b/tools/gfx/render-graphics-common.h
@@ -5,18 +5,20 @@
 namespace gfx
 {
 
-class GraphicsAPIRenderer : public Renderer
+class GraphicsAPIRenderer : public IRenderer, public Slang::RefObject
 {
 public:
-    virtual Result createShaderObjectLayout(
+    SLANG_REF_OBJECT_IUNKNOWN_ALL
+    virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObjectLayout(
         slang::TypeLayoutReflection* typeLayout, ShaderObjectLayout** outLayout) SLANG_OVERRIDE;
-    virtual Result createRootShaderObjectLayout(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObjectLayout(
         slang::ProgramLayout* programLayout, ShaderObjectLayout** outLayout) SLANG_OVERRIDE;
-    virtual Result createShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) SLANG_OVERRIDE;
-    virtual Result createRootShaderObject(ShaderObjectLayout* rootLayout, ShaderObject** outObject) SLANG_OVERRIDE;
-    virtual Result bindRootShaderObject(PipelineType pipelineType,  ShaderObject* object) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObject(ShaderObjectLayout* rootLayout, ShaderObject** outObject) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW Result SLANG_MCALL bindRootShaderObject(PipelineType pipelineType, ShaderObject* object) SLANG_OVERRIDE;
     void preparePipelineDesc(GraphicsPipelineStateDesc& desc);
     void preparePipelineDesc(ComputePipelineStateDesc& desc);
+    IRenderer* getInterface(const Slang::Guid& guid);
 };
 
 }
diff --git a/tools/gfx/render.h b/tools/gfx/render.h
index ab9af8afb..bcba27dc5 100644
--- a/tools/gfx/render.h
+++ b/tools/gfx/render.h
@@ -852,7 +852,7 @@ struct Viewport
     float maxZ    = 1.0f;
 };
 
-class Renderer: public Slang::RefObject
+class IRenderer: public ISlangUnknown
 {
 public:
 
@@ -866,23 +866,30 @@ public:
     };
 
         // Will return with SLANG_E_NOT_AVAILABLE if NVAPI can't be initialized and nvapiExtnSlot >= 0
-    virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) = 0;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL initialize(const Desc& desc, void* inWindowHandle) = 0;
 
     bool hasFeature(const Slang::UnownedStringSlice& feature) { return getFeatures().indexOf(Slang::String(feature)) != Slang::Index(-1); }
-    virtual const Slang::List<Slang::String>& getFeatures() = 0;
+    virtual SLANG_NO_THROW const Slang::List<Slang::String>& SLANG_MCALL getFeatures() = 0;
 
-    virtual void setClearColor(const float color[4]) = 0;
-    virtual void clearFrame() = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL setClearColor(const float color[4]) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL clearFrame() = 0;
 
-    virtual void presentFrame() = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL presentFrame() = 0;
 
-    virtual TextureResource::Desc getSwapChainTextureDesc() = 0;
+    virtual SLANG_NO_THROW TextureResource::Desc SLANG_MCALL getSwapChainTextureDesc() = 0;
 
         /// Create a texture resource. initData holds the initialize data to set the contents of the texture when constructed.
-    virtual Result createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& desc, const TextureResource::Data* initData, TextureResource** outResource) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
+        Resource::Usage initialUsage,
+        const TextureResource::Desc& desc,
+        const TextureResource::Data* initData,
+        TextureResource** outResource) = 0;
 
         /// Create a texture resource. initData holds the initialize data to set the contents of the texture when constructed.
-    inline RefPtr<TextureResource> createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& desc, const TextureResource::Data* initData = nullptr)
+    inline SLANG_NO_THROW RefPtr<TextureResource> SLANG_MCALL createTextureResource(
+        Resource::Usage initialUsage,
+        const TextureResource::Desc& desc,
+        const TextureResource::Data* initData = nullptr)
     {
         RefPtr<TextureResource> resource;
         SLANG_RETURN_NULL_ON_FAIL(createTextureResource(initialUsage, desc, initData, resource.writeRef()));
@@ -890,16 +897,23 @@ public:
     }
 
         /// Create a buffer resource
-    virtual Result createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& desc, const void* initData, BufferResource** outResource) = 0;
-
-    inline RefPtr<BufferResource> createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& desc, const void* initData = nullptr)
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
+        Resource::Usage initialUsage,
+        const BufferResource::Desc& desc,
+        const void* initData,
+        BufferResource** outResource) = 0;
+
+    inline SLANG_NO_THROW RefPtr<BufferResource> SLANG_MCALL createBufferResource(
+        Resource::Usage initialUsage,
+        const BufferResource::Desc& desc,
+        const void* initData = nullptr)
     {
         RefPtr<BufferResource> resource;
         SLANG_RETURN_NULL_ON_FAIL(createBufferResource(initialUsage, desc, initData, resource.writeRef()));
         return resource;
     }
 
-    virtual Result createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) = 0;
 
     inline RefPtr<SamplerState> createSamplerState(SamplerState::Desc const& desc)
     {
@@ -908,7 +922,8 @@ public:
         return sampler;
     }
 
-    virtual Result createTextureView(TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView(
+        TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) = 0;
 
     inline RefPtr<ResourceView> createTextureView(TextureResource* texture, ResourceView::Desc const& desc)
     {
@@ -917,7 +932,8 @@ public:
         return view;
     }
 
-    virtual Result createBufferView(BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView(
+        BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) = 0;
 
     inline RefPtr<ResourceView> createBufferView(BufferResource* buffer, ResourceView::Desc const& desc)
     {
@@ -926,7 +942,8 @@ public:
         return view;
     }
 
-    virtual Result createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount, InputLayout** outLayout) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout(
+        const InputElementDesc* inputElements, UInt inputElementCount, InputLayout** outLayout) = 0;
 
     inline RefPtr<InputLayout> createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount)
     {
@@ -935,7 +952,8 @@ public:
         return layout;
     }
 
-    virtual Result createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout(
+        const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) = 0;
 
     inline RefPtr<DescriptorSetLayout> createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc)
     {
@@ -944,7 +962,7 @@ public:
         return layout;
     }
 
-    virtual Result createShaderObjectLayout(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObjectLayout(
         slang::TypeLayoutReflection* typeLayout, ShaderObjectLayout** outLayout) = 0;
 
     inline RefPtr<ShaderObjectLayout> createShaderObjectLayout(slang::TypeLayoutReflection* typeLayout)
@@ -954,7 +972,7 @@ public:
         return layout;
     }
 
-    virtual Result createRootShaderObjectLayout(slang::ProgramLayout* layout, ShaderObjectLayout** outLayout) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObjectLayout(slang::ProgramLayout* layout, ShaderObjectLayout** outLayout) = 0;
 
     inline RefPtr<ShaderObjectLayout> createRootShaderObjectLayout(slang::ProgramLayout* layout)
     {
@@ -963,7 +981,7 @@ public:
         return result;
     }
 
-    virtual Result createShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) = 0;
 
     inline RefPtr<ShaderObject> createShaderObject(ShaderObjectLayout* layout)
     {
@@ -972,7 +990,7 @@ public:
         return object;
     }
 
-    virtual Result createRootShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) = 0;
 
     inline RefPtr<ShaderObject> createRootShaderObject(ShaderObjectLayout* layout)
     {
@@ -981,9 +999,9 @@ public:
         return object;
     }
 
-    virtual Result bindRootShaderObject(PipelineType pipelineType, ShaderObject* object) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL bindRootShaderObject(PipelineType pipelineType, ShaderObject* object) = 0;
 
-    virtual Result createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) = 0;
 
     inline RefPtr<PipelineLayout> createPipelineLayout(const PipelineLayout::Desc& desc)
     {
@@ -992,7 +1010,7 @@ public:
         return layout;
     }
 
-    virtual Result createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) = 0;
 
     inline RefPtr<DescriptorSet> createDescriptorSet(DescriptorSetLayout* layout)
     {
@@ -1001,7 +1019,7 @@ public:
         return descriptorSet;
     }
 
-    virtual Result createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) = 0;
 
     inline RefPtr<ShaderProgram> createProgram(const ShaderProgram::Desc& desc)
     {
@@ -1010,7 +1028,7 @@ public:
         return program;
     }
 
-    virtual Result createGraphicsPipelineState(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
         const GraphicsPipelineStateDesc&    desc,
         PipelineState**                     outState) = 0;
 
@@ -1022,7 +1040,7 @@ public:
         return state;
     }
 
-    virtual Result createComputePipelineState(
+    virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
         const ComputePipelineStateDesc&    desc,
         PipelineState**                     outState) = 0;
 
@@ -1035,53 +1053,67 @@ public:
     }
 
         /// Captures the back buffer and stores the result in surfaceOut. If the surface contains data - it will either be overwritten (if same size and format), or freed and a re-allocated.
-    virtual SlangResult captureScreenSurface(Surface& surfaceOut) = 0;
-
-    virtual void* map(BufferResource* buffer, MapFlavor flavor) = 0;
-    virtual void unmap(BufferResource* buffer) = 0;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL captureScreenSurface(Surface& surfaceOut) = 0;
 
-    virtual void setPrimitiveTopology(PrimitiveTopology topology) = 0;
+    virtual SLANG_NO_THROW void* SLANG_MCALL map(BufferResource* buffer, MapFlavor flavor) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL unmap(BufferResource* buffer) = 0;
 
-    virtual void setDescriptorSet(PipelineType pipelineType, PipelineLayout* layout, UInt index, DescriptorSet* descriptorSet) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL setPrimitiveTopology(PrimitiveTopology topology) = 0;
 
-    virtual void setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource*const* buffers, const UInt* strides, const UInt* offsets) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet(
+        PipelineType pipelineType,
+        PipelineLayout* layout,
+        UInt index,
+        DescriptorSet* descriptorSet) = 0;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
+        UInt startSlot,
+        UInt slotCount,
+        BufferResource* const* buffers,
+        const UInt* strides,
+        const UInt* offsets) = 0;
     inline void setVertexBuffer(UInt slot, BufferResource* buffer, UInt stride, UInt offset = 0);
 
-    virtual void setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset = 0) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset = 0) = 0;
 
-    virtual void setDepthStencilTarget(ResourceView* depthStencilView) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL setDepthStencilTarget(ResourceView* depthStencilView) = 0;
 
-    virtual void setViewports(UInt count, Viewport const* viewports) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL setViewports(UInt count, Viewport const* viewports) = 0;
     inline void setViewport(Viewport const& viewport)
     {
         setViewports(1, &viewport);
     }
 
-    virtual void setScissorRects(UInt count, ScissorRect const* rects) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL setScissorRects(UInt count, ScissorRect const* rects) = 0;
     inline void setScissorRect(ScissorRect const& rect)
     {
         setScissorRects(1, &rect);
     }
 
-    virtual void setPipelineState(PipelineType pipelineType, PipelineState* state) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL setPipelineState(PipelineType pipelineType, PipelineState* state) = 0;
 
-    virtual void draw(UInt vertexCount, UInt startVertex = 0) = 0;
-    virtual void drawIndexed(UInt indexCount, UInt startIndex = 0, UInt baseVertex = 0) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL draw(UInt vertexCount, UInt startVertex = 0) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL drawIndexed(UInt indexCount, UInt startIndex = 0, UInt baseVertex = 0) = 0;
 
-    virtual void dispatchCompute(int x, int y, int z) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) = 0;
 
         /// Commit any buffered state changes or draw calls.
         /// presentFrame will commitAll implicitly before doing a present
-    virtual void submitGpuWork() = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL submitGpuWork() = 0;
         /// Blocks until Gpu work is complete
-    virtual void waitForGpu() = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL waitForGpu() = 0;
 
         /// Get the type of this renderer
-    virtual RendererType getRendererType() const = 0;
+    virtual SLANG_NO_THROW RendererType SLANG_MCALL getRendererType() const = 0;
 };
 
+#define SLANG_UUID_IRenderer                                                             \
+    {                                                                                    \
+          0x715bdf26, 0x5135, 0x11eb, { 0xAE, 0x93, 0x02, 0x42, 0xAC, 0x13, 0x00, 0x02 } \
+    }
+
 // ----------------------------------------------------------------------------------------
-inline void Renderer::setVertexBuffer(UInt slot, BufferResource* buffer, UInt stride, UInt offset)
+inline void IRenderer::setVertexBuffer(UInt slot, BufferResource* buffer, UInt stride, UInt offset)
 {
     setVertexBuffers(slot, 1, &buffer, &stride, &offset);
 }
@@ -1089,7 +1121,7 @@ inline void Renderer::setVertexBuffer(UInt slot, BufferResource* buffer, UInt st
 /// Functions that are around Renderer and it's types
 struct RendererUtil
 {
-    typedef Renderer* (*CreateFunc)();
+    typedef SlangResult (*CreateFunc)(IRenderer** outRenderer);
 
         /// Gets the size in bytes of a Format type. Returns 0 if a size is not defined/invalid
     SLANG_FORCE_INLINE static size_t getFormatSize(Format format) { return s_formatSize[int(format)]; }
diff --git a/tools/gfx/vulkan/render-vk.cpp b/tools/gfx/vulkan/render-vk.cpp
index 80393904c..3cd10902b 100644
--- a/tools/gfx/vulkan/render-vk.cpp
+++ b/tools/gfx/vulkan/render-vk.cpp
@@ -42,50 +42,95 @@ public:
     };
 
     // Renderer    implementation
-    virtual SlangResult initialize(const Desc& desc, void* inWindowHandle) override;
-    virtual const List<String>& getFeatures() override { return m_features; }
-    virtual void setClearColor(const float color[4]) override;
-    virtual void clearFrame() override;
-    virtual void presentFrame() override;
-    TextureResource::Desc getSwapChainTextureDesc() override;
-
-    Result createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& desc, const TextureResource::Data* initData, TextureResource** outResource) override;
-    Result createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& desc, const void* initData, BufferResource** outResource) override;
-    Result createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override;
-
-    Result createTextureView(TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override;
-    Result createBufferView(BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override;
-
-    Result createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount, InputLayout** outLayout) override;
-
-    Result createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override;
-    Result createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override;
-    Result createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override;
-
-    Result createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override;
-    Result createGraphicsPipelineState(const GraphicsPipelineStateDesc& desc, PipelineState** outState) override;
-    Result createComputePipelineState(const ComputePipelineStateDesc& desc, PipelineState** outState) override;
-
-    virtual SlangResult captureScreenSurface(Surface& surface) override;
-
-    virtual void* map(BufferResource* buffer, MapFlavor flavor) override;
-    virtual void unmap(BufferResource* buffer) override;
-    virtual void setPrimitiveTopology(PrimitiveTopology topology) override;
-
-    virtual void setDescriptorSet(PipelineType pipelineType, PipelineLayout* layout, UInt index, DescriptorSet* descriptorSet) override;
-
-    virtual void setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource*const* buffers, const UInt* strides, const UInt* offsets) override;
-    virtual void setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override;
-    virtual void setDepthStencilTarget(ResourceView* depthStencilView) override;
-    void setViewports(UInt count, Viewport const* viewports) override;
-    void setScissorRects(UInt count, ScissorRect const* rects) override;
-    virtual void setPipelineState(PipelineType pipelineType, PipelineState* state) override;
-    virtual void draw(UInt vertexCount, UInt startVertex) override;
-    virtual void drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override;
-    virtual void dispatchCompute(int x, int y, int z) override;
-    virtual void submitGpuWork() override;
-    virtual void waitForGpu() override;
-    virtual RendererType getRendererType() const override { return RendererType::Vulkan; }
+    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;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
+        Resource::Usage initialUsage,
+        const BufferResource::Desc& desc,
+        const void* initData,
+        BufferResource** outResource) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView(
+        TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView(
+        BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout(
+        const InputElementDesc* inputElements,
+        UInt inputElementCount,
+        InputLayout** outLayout) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout(
+        const DescriptorSetLayout::Desc& desc,
+        DescriptorSetLayout** outLayout) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
+        const GraphicsPipelineStateDesc& desc,
+        PipelineState** outState) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
+        const ComputePipelineStateDesc& desc,
+        PipelineState** outState) override;
+
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL captureScreenSurface(Surface& surface) 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
+        setPrimitiveTopology(PrimitiveTopology topology) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet(
+        PipelineType pipelineType,
+        PipelineLayout* layout,
+        UInt index,
+        DescriptorSet* descriptorSet) override;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
+        UInt startSlot,
+        UInt slotCount,
+        BufferResource* const* buffers,
+        const UInt* strides,
+        const UInt* offsets) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setDepthStencilTarget(ResourceView* 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;
+    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;
+    virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override;
+    virtual SLANG_NO_THROW void SLANG_MCALL submitGpuWork() override;
+    virtual SLANG_NO_THROW void SLANG_MCALL waitForGpu() override;
+    virtual SLANG_NO_THROW RendererType SLANG_MCALL getRendererType() const override
+    {
+        return RendererType::Vulkan;
+    }
 
         /// Dtor
     ~VKRenderer();
@@ -813,9 +858,11 @@ void VKRenderer::_endRender()
     m_deviceQueue.flush();
 }
 
-Renderer* createVKRenderer()
+SlangResult createVKRenderer(IRenderer** outRenderer)
 {
-    return new VKRenderer;
+    *outRenderer = new VKRenderer();
+    (*outRenderer)->addRef();
+    return SLANG_OK;
 }
 
 VKRenderer::~VKRenderer()
diff --git a/tools/gfx/vulkan/render-vk.h b/tools/gfx/vulkan/render-vk.h
index 14a8e403a..2e101c999 100644
--- a/tools/gfx/vulkan/render-vk.h
+++ b/tools/gfx/vulkan/render-vk.h
@@ -1,10 +1,12 @@
 // render-vk.h
 #pragma once
 
+#include <cstdint>
+
 namespace gfx {
 
-class Renderer;
+class IRenderer;
 
-Renderer* createVKRenderer();
+int32_t createVKRenderer(IRenderer** outRenderer);
 
 } // gfx
diff --git a/tools/graphics-app-framework/gui.cpp b/tools/graphics-app-framework/gui.cpp
index 8208bd606..3d6039f27 100644
--- a/tools/graphics-app-framework/gui.cpp
+++ b/tools/graphics-app-framework/gui.cpp
@@ -36,7 +36,7 @@ void setNativeWindowHook(Window* window, WNDPROC proc);
 #endif
 
 
-GUI::GUI(Window* window, Renderer* inRenderer)
+GUI::GUI(Window* window, IRenderer* inRenderer)
     : renderer(inRenderer)
 {
      ImGui::CreateContext();
diff --git a/tools/graphics-app-framework/gui.h b/tools/graphics-app-framework/gui.h
index d2c52de3c..fa6fda1d1 100644
--- a/tools/graphics-app-framework/gui.h
+++ b/tools/graphics-app-framework/gui.h
@@ -4,21 +4,21 @@
 #include "tools/gfx/render.h"
 #include "vector-math.h"
 #include "window.h"
-
+#include "slang-com-ptr.h"
 #include "external/imgui/imgui.h"
 
 namespace gfx {
 
 struct GUI : RefObject
 {
-    GUI(Window* window, Renderer* renderer);
+    GUI(Window* window, IRenderer* renderer);
     ~GUI();
 
     void beginFrame();
     void endFrame();
 
 private:
-    RefPtr<Renderer>            renderer;
+    Slang::ComPtr<IRenderer>    renderer;
     RefPtr<PipelineState>       pipelineState;
     RefPtr<DescriptorSetLayout> descriptorSetLayout;
     RefPtr<PipelineLayout>      pipelineLayout;
diff --git a/tools/graphics-app-framework/model.cpp b/tools/graphics-app-framework/model.cpp
index 5d3a850e4..6a61c64e5 100644
--- a/tools/graphics-app-framework/model.cpp
+++ b/tools/graphics-app-framework/model.cpp
@@ -98,7 +98,7 @@ namespace gfx
 {
 
 RefPtr<TextureResource> loadTextureImage(
-    Renderer*   renderer,
+    IRenderer*   renderer,
     char const* path)
 {
     int extentX = 0;
diff --git a/tools/graphics-app-framework/model.h b/tools/graphics-app-framework/model.h
index e86940244..446f57943 100644
--- a/tools/graphics-app-framework/model.h
+++ b/tools/graphics-app-framework/model.h
@@ -3,7 +3,7 @@
 
 #include "tools/gfx/render.h"
 #include "vector-math.h"
-
+#include "slang-com-ptr.h"
 #include <vector>
 #include <string>
 
@@ -65,10 +65,10 @@ struct ModelLoader
         FlipWinding = 1 << 0,
     };
 
-    ICallbacks*         callbacks = nullptr;
-    RefPtr<Renderer>    renderer;
-    LoadFlags           loadFlags = 0;
-    float               scale = 1.0f;
+    ICallbacks*              callbacks = nullptr;
+    Slang::ComPtr<IRenderer> renderer;
+    LoadFlags                loadFlags = 0;
+    float                    scale = 1.0f;
 
     Result load(char const* inputPath, void** outModel);
 };
diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp
index 1c8dc1d72..533932eab 100644
--- a/tools/render-test/render-test-main.cpp
+++ b/tools/render-test/render-test-main.cpp
@@ -90,7 +90,7 @@ public:
     // code, and then create the API objects we need for rendering.
     virtual Result initialize(
         SlangSession* session,
-        Renderer* renderer,
+        IRenderer* renderer,
         const Options& options,
         const ShaderCompilerUtil::Input& input) = 0;
     void runCompute();
@@ -107,7 +107,7 @@ protected:
     /// Called in initialize
     Result _initializeShaders(
         SlangSession* session,
-        Renderer* renderer,
+        IRenderer* renderer,
         Options::ShaderProgramType shaderType,
         const ShaderCompilerUtil::Input& input);
 
@@ -116,7 +116,7 @@ protected:
     // variables for state to be used for rendering...
     uintptr_t m_constantBufferSize;
 
-    RefPtr<Renderer> m_renderer;
+    ComPtr<IRenderer> m_renderer;
 
     RefPtr<InputLayout> m_inputLayout;
     RefPtr<BufferResource> m_vertexBuffer;
@@ -137,7 +137,7 @@ public:
     virtual void setProjectionMatrix() SLANG_OVERRIDE;
     virtual Result initialize(
         SlangSession* session,
-        Renderer* renderer,
+        IRenderer* renderer,
         const Options& options,
         const ShaderCompilerUtil::Input& input) SLANG_OVERRIDE;
 
@@ -159,7 +159,7 @@ public:
     virtual void setProjectionMatrix() SLANG_OVERRIDE;
     virtual Result initialize(
         SlangSession* session,
-        Renderer* renderer,
+        IRenderer* renderer,
         const Options& options,
         const ShaderCompilerUtil::Input& input) SLANG_OVERRIDE;
     virtual Result writeBindingOutput(BindRoot* bindRoot, const char* fileName) override;
@@ -170,7 +170,7 @@ protected:
 };
 
 SlangResult _assignVarsFromLayout(
-    Renderer*                   renderer,
+    IRenderer*                   renderer,
     ShaderObject*               shaderObject,
     ShaderInputLayout const&    layout,
     ShaderOutputPlan&           ioOutputPlan,
@@ -421,7 +421,7 @@ SlangResult _assignVarsFromLayout(
 
 void LegacyRenderTestApp::applyBinding(PipelineType pipelineType)
 {
-    m_bindingState->apply(m_renderer.Ptr(), pipelineType);
+    m_bindingState->apply(m_renderer.get(), pipelineType);
 }
 
 void ShaderObjectRenderTestApp::applyBinding(PipelineType pipelineType)
@@ -431,7 +431,7 @@ void ShaderObjectRenderTestApp::applyBinding(PipelineType pipelineType)
 
 SlangResult LegacyRenderTestApp::initialize(
     SlangSession* session,
-    Renderer* renderer,
+    IRenderer* renderer,
     const Options& options,
     const ShaderCompilerUtil::Input& input)
 {
@@ -536,7 +536,7 @@ SlangResult LegacyRenderTestApp::initialize(
 
 SlangResult ShaderObjectRenderTestApp::initialize(
     SlangSession* session,
-    Renderer* renderer,
+    IRenderer* renderer,
     const Options& options,
     const ShaderCompilerUtil::Input& input)
 {
@@ -631,7 +631,11 @@ SlangResult ShaderObjectRenderTestApp::initialize(
     return m_pipelineState ? SLANG_OK : SLANG_FAIL;
 }
 
-Result RenderTestApp::_initializeShaders(SlangSession* session, Renderer* renderer, Options::ShaderProgramType shaderType, const ShaderCompilerUtil::Input& input)
+Result RenderTestApp::_initializeShaders(
+    SlangSession* session,
+    IRenderer* renderer,
+    Options::ShaderProgramType shaderType,
+    const ShaderCompilerUtil::Input& input)
 {
     SLANG_RETURN_ON_FAIL(ShaderCompilerUtil::compileWithLayout(session, m_options, input,  m_compilationOutput));
     m_shaderInputLayout = m_compilationOutput.layout;
@@ -1211,12 +1215,12 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi
 #endif
     }
 
-    Slang::RefPtr<Renderer> renderer;
+    Slang::ComPtr<IRenderer> renderer;
     {
         RendererUtil::CreateFunc createFunc = RendererUtil::getCreateFunc(options.rendererType);
         if (createFunc)
         {
-            renderer = createFunc();
+            createFunc(renderer.writeRef());
         }
 
         if (!renderer)
@@ -1228,7 +1232,7 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi
             return SLANG_FAIL;
         }
 
-        Renderer::Desc desc;
+        IRenderer::Desc desc;
         desc.width = gWindowWidth;
         desc.height = gWindowHeight;
         desc.adapter = options.adapter;
diff --git a/tools/render-test/shader-renderer-util.cpp b/tools/render-test/shader-renderer-util.cpp
index 5e77cf1fd..d24909bca 100644
--- a/tools/render-test/shader-renderer-util.cpp
+++ b/tools/render-test/shader-renderer-util.cpp
@@ -7,7 +7,7 @@ namespace renderer_test {
 using namespace Slang;
 using Slang::Result;
 
-void BindingStateImpl::apply(Renderer* renderer, PipelineType pipelineType)
+void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType)
 {
     renderer->setDescriptorSet(
         pipelineType,
@@ -16,14 +16,23 @@ void BindingStateImpl::apply(Renderer* renderer, PipelineType pipelineType)
         descriptorSet);
 }
 
-/* static */Result ShaderRendererUtil::generateTextureResource(const InputTextureDesc& inputDesc, int bindFlags, Renderer* renderer, RefPtr<TextureResource>& textureOut)
+/* static */ Result ShaderRendererUtil::generateTextureResource(
+    const InputTextureDesc& inputDesc,
+    int bindFlags,
+    IRenderer* renderer,
+    RefPtr<TextureResource>& textureOut)
 {
     TextureData texData;
     generateTextureData(texData, inputDesc);
     return createTextureResource(inputDesc, texData, bindFlags, renderer, textureOut);
 }
 
-/* static */Result ShaderRendererUtil::createTextureResource(const InputTextureDesc& inputDesc, const TextureData& texData, int bindFlags, Renderer* renderer, RefPtr<TextureResource>& textureOut)
+/* static */ Result ShaderRendererUtil::createTextureResource(
+    const InputTextureDesc& inputDesc,
+    const TextureData& texData,
+    int bindFlags,
+    IRenderer* renderer,
+    RefPtr<TextureResource>& textureOut)
 {
     TextureResource::Desc textureResourceDesc;
     textureResourceDesc.init(Resource::Type::Unknown);
@@ -99,7 +108,13 @@ void BindingStateImpl::apply(Renderer* renderer, PipelineType pipelineType)
     return textureOut ? SLANG_OK : SLANG_FAIL;
 }
 
-/* static */Result ShaderRendererUtil::createBufferResource(const InputBufferDesc& inputDesc, bool isOutput, size_t bufferSize, const void* initData, Renderer* renderer, Slang::RefPtr<BufferResource>& bufferOut)
+/* static */ Result ShaderRendererUtil::createBufferResource(
+    const InputBufferDesc& inputDesc,
+    bool isOutput,
+    size_t bufferSize,
+    const void* initData,
+    IRenderer* renderer,
+    Slang::RefPtr<BufferResource>& bufferOut)
 {
     Resource::Usage initialUsage = Resource::Usage::GenericRead;
 
@@ -149,14 +164,17 @@ static SamplerState::Desc _calcSamplerDesc(const InputSamplerDesc& srcDesc)
     return dstDesc;
 }
 
-RefPtr<SamplerState> _createSamplerState(
-    Renderer*               renderer,
+RefPtr<SamplerState> _createSamplerState(IRenderer* renderer,
     const InputSamplerDesc& srcDesc)
 {
     return renderer->createSamplerState(_calcSamplerDesc(srcDesc));
 }
 
-/* static */Result ShaderRendererUtil::createBindingState(const ShaderInputLayout& layout, Renderer* renderer, BufferResource* addedConstantBuffer, BindingStateImpl** outBindingState)
+/* static */ Result ShaderRendererUtil::createBindingState(
+    const ShaderInputLayout& layout,
+    IRenderer* renderer,
+    BufferResource* addedConstantBuffer,
+    BindingStateImpl** outBindingState)
 {
     auto srcEntries = layout.entries.getBuffer();
     auto numEntries = layout.entries.getCount();
diff --git a/tools/render-test/shader-renderer-util.h b/tools/render-test/shader-renderer-util.h
index 76f3b6d87..5bb2d342e 100644
--- a/tools/render-test/shader-renderer-util.h
+++ b/tools/render-test/shader-renderer-util.h
@@ -33,7 +33,7 @@ struct BindingStateImpl : public Slang::RefObject
         uint16_t size;              ///< The amount of register indices
     };
 
-    void apply(Renderer* renderer, PipelineType pipelineType);
+    void apply(IRenderer* renderer, PipelineType pipelineType);
 
     struct OutputBinding
     {
@@ -48,27 +48,47 @@ struct BindingStateImpl : public Slang::RefObject
 };
 
 RefPtr<SamplerState> _createSamplerState(
-    Renderer*               renderer,
+    IRenderer*               renderer,
     const InputSamplerDesc& srcDesc);
 
 /// Utility class containing functions that construct items on the renderer using the ShaderInputLayout representation
 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, Renderer* renderer, Slang::RefPtr<TextureResource>& textureOut);
+    static Slang::Result generateTextureResource(const InputTextureDesc& inputDesc, int bindFlags, IRenderer* renderer, Slang::RefPtr<TextureResource>& textureOut);
 
         /// Create texture resource using inputDesc, and texData to describe format, and contents
-    static Slang::Result createTextureResource(const InputTextureDesc& inputDesc, const TextureData& texData, int bindFlags, Renderer* renderer, Slang::RefPtr<TextureResource>& textureOut);
+    static Slang::Result createTextureResource(
+        const InputTextureDesc& inputDesc,
+        const TextureData& texData,
+        int bindFlags,
+        IRenderer* renderer,
+        Slang::RefPtr<TextureResource>& textureOut);
 
         /// Create the BufferResource using the renderer from the contents of inputDesc
-    static Slang::Result createBufferResource(const InputBufferDesc& inputDesc, bool isOutput, size_t bufferSize, const void* initData, Renderer* renderer, Slang::RefPtr<BufferResource>& bufferOut);
+    static Slang::Result createBufferResource(
+        const InputBufferDesc& inputDesc,
+        bool isOutput,
+        size_t bufferSize,
+        const void* initData,
+        IRenderer* renderer,
+        Slang::RefPtr<BufferResource>& bufferOut);
 
         /// Create BindingState::Desc from the contents of layout
-    static Slang::Result createBindingState(const ShaderInputLayout& layout, Renderer* renderer, BufferResource* addedConstantBuffer, BindingStateImpl** outBindingState);
+    static Slang::Result createBindingState(
+        const ShaderInputLayout& layout,
+        IRenderer* renderer,
+        BufferResource* addedConstantBuffer,
+        BindingStateImpl** outBindingState);
 
 private:
         /// Create BindingState::Desc from a list of ShaderInputLayout entries
-    static Slang::Result _createBindingState(ShaderInputLayoutEntry* srcEntries, int numEntries, Renderer* renderer, BufferResource* addedConstantBuffer, BindingStateImpl** outBindingState);
+    static Slang::Result _createBindingState(
+        ShaderInputLayoutEntry* srcEntries,
+        int numEntries,
+        IRenderer* renderer,
+        BufferResource* addedConstantBuffer,
+        BindingStateImpl** outBindingState);
 };
 
 } // renderer_test
author	Yong He <yonghe@outlook.com>	2021-01-11 09:11:52 -0800
committer	GitHub <noreply@github.com>	2021-01-11 09:11:52 -0800
commit	5554777188225266e2295db3588f6cb17cae0c4d (patch)
tree	9d15992cd24d752cde1047745cf75a25e841f494
parent	e24c5a6cb9c3347477b83abe084a09ae8f9fde0a (diff)