First pass impls on ComPtr and reorganise Renderer (#450)

* Fixed some small typos in api-users-guide.md

* Fix some small typos in slang-test/main.cpp, render-test/render-d3d11.cpp

* Remove exit() calls from test code. Added Slang::Result, which works in the same way as COM HRESULT.

* FIx bug introduced when moving to Slang::Result - handling E_INVALIDARG on Dx11.

* Fix the testing of feature levels on Dx11 renderer.

* First attempt at README.md for slang-test.

* Tidied up the slang-test README.md file.

* Fix some small typos in tools/slang-test/main.cpp

* Fix spaces -> tabs problems.
Fix some small types.

* Refactor Renderer implementations such that:
* Class definition does not contain long implementation/s
* Removed unused globals
* Ordered implementation after class definition
* Made renderer specific classes child classes, and use Impl postfix to differentiate
* Converted tabs into spaces

* First pass at Slang::ComPtr. Added slang-defines.h which sets up some fairly commonly used defines such as SLANG_FORCE_INLINE, compiler detection, os detection, and some other cross platform features.

1 files changed, 221 insertions, 200 deletions

diff --git a/tools/render-test/render-d3d12.cpp b/tools/render-test/render-d3d12.cpp
index f0b0eb478..d481d7084 100644
--- a/tools/render-test/render-d3d12.cpp
+++ b/tools/render-test/render-d3d12.cpp
@@ -1,4 +1,4 @@
-// render-d3d12.cpp
+// render-d3d12.cpp
 #include "render-d3d12.h"
 
 #include "options.h"
@@ -46,279 +46,300 @@ ID3DBlob* compileHLSLShader(
     char const* entryPointName,
     char const* dxProfileName);
 
-static char const* vertexProfileName   = "vs_4_0";
-static char const* fragmentProfileName = "ps_4_0";
+//static char const* vertexProfileName   = "vs_4_0";
+//static char const* fragmentProfileName = "ps_4_0";
 
 //
-
 class D3D12Renderer : public Renderer, public ShaderCompiler
 {
 public:
-    IDXGISwapChain* dxSwapChain = nullptr;
+    // Renderer    implementation
+    virtual SlangResult initialize(void* inWindowHandle) override;
+    virtual void setClearColor(float const* color) override;
+    virtual void clearFrame() override;
+    virtual void presentFrame() override;
+    virtual SlangResult captureScreenShot(char const* outputPath) override;
+    virtual void serializeOutput(BindingState* state, const char * fileName) override;
+    virtual Buffer* createBuffer(BufferDesc const& desc) override;
+    virtual InputLayout* createInputLayout(InputElementDesc const* inputElements, UInt inputElementCount) override;
+    virtual BindingState * createBindingState(const ShaderInputLayout & layout) override;
+    virtual ShaderCompiler* getShaderCompiler() override;
+    virtual void* map(Buffer* buffer, MapFlavor flavor) override;
+    virtual void unmap(Buffer* buffer) override;
+    virtual void setInputLayout(InputLayout* inputLayout) override;
+    virtual void setPrimitiveTopology(PrimitiveTopology topology) override;
+    virtual void setBindingState(BindingState * state);
+    virtual void setVertexBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* strides, UInt const* offsets) override;
+    virtual void setShaderProgram(ShaderProgram* inProgram) override;
+    virtual void setConstantBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets) override;
+    virtual void draw(UInt vertexCount, UInt startVertex) override;
+    virtual void dispatchCompute(int x, int y, int z) override;
+
+    // ShaderCompiler implementation
+    virtual ShaderProgram* compileProgram(ShaderCompileRequest const& request) override;
+    
+    protected:
+    PROC loadProc(HMODULE module, char const* name);
+    static DXGI_FORMAT mapFormat(Format format);
 
+    float clearColor[4] = { 0, 0, 0, 0 };
+    IDXGISwapChain* dxSwapChain = nullptr;
     ID3D12Device* dxDevice = nullptr;
+};
+
+Renderer* createD3D12Renderer()
+{
+    return new D3D12Renderer;
+}
 
