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

5 files changed, 46 insertions, 44 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;
     {