-    virtual PROC loadProc(
-        HMODULE module,
-        char const* name)
+PROC D3D12Renderer::loadProc(HMODULE module, char const* name)
+{
+    PROC proc = ::GetProcAddress(module, name);
+    if (!proc)
     {
-        PROC proc = GetProcAddress(module, name);
-        if( !proc )
-        {
-            fprintf(stderr,
-                "error: failed load symbol '%s'\n", name);
-            return nullptr;
-        }
-        return proc;
+        fprintf(stderr, "error: failed load symbol '%s'\n", name);
+        return nullptr;
     }
+    return proc;
+}
 
-    virtual SlangResult initialize(void* inWindowHandle) override
+/* static */DXGI_FORMAT D3D12Renderer::mapFormat(Format format)
+{
+    switch (format)
     {
-        auto windowHandle = (HWND) inWindowHandle;
-        // Rather than statically link against D3D, we load it dynamically.
+        case Format::RGB_Float32:
+            return DXGI_FORMAT_R32G32B32_FLOAT;
+        case Format::RG_Float32:
+            return DXGI_FORMAT_R32G32_FLOAT;
+        default:
+            return DXGI_FORMAT_UNKNOWN;
+    }
+}
 
-        HMODULE d3d12 = LoadLibraryA("d3d12.dll");
-        if(!d3d12)
-        {
-            fprintf(stderr, "error: failed load 'd3d12.dll'\n");
-            return SLANG_FAIL;
-        }
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!! Renderer interface !!!!!!!!!!!!!!!!!!!!!!!!!!
+
+SlangResult D3D12Renderer::initialize(void* inWindowHandle)
+{
+    auto windowHandle = (HWND)inWindowHandle;
+    // Rather than statically link against D3D, we load it dynamically.
+
+    HMODULE d3d12 = LoadLibraryA("d3d12.dll");
+    if (!d3d12)
+    {
+        fprintf(stderr, "error: failed load 'd3d12.dll'\n");
+        return SLANG_FAIL;
+    }
 
 #define LOAD_PROC(TYPE, NAME) \
         TYPE NAME##_ = (TYPE) loadProc(d3d12, #NAME); \
-		if (NAME##_ == nullptr) return SLANG_FAIL;
+        if (NAME##_ == nullptr) return SLANG_FAIL;
 
-        UINT dxgiFactoryFlags = 0;
+    UINT dxgiFactoryFlags = 0;
 
 #if ENABLE_DEBUG_LAYER
-        LOAD_PROC(PFN_D3D12_GET_DEBUG_INTERFACE, D3D12GetDebugInterface);
+    LOAD_PROC(PFN_D3D12_GET_DEBUG_INTERFACE, D3D12GetDebugInterface);
 
-        ID3D12Debug* debugController;
-        if(SUCCEEDED(D3D12GetDebugInterface_(IID_PPV_ARGS(&debugController))))
-        {
-            debugController->EnableDebugLayer();
-            dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
-        }
+    ID3D12Debug* debugController;
+    if (SUCCEEDED(D3D12GetDebugInterface_(IID_PPV_ARGS(&debugController))))
+    {
+        debugController->EnableDebugLayer();
+        dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
+    }
 #endif
-        
-        typedef HRESULT (WINAPI *PFN_DXGI_CREATE_FACTORY_2)(UINT Flags, REFIID riid, _COM_Outptr_ void **ppFactory);
 
-        LOAD_PROC(PFN_DXGI_CREATE_FACTORY_2, CreateDXGIFactory2);
+    typedef HRESULT(WINAPI *PFN_DXGI_CREATE_FACTORY_2)(UINT Flags, REFIID riid, _COM_Outptr_ void **ppFactory);
 
-        IDXGIFactory4* dxgiFactory;
-        SLANG_RETURN_ON_FAIL(CreateDXGIFactory2_(dxgiFactoryFlags, IID_PPV_ARGS(&dxgiFactory)));
+    LOAD_PROC(PFN_DXGI_CREATE_FACTORY_2, CreateDXGIFactory2);
 
-        D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
+    IDXGIFactory4* dxgiFactory;
+    SLANG_RETURN_ON_FAIL(CreateDXGIFactory2_(dxgiFactoryFlags, IID_PPV_ARGS(&dxgiFactory)));
 
-        // Search for an adapter that meets our requirements
-        IDXGIAdapter* adapter = nullptr;
+    D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_11_0;
 
-        LOAD_PROC(PFN_D3D12_CREATE_DEVICE, D3D12CreateDevice);
+    // Search for an adapter that meets our requirements
+    IDXGIAdapter* adapter = nullptr;
 
-        UINT adapterCounter = 0;
-        for(;;)
+    LOAD_PROC(PFN_D3D12_CREATE_DEVICE, D3D12CreateDevice);
+
+    UINT adapterCounter = 0;
+    for (;;)
+    {
+        UINT adapterIndex = adapterCounter++;
+        IDXGIAdapter1* candidateAdapter = nullptr;
+        if (dxgiFactory->EnumAdapters1(adapterIndex, &candidateAdapter) == DXGI_ERROR_NOT_FOUND)
+            break;
+
+        DXGI_ADAPTER_DESC1 desc;
+        candidateAdapter->GetDesc1(&desc);
+
+        if (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE)
         {
-            UINT adapterIndex = adapterCounter++;
-            IDXGIAdapter1* candidateAdapter = nullptr;
-            if(dxgiFactory->EnumAdapters1(adapterIndex, &candidateAdapter) == DXGI_ERROR_NOT_FOUND)
-                break;
-
-            DXGI_ADAPTER_DESC1 desc;
-            candidateAdapter->GetDesc1(&desc);
-
-            if( desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE )
-            {
-                // TODO: may want to allow software driver as fallback
-            }
-            else if( SUCCEEDED(D3D12CreateDevice_(candidateAdapter, featureLevel, IID_PPV_ARGS(&dxDevice))) )
-            {
-                // We found one!
-                adapter = candidateAdapter;
-                break;
-            }
-
-            candidateAdapter->Release();
+            // TODO: may want to allow software driver as fallback
         }
-
-        if(!adapter)
+        else if (SUCCEEDED(D3D12CreateDevice_(candidateAdapter, featureLevel, IID_PPV_ARGS(&dxDevice))))
         {
-			// Couldn't find an adapter
-            return SLANG_FAIL;
+            // We found one!
+            adapter = candidateAdapter;
+            break;
         }
 
-        // Command Queue
-        D3D12_COMMAND_QUEUE_DESC queueDesc = {};
-        queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
+        candidateAdapter->Release();
+    }
 
-        ID3D12CommandQueue* commandQueue;
-		SLANG_RETURN_ON_FAIL(dxDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&commandQueue)));
+    if (!adapter)
+    {
+        // Couldn't find an adapter
+        return SLANG_FAIL;
+    }
 
-        // Swap Chain
-        UINT frameCount = 2; // TODO: configure
+    // Command Queue
+    D3D12_COMMAND_QUEUE_DESC queueDesc = {};
+    queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
 
-        DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
-        swapChainDesc.BufferCount = frameCount;
-        swapChainDesc.Width = gWindowWidth;
-        swapChainDesc.Height = gWindowHeight;
-        swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
-        swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
-        swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
-        swapChainDesc.SampleDesc.Count = 1;
+    ID3D12CommandQueue* commandQueue;
+    SLANG_RETURN_ON_FAIL(dxDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&commandQueue)));
 
-        IDXGISwapChain1* swapChain;
-        SLANG_RETURN_ON_FAIL(dxgiFactory->CreateSwapChainForHwnd(
-            commandQueue,
-            windowHandle,
-            &swapChainDesc,
-            nullptr,
-            nullptr,
-            &swapChain));
+    // Swap Chain
+    UINT frameCount = 2; // TODO: configure
 
-        // Is this needed?
-        dxgiFactory->MakeWindowAssociation(windowHandle, DXGI_MWA_NO_ALT_ENTER);
+    DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
+    swapChainDesc.BufferCount = frameCount;
+    swapChainDesc.Width = gWindowWidth;
+    swapChainDesc.Height = gWindowHeight;
+    swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+    swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+    swapChainDesc.SampleDesc.Count = 1;
 
-        IDXGISwapChain3* swapChainEx;
-        SLANG_RETURN_ON_FAIL(swapChain->QueryInterface(IID_PPV_ARGS(&swapChainEx)));
+    IDXGISwapChain1* swapChain;
+    SLANG_RETURN_ON_FAIL(dxgiFactory->CreateSwapChainForHwnd(commandQueue, windowHandle, &swapChainDesc, nullptr, nullptr, &swapChain));
 
-        UINT frameIndex = swapChainEx->GetCurrentBackBufferIndex();
+    // Is this needed?
+    dxgiFactory->MakeWindowAssociation(windowHandle, DXGI_MWA_NO_ALT_ENTER);
 
-        // Descriptor heaps
+    IDXGISwapChain3* swapChainEx;
+    SLANG_RETURN_ON_FAIL(swapChain->QueryInterface(IID_PPV_ARGS(&swapChainEx)));
 
-        D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
-        rtvHeapDesc.NumDescriptors = frameCount;
-        rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
+    UINT frameIndex = swapChainEx->GetCurrentBackBufferIndex();
 
-        ID3D12DescriptorHeap* rtvHeap;
-        SLANG_RETURN_ON_FAIL(dxDevice->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&rtvHeap)));
+    // Descriptor heaps
 
-        UINT rtvDescriptorSize = dxDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+    D3D12_DESCRIPTOR_HEAP_DESC rtvHeapDesc = {};
+    rtvHeapDesc.NumDescriptors = frameCount;
+    rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
 
-        D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = rtvHeap->GetCPUDescriptorHandleForHeapStart();
+    ID3D12DescriptorHeap* rtvHeap;
+    SLANG_RETURN_ON_FAIL(dxDevice->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&rtvHeap)));
 
-        // Create per-frame RTVs
-        ID3D12Resource* backBufferResources[2];
-        for( UINT ff = 0; ff < frameCount; ++ff )
-        {
-            SLANG_RETURN_ON_FAIL(swapChainEx->GetBuffer(ff, IID_PPV_ARGS(&backBufferResources[ff])));
-            dxDevice->CreateRenderTargetView(backBufferResources[ff], nullptr, rtvHandle);
-            rtvHandle.ptr += rtvDescriptorSize;
-        }
+    UINT rtvDescriptorSize = dxDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
 
-        ID3D12CommandAllocator* commandAllocator;
-        SLANG_RETURN_ON_FAIL(dxDevice->CreateCommandAllocator( D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&commandAllocator)));
-		return SLANG_OK;
-    }
+    D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = rtvHeap->GetCPUDescriptorHandleForHeapStart();
 
-    float clearColor[4] = { 0, 0, 0, 0 };
-    virtual void setClearColor(float const* color) override
+    // Create per-frame RTVs
+    ID3D12Resource* backBufferResources[2];
+    for (UINT ff = 0; ff < frameCount; ++ff)
     {
-        memcpy(clearColor, color, sizeof(clearColor));
+        SLANG_RETURN_ON_FAIL(swapChainEx->GetBuffer(ff, IID_PPV_ARGS(&backBufferResources[ff])));
+        dxDevice->CreateRenderTargetView(backBufferResources[ff], nullptr, rtvHandle);
+        rtvHandle.ptr += rtvDescriptorSize;
     }
 
-    virtual void clearFrame() override
-    {
-    }
+    ID3D12CommandAllocator* commandAllocator;
+    SLANG_RETURN_ON_FAIL(dxDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&commandAllocator)));
+    return SLANG_OK;
+}
 
-    virtual void presentFrame() override
-    {
-    }
+void D3D12Renderer::setClearColor(float const* color)
+{
+    memcpy(clearColor, color, sizeof(clearColor));
+}
 
-    virtual SlangResult captureScreenShot(char const* outputPath) override
-    {
-		return SLANG_FAIL;
-    }
+void D3D12Renderer::clearFrame()
+{
+}
 
-    virtual ShaderCompiler* getShaderCompiler() override
-    {
-        return this;
-    }
+void D3D12Renderer::presentFrame()
+{
+}
 
-    virtual Buffer* createBuffer(BufferDesc const& desc) override
-    {
-        return nullptr;
-    }
+SlangResult D3D12Renderer::captureScreenShot(char const* outputPath)
+{
+    return SLANG_FAIL;
+}
 
-    static DXGI_FORMAT mapFormat(Format format)
-    {
-        switch( format )
-        {
-        case Format::RGB_Float32:
-            return DXGI_FORMAT_R32G32B32_FLOAT;
-        case Format::RG_Float32:
-            return DXGI_FORMAT_R32G32_FLOAT;
-        default:
-            return DXGI_FORMAT_UNKNOWN;
-        }
-    }
+ShaderCompiler* D3D12Renderer::getShaderCompiler() 
+{
+    return this;
+}
 
-    virtual InputLayout* createInputLayout(InputElementDesc const* inputElements, UInt inputElementCount) override
-    {
-        return nullptr;
-    }
+Buffer* D3D12Renderer::createBuffer(BufferDesc const& desc)
+{
+    return nullptr;
+}
 
-    virtual void* map(Buffer* buffer, MapFlavor flavor) override
-    {
-        return nullptr;
-    }
 
-    virtual void unmap(Buffer* buffer) override
-    {
-    }
+InputLayout* D3D12Renderer::createInputLayout(InputElementDesc const* inputElements, UInt inputElementCount) 
+{
+    return nullptr;
+}
 
-    virtual void setInputLayout(InputLayout* inputLayout) override
-    {
-    }
+void* D3D12Renderer::map(Buffer* buffer, MapFlavor flavor) 
+{
+    return nullptr;
+}
 
-    virtual void setPrimitiveTopology(PrimitiveTopology topology) override
-    {
-    }
+void D3D12Renderer::unmap(Buffer* buffer)
+{
+}
 
-    virtual void setVertexBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* strides, UInt const* offsets) override
-    {
-    }
+void D3D12Renderer::setInputLayout(InputLayout* inputLayout) 
+{
+}
 
-    virtual void setShaderProgram(ShaderProgram* inProgram) override
-    {
-    }
+void D3D12Renderer::setPrimitiveTopology(PrimitiveTopology topology) 
+{
+}
 
-    virtual void setConstantBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets) override
-    {
-    }
+void D3D12Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* strides, UInt const* offsets)
+{
+}
 
-    virtual void draw(UInt vertexCount, UInt startVertex) override
-    {
-    }
+void D3D12Renderer::setShaderProgram(ShaderProgram* inProgram)
+{
+}
 
+void D3D12Renderer::setConstantBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets)
+{
+}
 
-    virtual void dispatchCompute(int x, int y, int z) override
-    {
-    }
+void D3D12Renderer::draw(UInt vertexCount, UInt startVertex)
+{
+}
 
-    virtual BindingState * createBindingState(const ShaderInputLayout & layout)
-    {
-        return nullptr;
-    }
 
-    virtual void setBindingState(BindingState * state)
-    {
-    }
+void D3D12Renderer::dispatchCompute(int x, int y, int z)
+{
+}
 
-    virtual void serializeOutput(BindingState* state, const char * fileName)
-    {
-    }
+BindingState* D3D12Renderer::createBindingState(const ShaderInputLayout & layout)
+{
+    return nullptr;
+}
 
-    // ShaderCompiler interface
+void D3D12Renderer::setBindingState(BindingState * state)
+{
+}
 
-    virtual ShaderProgram* compileProgram(ShaderCompileRequest const& request) override
-    {
-        return nullptr;
-    }
+void D3D12Renderer::serializeOutput(BindingState* state, const char * fileName)
+{
+}
 
-};
+// ShaderCompiler interface
 
-Renderer* createD3D12Renderer()
+ShaderProgram* D3D12Renderer::compileProgram(ShaderCompileRequest const& request)
 {
-    return new D3D12Renderer();
+    return nullptr;
 }
 
 } // renderer_test
+