Tidy up of Renderer (#452)

* 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.

* * Fixed bug in vk renderer - where features structure not initialized on hkCreateDevice
* Make member variables in Renderer implementations use prefix
* Updated test README.md to document that free parameter can control what test is run

* * changed setClearColor to take an array of 4 floats to make API clearer on usage
* mix of type usage style - defaulted to more conventional style

* * Fixed swapWith
* Use SLANG_FORCE_INLINE
* Don't bother initializing List data when type is POD

* Added convenience macro for Result handling SLANG_RETURN_NULL_ON_ERROR

1 files changed, 246 insertions, 296 deletions

diff --git a/tools/render-test/render-d3d11.cpp b/tools/render-test/render-d3d11.cpp
index dc86e2e44..b4195c63d 100644
--- a/tools/render-test/render-d3d11.cpp
+++ b/tools/render-test/render-d3d11.cpp
@@ -1,4 +1,4 @@
-// render-d3d11.cpp
+// render-d3d11.cpp
 #include "render-d3d11.h"
 
 #include "options.h"
@@ -40,24 +40,18 @@ using namespace Slang;
 
 namespace renderer_test {
 
-//static char const* vertexEntryPointName    = "vertexMain";
-//static char const* fragmentEntryPointName  = "fragmentMain";
-
-//static char const* vertexProfileName   = "vs_4_0";
-//static char const* fragmentProfileName = "ps_4_0";
-
 class D3D11Renderer : public Renderer, public ShaderCompiler
 {
 public:
     // Renderer    implementation
     virtual SlangResult initialize(void* inWindowHandle) override;
-    virtual void setClearColor(float const* color) override;
+    virtual void setClearColor(const float color[4]) 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 void serializeOutput(BindingState* state, const char* fileName) override;
+    virtual Buffer* createBuffer(const BufferDesc& desc) override;
+    virtual InputLayout* createInputLayout( const InputElementDesc* inputElements, UInt inputElementCount) override;
     virtual BindingState * createBindingState(const ShaderInputLayout& layout) override;
     virtual ShaderCompiler* getShaderCompiler() override;
     virtual void* map(Buffer* buffer, MapFlavor flavor) override;
@@ -65,9 +59,9 @@ public:
     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 setVertexBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt* strides,  const UInt* offsets) override;    
     virtual void setShaderProgram(ShaderProgram* inProgram) override;
-    virtual void setConstantBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets) override;
+    virtual void setConstantBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffers,  const UInt* offsets) override;
     virtual void draw(UInt vertexCount, UInt startVertex) override;
     virtual void dispatchCompute(int x, int y, int z) override;
     
@@ -80,10 +74,10 @@ public:
     {
         ShaderInputType type;
         InputBufferType bufferType;                        // Only valid if `type` is `Buffer`
-        ID3D11ShaderResourceView * srv = nullptr;
-        ID3D11UnorderedAccessView * uav = nullptr;
-        ID3D11Buffer * buffer = nullptr;
-        ID3D11SamplerState * samplerState = nullptr;
+        ID3D11ShaderResourceView* srv = nullptr;
+        ID3D11UnorderedAccessView* uav = nullptr;
+        ID3D11Buffer* buffer = nullptr;
+        ID3D11SamplerState* samplerState = nullptr;
         int binding = 0;
         bool isOutput = false;
         int bufferLength = 0;
@@ -95,9 +89,9 @@ public:
     };
     struct ShaderProgramImpl
     {
-        ID3D11VertexShader* dxVertexShader = nullptr;
-        ID3D11PixelShader*  dxPixelShader = nullptr;
-        ID3D11ComputeShader* dxComputeShader = nullptr;
+        ID3D11VertexShader* vertexShader = nullptr;
+        ID3D11PixelShader*  pixelShader = nullptr;
+        ID3D11ComputeShader* computeShader = nullptr;
     };
 
     struct BufferImpl
@@ -115,28 +109,28 @@ public:
         /// Definition of the HLSL-to-bytecode compilation logic.
     static ID3DBlob* compileHLSLShader(char const* sourcePath, char const* source, char const* entryPointName, char const* dxProfileName);
         /// Capture a texture to a file
-    static HRESULT captureTextureToFile(ID3D11Device* dxDevice, ID3D11DeviceContext* dxContext, ID3D11Texture2D* dxTexture, char const* outputPath);
+    static HRESULT captureTextureToFile(ID3D11Device* device, ID3D11DeviceContext* context, ID3D11Texture2D* texture, char const* outputPath);
 
-    void* map(ID3D11Buffer * buffer, MapFlavor flavor);
-    void unmap(ID3D11Buffer * buffer);
+    void* map(ID3D11Buffer* buffer, MapFlavor flavor);
+    void unmap(ID3D11Buffer* buffer);
 
-    void createInputBuffer(InputBufferDesc & bufferDesc, List<unsigned int> & bufferData, ID3D11Buffer * &bufferOut,
-        ID3D11UnorderedAccessView * &viewOut, ID3D11ShaderResourceView * &srvOut);
+    void createInputBuffer(InputBufferDesc& bufferDesc, List<unsigned int>& bufferData, ID3D11Buffer*& bufferOut,
+        ID3D11UnorderedAccessView*& viewOut, ID3D11ShaderResourceView*& srvOut);
 
-    void createInputTexture(const InputTextureDesc & inputDesc, ID3D11ShaderResourceView * &viewOut);
+    void createInputTexture(const InputTextureDesc& inputDesc, ID3D11ShaderResourceView*& viewOut);
 
-    void createInputSampler(const InputSamplerDesc & inputDesc, ID3D11SamplerState * & stateOut);
+    void createInputSampler(const InputSamplerDesc& inputDesc, ID3D11SamplerState*& stateOut);
 
     void applyBindingState(bool isCompute);
 
-    IDXGISwapChain* dxSwapChain = nullptr;
-    ID3D11Device* dxDevice = nullptr;
-    ID3D11DeviceContext* dxImmediateContext = nullptr;
-    ID3D11Texture2D* dxBackBufferTexture = nullptr;
-    List<ID3D11RenderTargetView*> dxRenderTargetViews;
-    List<ID3D11Texture2D*> dxRenderTargetTextures;
-    BindingStateImpl* currentBindings = nullptr;
-    float clearColor[4] = { 0, 0, 0, 0 };
+    IDXGISwapChain* m_swapChain = nullptr;
+    ID3D11Device* m_device = nullptr;
+    ID3D11DeviceContext* m_immediateContext = nullptr;
+    ID3D11Texture2D* m_backBufferTexture = nullptr;
+    List<ID3D11RenderTargetView*> m_renderTargetViews;
+    List<ID3D11Texture2D*> m_renderTargetTextures;
+    BindingStateImpl* m_currentBindings = nullptr;
+    float m_clearColor[4] = { 0, 0, 0, 0 };
 };
 
 Renderer* createD3D11Renderer()
@@ -166,19 +160,19 @@ Renderer* createD3D11Renderer()
     // shader bytecode as part of an offline process, rather than doing it
     // on-the-fly like this
     //
-    static pD3DCompile D3DCompile_ = nullptr;
-    if (!D3DCompile_)
+    static pD3DCompile compileFunc = nullptr;
+    if (!compileFunc)
     {
         // TODO(tfoley): maybe want to search for one of a few versions of the DLL
-        HMODULE d3dcompiler = LoadLibraryA("d3dcompiler_47.dll");
-        if (!d3dcompiler)
+        HMODULE compilerModule = LoadLibraryA("d3dcompiler_47.dll");
+        if (!compilerModule)
         {
             fprintf(stderr, "error: failed load 'd3dcompiler_47.dll'\n");
             return nullptr;
         }
 
-        D3DCompile_ = (pD3DCompile)GetProcAddress(d3dcompiler, "D3DCompile");
-        if (!D3DCompile_)
+        compileFunc = (pD3DCompile)GetProcAddress(compilerModule, "D3DCompile");
+        if (!compileFunc)
         {
             fprintf(stderr, "error: failed load symbol 'D3DCompile'\n");
             return nullptr;
@@ -201,34 +195,20 @@ Renderer* createD3D11Renderer()
 
     // The `D3DCompile` entry point takes a bunch of parameters, but we
     // don't really need most of them for Slang-generated code.
-    ID3DBlob* dxShaderBlob = nullptr;
-    ID3DBlob* dxErrorBlob = nullptr;
-    HRESULT hr = D3DCompile_(
-        source,
-        strlen(source),
-        sourcePath,
-        &defines[0],
-        nullptr,
-        entryPointName,
-        dxProfileName,
-        flags,
-        0,
-        &dxShaderBlob,
-        &dxErrorBlob);
+    ID3DBlob* shaderBlob = nullptr;
+    ID3DBlob* errorBlob = nullptr;
+    HRESULT hr = compileFunc(source, strlen(source), sourcePath, &defines[0], nullptr, entryPointName, dxProfileName, flags, 0,
+        &shaderBlob, &errorBlob);
 
     // If the HLSL-to-bytecode compilation produced any diagnostic messages
     // then we will print them out (whether or not the compilation failed).
-    if (dxErrorBlob)
+    if (errorBlob)
     {
-        fputs(
-            (char const*)dxErrorBlob->GetBufferPointer(),
-            stderr);
-        fflush(stderr);
-
-        OutputDebugStringA(
-            (char const*)dxErrorBlob->GetBufferPointer());
+        ::fputs((const char*)errorBlob->GetBufferPointer(), stderr);
+        ::fflush(stderr);
+        ::OutputDebugStringA((const char*)errorBlob->GetBufferPointer());
 
-        dxErrorBlob->Release();
+        errorBlob->Release();
     }
 
     if (FAILED(hr))
@@ -236,67 +216,67 @@ Renderer* createD3D11Renderer()
         return nullptr;
     }
 
-    return dxShaderBlob;
+    return shaderBlob;
 }
 
-/* static */HRESULT D3D11Renderer::captureTextureToFile(ID3D11Device* dxDevice, ID3D11DeviceContext* dxContext,
-    ID3D11Texture2D* dxTexture, char const* outputPath)
+/* static */HRESULT D3D11Renderer::captureTextureToFile(ID3D11Device* device, ID3D11DeviceContext* context,
+    ID3D11Texture2D* texture, char const* outputPath)
 {
-    if (!dxContext) return E_INVALIDARG;
-    if (!dxTexture) return E_INVALIDARG;
+    if (!context) return E_INVALIDARG;
+    if (!texture) return E_INVALIDARG;
 
-    D3D11_TEXTURE2D_DESC dxTextureDesc;
-    dxTexture->GetDesc(&dxTextureDesc);
+    D3D11_TEXTURE2D_DESC textureDesc;
+    texture->GetDesc(&textureDesc);
 
     // Don't bother supporting MSAA for right now
-    if (dxTextureDesc.SampleDesc.Count > 1)
+    if (textureDesc.SampleDesc.Count > 1)
     {
         fprintf(stderr, "ERROR: cannot capture multi-sample texture\n");
         return E_INVALIDARG;
     }
 
     HRESULT hr = S_OK;
-    ID3D11Texture2D* dxStagingTexture = nullptr;
+    ID3D11Texture2D* stagingTexture = nullptr;
 
-    if (dxTextureDesc.Usage == D3D11_USAGE_STAGING && (dxTextureDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
+    if (textureDesc.Usage == D3D11_USAGE_STAGING && (textureDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
     {
-        dxStagingTexture = dxTexture;
-        dxStagingTexture->AddRef();
+        stagingTexture = texture;
+        stagingTexture->AddRef();
     }
     else
     {
         // Modify the descriptor to give us a staging texture
-        dxTextureDesc.BindFlags = 0;
-        dxTextureDesc.MiscFlags &= ~D3D11_RESOURCE_MISC_TEXTURECUBE;
-        dxTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-        dxTextureDesc.Usage = D3D11_USAGE_STAGING;
+        textureDesc.BindFlags = 0;
+        textureDesc.MiscFlags &= ~D3D11_RESOURCE_MISC_TEXTURECUBE;
+        textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+        textureDesc.Usage = D3D11_USAGE_STAGING;
 
-        hr = dxDevice->CreateTexture2D(&dxTextureDesc, 0, &dxStagingTexture);
+        hr = device->CreateTexture2D(&textureDesc, 0, &stagingTexture);
         if (FAILED(hr))
         {
             fprintf(stderr, "ERROR: failed to create staging texture\n");
             return hr;
         }
 
-        dxContext->CopyResource(dxStagingTexture, dxTexture);
+        context->CopyResource(stagingTexture, texture);
     }
 
     // Now just read back texels from the staging textures
 
-    D3D11_MAPPED_SUBRESOURCE dxMappedResource;
-    hr = dxContext->Map(dxStagingTexture, 0, D3D11_MAP_READ, 0, &dxMappedResource);
+    D3D11_MAPPED_SUBRESOURCE mappedResource;
+    hr = context->Map(stagingTexture, 0, D3D11_MAP_READ, 0, &mappedResource);
     if (FAILED(hr))
     {
         fprintf(stderr, "ERROR: failed to map texture for read\n");
         return hr;
     }
 
-    int stbResult = stbi_write_png(outputPath, dxTextureDesc.Width, dxTextureDesc.Height, 4,
-        dxMappedResource.pData, dxMappedResource.RowPitch);
+    int stbResult = stbi_write_png(outputPath, textureDesc.Width, textureDesc.Height, 4,
+        mappedResource.pData, mappedResource.RowPitch);
 
     // Make sure to unmap
-    dxContext->Unmap(dxStagingTexture, 0);
-    dxStagingTexture->Release();
+    context->Unmap(stagingTexture, 0);
+    stagingTexture->Release();
 
     if (!stbResult)
     {
@@ -312,17 +292,17 @@ Renderer* createD3D11Renderer()
 SlangResult D3D11Renderer::initialize(void* inWindowHandle)
 {
     auto windowHandle = (HWND)inWindowHandle;
-    // Rather than statically link against D3D, we load it dynamically.
 
-    HMODULE d3d11 = LoadLibraryA("d3d11.dll");
-    if (!d3d11)
+    // Rather than statically link against D3D, we load it dynamically.
+    HMODULE d3dModule = LoadLibraryA("d3d11.dll");
+    if (!d3dModule)
     {
         fprintf(stderr, "error: failed load 'd3d11.dll'\n");
         return SLANG_FAIL;
     }
 
     PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN D3D11CreateDeviceAndSwapChain_ =
-        (PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)GetProcAddress(d3d11, "D3D11CreateDeviceAndSwapChain");
+        (PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)GetProcAddress(d3dModule, "D3D11CreateDeviceAndSwapChain");
     if (!D3D11CreateDeviceAndSwapChain_)
     {
         fprintf(stderr,
@@ -335,28 +315,26 @@ SlangResult D3D11Renderer::initialize(void* inWindowHandle)
     UINT deviceFlags = 0;
     deviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
 
-
     // Our swap chain uses RGBA8 with sRGB, with double buffering.
-
-    DXGI_SWAP_CHAIN_DESC dxSwapChainDesc = { 0 };
-    dxSwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+    DXGI_SWAP_CHAIN_DESC swapChainDesc = { 0 };
+    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
 
     // Note(tfoley): Disabling sRGB for DX back buffer for now, so that we
     // can get consistent output with OpenGL, where setting up sRGB will
     // probably be more involved.
-    //        dxSwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
-    dxSwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+    // swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
+    swapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
 
-    dxSwapChainDesc.SampleDesc.Count = 1;
-    dxSwapChainDesc.SampleDesc.Quality = 0;
-    dxSwapChainDesc.BufferCount = 2;
-    dxSwapChainDesc.OutputWindow = windowHandle;
-    dxSwapChainDesc.Windowed = TRUE;
-    dxSwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
-    dxSwapChainDesc.Flags = 0;
+    swapChainDesc.SampleDesc.Count = 1;
+    swapChainDesc.SampleDesc.Quality = 0;
+    swapChainDesc.BufferCount = 2;
+    swapChainDesc.OutputWindow = windowHandle;
+    swapChainDesc.Windowed = TRUE;
+    swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+    swapChainDesc.Flags = 0;
 
     // We will ask for the highest feature level that can be supported.
-    D3D_FEATURE_LEVEL featureLevels[] = {
+    const D3D_FEATURE_LEVEL featureLevels[] = {
         D3D_FEATURE_LEVEL_11_1,
         D3D_FEATURE_LEVEL_11_0,
         D3D_FEATURE_LEVEL_10_1,
@@ -365,7 +343,7 @@ SlangResult D3D11Renderer::initialize(void* inWindowHandle)
         D3D_FEATURE_LEVEL_9_2,
         D3D_FEATURE_LEVEL_9_1,
     };
-    D3D_FEATURE_LEVEL dxFeatureLevel = D3D_FEATURE_LEVEL_9_1;
+    D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_9_1;
     const int totalNumFeatureLevels = sizeof(featureLevels) / sizeof(featureLevels[0]);
 
     // On a machine that does not have an up-to-date version of D3D installed,
@@ -386,11 +364,11 @@ SlangResult D3D11Renderer::initialize(void* inWindowHandle)
             &featureLevels[ii],
             totalNumFeatureLevels - ii,
             D3D11_SDK_VERSION,
-            &dxSwapChainDesc,
-            &dxSwapChain,
-            &dxDevice,
-            &dxFeatureLevel,
-            &dxImmediateContext);
+            &swapChainDesc,
+            &m_swapChain,
+            &m_device,
+            &featureLevel,
+            &m_immediateContext);
 
         // Failures with `E_INVALIDARG` might be due to feature level 11_1
         // not being supported. 
@@ -412,68 +390,64 @@ SlangResult D3D11Renderer::initialize(void* inWindowHandle)
         0x6f15aaf2, 0xd208, 0x4e89, 0x9a, 0xb4, 0x48,
         0x95, 0x35, 0xd3, 0x4f, 0x9c };
 
-    SLANG_RETURN_ON_FAIL(dxSwapChain->GetBuffer(0, kIID_ID3D11Texture2D, (void**)&dxBackBufferTexture));
+    SLANG_RETURN_ON_FAIL(m_swapChain->GetBuffer(0, kIID_ID3D11Texture2D, (void**)&m_backBufferTexture));
 
     for (int i = 0; i < 8; i++)
     {
         ID3D11Texture2D* texture;
         D3D11_TEXTURE2D_DESC textureDesc;
-        dxBackBufferTexture->GetDesc(&textureDesc);
-        SLANG_RETURN_ON_FAIL(dxDevice->CreateTexture2D(&textureDesc, nullptr, &texture));
+        m_backBufferTexture->GetDesc(&textureDesc);
+        SLANG_RETURN_ON_FAIL(m_device->CreateTexture2D(&textureDesc, nullptr, &texture));
 
         ID3D11RenderTargetView * rtv;
         D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
         rtvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
         rtvDesc.Texture2D.MipSlice = 0;
         rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
-        SLANG_RETURN_ON_FAIL(dxDevice->CreateRenderTargetView(texture, &rtvDesc, &rtv));
+        SLANG_RETURN_ON_FAIL(m_device->CreateRenderTargetView(texture, &rtvDesc, &rtv));
 
-        dxRenderTargetViews.Add(rtv);
-        dxRenderTargetTextures.Add(texture);
+        m_renderTargetViews.Add(rtv);
+        m_renderTargetTextures.Add(texture);
     }
 
-    dxImmediateContext->OMSetRenderTargets((UINT)dxRenderTargetViews.Count(), dxRenderTargetViews.Buffer(), nullptr);
+    m_immediateContext->OMSetRenderTargets((UINT)m_renderTargetViews.Count(), m_renderTargetViews.Buffer(), nullptr);
 
     // Similarly, we are going to set up a viewport once, and then never
     // switch, since this is a simple test app.
-    D3D11_VIEWPORT dxViewport;
-    dxViewport.TopLeftX = 0;
-    dxViewport.TopLeftY = 0;
-    dxViewport.Width = (float)gWindowWidth;
-    dxViewport.Height = (float)gWindowHeight;
-    dxViewport.MaxDepth = 1; // TODO(tfoley): use reversed depth
-    dxViewport.MinDepth = 0;
-    dxImmediateContext->RSSetViewports(1, &dxViewport);
+    D3D11_VIEWPORT viewport;
+    viewport.TopLeftX = 0;
+    viewport.TopLeftY = 0;
+    viewport.Width = (float)gWindowWidth;
+    viewport.Height = (float)gWindowHeight;
+    viewport.MaxDepth = 1; // TODO(tfoley): use reversed depth
+    viewport.MinDepth = 0;
+    m_immediateContext->RSSetViewports(1, &viewport);
 
     return SLANG_OK;
 }
 
-void D3D11Renderer::setClearColor(float const* color)
+void D3D11Renderer::setClearColor(const float color[4])
 {
-    memcpy(clearColor, color, sizeof(clearColor));
+    memcpy(m_clearColor, color, sizeof(m_clearColor));
 }
 
 void D3D11Renderer::clearFrame()
 {
-    for (auto i = 0u; i < dxRenderTargetViews.Count(); i++)
-        dxImmediateContext->ClearRenderTargetView(
-            dxRenderTargetViews[i],
-            clearColor);
+    for (auto i = 0u; i < m_renderTargetViews.Count(); i++)
+        m_immediateContext->ClearRenderTargetView(
+            m_renderTargetViews[i],
+            m_clearColor);
 }
 
 void D3D11Renderer::presentFrame()
 {
-    dxImmediateContext->CopyResource(dxBackBufferTexture, dxRenderTargetTextures[0]);
-    dxSwapChain->Present(0, 0);
+    m_immediateContext->CopyResource(m_backBufferTexture, m_renderTargetTextures[0]);
+    m_swapChain->Present(0, 0);
 }
 
-SlangResult D3D11Renderer::captureScreenShot(char const* outputPath)
+SlangResult D3D11Renderer::captureScreenShot(const char* outputPath)
 {
-    HRESULT hr = captureTextureToFile(
-        dxDevice,
-        dxImmediateContext,
-        dxRenderTargetTextures[0],
-        outputPath);
+    HRESULT hr = captureTextureToFile(m_device, m_immediateContext, m_renderTargetTextures[0], outputPath);
     if (FAILED(hr))
     {
         fprintf(stderr, "error: could not capture screen-shot to '%s'\n", outputPath);
@@ -487,43 +461,43 @@ ShaderCompiler* D3D11Renderer::getShaderCompiler()
     return this;
 }
 
-Buffer* D3D11Renderer::createBuffer(BufferDesc const& desc)
+Buffer* D3D11Renderer::createBuffer(const BufferDesc& desc)
 {
-    D3D11_BUFFER_DESC dxBufferDesc = { 0 };
-    dxBufferDesc.ByteWidth = (UINT)calcAligned(desc.size, 256);
+    D3D11_BUFFER_DESC bufferDesc = { 0 };
+    bufferDesc.ByteWidth = (UINT)calcAligned(desc.size, 256);
 
     switch (desc.flavor)
     {
         case BufferFlavor::Constant:
-            dxBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
-            dxBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
-            dxBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+            bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+            bufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+            bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
             break;
 
         case BufferFlavor::Vertex:
-            dxBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
-            dxBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
-            dxBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+            bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+            bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
+            bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
             break;
         default:
             return nullptr;
     }
 
-    D3D11_SUBRESOURCE_DATA dxInitData = { 0 };
-    dxInitData.pSysMem = desc.initData;
+    D3D11_SUBRESOURCE_DATA subResourceData = { 0 };
+    subResourceData.pSysMem = desc.initData;
 
-    ID3D11Buffer* dxBuffer = nullptr;
-    HRESULT hr = dxDevice->CreateBuffer(&dxBufferDesc, desc.initData ? &dxInitData : nullptr, &dxBuffer);
+    ID3D11Buffer* buffer = nullptr;
+    HRESULT hr = m_device->CreateBuffer(&bufferDesc, desc.initData ? &subResourceData : nullptr, &buffer);
     if (FAILED(hr)) return nullptr;
 
     BufferImpl* rs = new BufferImpl;
-    rs->buffer = dxBuffer;
+    rs->buffer = buffer;
     return (Buffer*)rs;
 }
 
-InputLayout* D3D11Renderer::createInputLayout(InputElementDesc const* inputElements, UInt inputElementCount)
+InputLayout* D3D11Renderer::createInputLayout(const InputElementDesc* inputElementsIn, UInt inputElementCount)
 {
-    D3D11_INPUT_ELEMENT_DESC dxInputElements[16] = {};
+    D3D11_INPUT_ELEMENT_DESC inputElements[16] = {};
 
     char hlslBuffer[1024];
     char* hlslCursor = &hlslBuffer[0];
@@ -532,13 +506,13 @@ InputLayout* D3D11Renderer::createInputLayout(InputElementDesc const* inputEleme
 
     for (UInt ii = 0; ii < inputElementCount; ++ii)
     {
-        dxInputElements[ii].SemanticName = inputElements[ii].semanticName;
-        dxInputElements[ii].SemanticIndex = (UINT)inputElements[ii].semanticIndex;
-        dxInputElements[ii].Format = getMapFormat(inputElements[ii].format);
-        dxInputElements[ii].InputSlot = 0;
-        dxInputElements[ii].AlignedByteOffset = (UINT)inputElements[ii].offset;
-        dxInputElements[ii].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
-        dxInputElements[ii].InstanceDataStepRate = 0;
+        inputElements[ii].SemanticName = inputElementsIn[ii].semanticName;
+        inputElements[ii].SemanticIndex = (UINT)inputElementsIn[ii].semanticIndex;
+        inputElements[ii].Format = getMapFormat(inputElementsIn[ii].format);
+        inputElements[ii].InputSlot = 0;
+        inputElements[ii].AlignedByteOffset = (UINT)inputElementsIn[ii].offset;
+        inputElements[ii].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
+        inputElements[ii].InstanceDataStepRate = 0;
 
         if (ii != 0)
         {
@@ -546,7 +520,7 @@ InputLayout* D3D11Renderer::createInputLayout(InputElementDesc const* inputEleme
         }
 
         char const* typeName = "Unknown";
-        switch (inputElements[ii].format)
+        switch (inputElementsIn[ii].format)
         {
             case Format::RGB_Float32:
                 typeName = "float3";
@@ -561,49 +535,41 @@ InputLayout* D3D11Renderer::createInputLayout(InputElementDesc const* inputEleme
         hlslCursor += sprintf(hlslCursor, "%s a%d : %s%d",
             typeName,
             (int)ii,
-            inputElements[ii].semanticName,
-            (int)inputElements[ii].semanticIndex);
+            inputElementsIn[ii].semanticName,
+            (int)inputElementsIn[ii].semanticIndex);
     }
 
     hlslCursor += sprintf(hlslCursor, "\n) : SV_Position { return 0; }");
 
-    auto dxVertexShaderBlob = compileHLSLShader("inputLayout", hlslBuffer, "main", "vs_5_0");
-    if (!dxVertexShaderBlob)
+    auto vertexShaderBlob = compileHLSLShader("inputLayout", hlslBuffer, "main", "vs_5_0");
+    if (!vertexShaderBlob)
         return nullptr;
 
-    ID3D11InputLayout* dxInputLayout = nullptr;
-    HRESULT hr = dxDevice->CreateInputLayout(
-        &dxInputElements[0],
-        (UINT)inputElementCount,
-        dxVertexShaderBlob->GetBufferPointer(),
-        dxVertexShaderBlob->GetBufferSize(),
-        &dxInputLayout);
+    ID3D11InputLayout* inputLayout = nullptr;
+    HRESULT hr = m_device->CreateInputLayout(&inputElements[0], (UINT)inputElementCount, vertexShaderBlob->GetBufferPointer(), vertexShaderBlob->GetBufferSize(),
+        &inputLayout);
 
-    dxVertexShaderBlob->Release();
+    vertexShaderBlob->Release();
 
     if (FAILED(hr))
         return nullptr;
 
-    return (InputLayout*)dxInputLayout;
+    return (InputLayout*)inputLayout;
 }
 
-void* D3D11Renderer::map(ID3D11Buffer * buffer, MapFlavor flavor)
+void* D3D11Renderer::map(ID3D11Buffer* buffer, MapFlavor flavorIn)
 {
-    auto dxContext = dxImmediateContext;
-
-    auto dxBuffer = buffer;
-
-    D3D11_MAP dxMapFlavor;
-    switch (flavor)
+    D3D11_MAP mapType;
+    switch (flavorIn)
     {
         case MapFlavor::WriteDiscard:
-            dxMapFlavor = D3D11_MAP_WRITE_DISCARD;
+            mapType = D3D11_MAP_WRITE_DISCARD;
             break;
         case MapFlavor::HostWrite:
-            dxMapFlavor = D3D11_MAP_WRITE;
+            mapType = D3D11_MAP_WRITE;
             break;
         case MapFlavor::HostRead:
-            dxMapFlavor = D3D11_MAP_READ;
+            mapType = D3D11_MAP_READ;
             break;
         default:
             return nullptr;
@@ -612,12 +578,12 @@ void* D3D11Renderer::map(ID3D11Buffer * buffer, MapFlavor flavor)
     // We update our constant buffer per-frame, just for the purposes
     // of the example, but we don't actually load different data
     // per-frame (we always use an identity projection).
-    D3D11_MAPPED_SUBRESOURCE dxMapped;
-    HRESULT hr = dxContext->Map(dxBuffer, 0, dxMapFlavor, 0, &dxMapped);
+    D3D11_MAPPED_SUBRESOURCE mappedSub;
+    HRESULT hr = m_immediateContext->Map(buffer, 0, mapType, 0, &mappedSub);
     if (FAILED(hr))
         return nullptr;
 
-    return dxMapped.pData;
+    return mappedSub.pData;
 }
 
 void* D3D11Renderer::map(Buffer* buffer, MapFlavor flavor)
@@ -625,152 +591,136 @@ void* D3D11Renderer::map(Buffer* buffer, MapFlavor flavor)
     return map(((BufferImpl*)buffer)->buffer, flavor);
 }
 
-void D3D11Renderer::unmap(ID3D11Buffer * buffer)
+void D3D11Renderer::unmap(ID3D11Buffer* buffer)
 {
-    auto dxContext = dxImmediateContext;
-    dxContext->Unmap(buffer, 0);
+    m_immediateContext->Unmap(buffer, 0);
 }
 
-void D3D11Renderer::unmap(Buffer* buffer)
+void D3D11Renderer::unmap(Buffer* bufferIn)
 {
-    auto dxBuffer = ((BufferImpl*)buffer)->buffer;
-    unmap(dxBuffer);
+    unmap(((BufferImpl*)bufferIn)->buffer);
 }
 
-void D3D11Renderer::setInputLayout(InputLayout* inputLayout)
+void D3D11Renderer::setInputLayout(InputLayout* inputLayoutIn)
 {
-    auto dxContext = dxImmediateContext;
-    auto dxInputLayout = (ID3D11InputLayout*)inputLayout;
+    auto inputLayout = (ID3D11InputLayout*)inputLayoutIn;
 
-    dxContext->IASetInputLayout(dxInputLayout);
+    m_immediateContext->IASetInputLayout(inputLayout);
 }
 
 void D3D11Renderer::setPrimitiveTopology(PrimitiveTopology topology)
 {
-    auto dxContext = dxImmediateContext;
-
-    D3D11_PRIMITIVE_TOPOLOGY dxTopology;
+    D3D11_PRIMITIVE_TOPOLOGY primTopology;
     switch (topology)
     {
         case PrimitiveTopology::TriangleList:
-            dxTopology = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
+            primTopology = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
             break;
 
         default:
             return;
     }
 
-    dxContext->IASetPrimitiveTopology(dxTopology);
+    m_immediateContext->IASetPrimitiveTopology(primTopology);
 }
 
-void D3D11Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* strides, UInt const* offsets)
+void D3D11Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffersIn, const UInt* stridesIn, const UInt* offsetsIn)
 {
-    auto dxContext = dxImmediateContext;
-
     static const int kMaxVertexBuffers = 16;
 
-    UINT dxVertexStrides[kMaxVertexBuffers];
-    UINT dxVertexOffsets[kMaxVertexBuffers];
+    UINT vertexStrides[kMaxVertexBuffers];
+    UINT vertexOffsets[kMaxVertexBuffers];
 
     for (UInt ii = 0; ii < slotCount; ++ii)
     {
-        dxVertexStrides[ii] = (UINT)strides[ii];
-        dxVertexOffsets[ii] = (UINT)offsets[ii];
+        vertexStrides[ii] = (UINT)stridesIn[ii];
+        vertexOffsets[ii] = (UINT)offsetsIn[ii];
     }
 
-    auto dxVertexBuffers = (BufferImpl* const*)buffers;
+    auto buffers = (BufferImpl* const*)buffersIn;
 
-    dxContext->IASetVertexBuffers(
-        (UINT)startSlot,
-        (UINT)slotCount, &(dxVertexBuffers[0])->buffer, &dxVertexStrides[0], &dxVertexOffsets[0]);
+    m_immediateContext->IASetVertexBuffers((UINT)startSlot, (UINT)slotCount, &(buffers[0])->buffer, &vertexStrides[0], &vertexOffsets[0]);
 }
 
-void D3D11Renderer::setShaderProgram(ShaderProgram* inProgram)
+void D3D11Renderer::setShaderProgram(ShaderProgram* programIn)
 {
-    auto dxContext = dxImmediateContext;
-
-    auto program = (ShaderProgramImpl*)inProgram;
-    dxContext->CSSetShader(program->dxComputeShader, nullptr, 0);
-    dxContext->VSSetShader(program->dxVertexShader, nullptr, 0);
-    dxContext->PSSetShader(program->dxPixelShader, nullptr, 0);
+    auto program = (ShaderProgramImpl*)programIn;
+    m_immediateContext->CSSetShader(program->computeShader, nullptr, 0);
+    m_immediateContext->VSSetShader(program->vertexShader, nullptr, 0);
+    m_immediateContext->PSSetShader(program->pixelShader, nullptr, 0);
 }
 
-void D3D11Renderer::setConstantBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets)
+void D3D11Renderer::setConstantBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffersIn, const UInt* offsetsIn)
 {
-    auto dxContext = dxImmediateContext;
-
     // TODO: actually use those offsets
 
-    auto dxConstantBuffers = (BufferImpl* const*)buffers;
-    dxContext->VSSetConstantBuffers((UINT)startSlot, (UINT)slotCount, &dxConstantBuffers[0]->buffer);
-    dxContext->VSSetConstantBuffers((UINT)startSlot, (UINT)slotCount, &dxConstantBuffers[0]->buffer);
+    auto buffers = (BufferImpl*const*)buffersIn;
+    m_immediateContext->VSSetConstantBuffers((UINT)startSlot, (UINT)slotCount, &buffers[0]->buffer);
+    m_immediateContext->VSSetConstantBuffers((UINT)startSlot, (UINT)slotCount, &buffers[0]->buffer);
 }
 
 void D3D11Renderer::draw(UInt vertexCount, UInt startVertex)
 {
-    auto dxContext = dxImmediateContext;
     applyBindingState(false);
-    dxContext->Draw((UINT)vertexCount, (UINT)startVertex);
+    m_immediateContext->Draw((UINT)vertexCount, (UINT)startVertex);
 }
 
-ShaderProgram* D3D11Renderer::compileProgram(ShaderCompileRequest const& request)
+ShaderProgram* D3D11Renderer::compileProgram(const ShaderCompileRequest& request)
 {
     if (request.computeShader.name)
     {
-        auto dxComputeShaderBlob = compileHLSLShader(request.computeShader.source.path, request.computeShader.source.dataBegin, request.computeShader.name, request.computeShader.profile);
-        if (!dxComputeShaderBlob)
+        auto computeShaderBlob = compileHLSLShader(request.computeShader.source.path, request.computeShader.source.dataBegin, request.computeShader.name, request.computeShader.profile);
+        if (!computeShaderBlob)
             return nullptr;
 
-        ID3D11ComputeShader* dxComputeShader;
+        ID3D11ComputeShader* computeShader;
 
-        HRESULT csResult = dxDevice->CreateComputeShader(dxComputeShaderBlob->GetBufferPointer(), dxComputeShaderBlob->GetBufferSize(), nullptr, &dxComputeShader);
+        HRESULT hr = m_device->CreateComputeShader(computeShaderBlob->GetBufferPointer(), computeShaderBlob->GetBufferSize(), nullptr, &computeShader);
 
-        dxComputeShaderBlob->Release();
+        computeShaderBlob->Release();
 
-        if (FAILED(csResult)) return nullptr;
+        if (FAILED(hr)) return nullptr;
 
         ShaderProgramImpl* shaderProgram = new ShaderProgramImpl();
-        shaderProgram->dxComputeShader = dxComputeShader;
+        shaderProgram->computeShader = computeShader;
         return (ShaderProgram*)shaderProgram;
     }
     else
     {
-        auto dxVertexShaderBlob = compileHLSLShader(request.vertexShader.source.path, request.vertexShader.source.dataBegin, request.vertexShader.name, request.vertexShader.profile);
-        if (!dxVertexShaderBlob)     return nullptr;
+        auto vertexShaderBlob = compileHLSLShader(request.vertexShader.source.path, request.vertexShader.source.dataBegin, request.vertexShader.name, request.vertexShader.profile);
+        if (!vertexShaderBlob)     return nullptr;
 
-        auto dxFragmentShaderBlob = compileHLSLShader(request.fragmentShader.source.path, request.fragmentShader.source.dataBegin, request.fragmentShader.name, request.fragmentShader.profile);
-        if (!dxFragmentShaderBlob)   return nullptr;
+        auto fragmentShaderBlob = compileHLSLShader(request.fragmentShader.source.path, request.fragmentShader.source.dataBegin, request.fragmentShader.name, request.fragmentShader.profile);
+        if (!fragmentShaderBlob)   return nullptr;
 
-        ID3D11VertexShader* dxVertexShader;
-        ID3D11PixelShader*  dxPixelShader;
+        ID3D11VertexShader* vertexShader;
+        ID3D11PixelShader*  pixelShader;
 
-        HRESULT vsResult = dxDevice->CreateVertexShader(dxVertexShaderBlob->GetBufferPointer(), dxVertexShaderBlob->GetBufferSize(), nullptr, &dxVertexShader);
-        HRESULT psResult = dxDevice->CreatePixelShader(dxFragmentShaderBlob->GetBufferPointer(), dxFragmentShaderBlob->GetBufferSize(), nullptr, &dxPixelShader);
+        HRESULT vsResult = m_device->CreateVertexShader(vertexShaderBlob->GetBufferPointer(), vertexShaderBlob->GetBufferSize(), nullptr, &vertexShader);
+        HRESULT psResult = m_device->CreatePixelShader(fragmentShaderBlob->GetBufferPointer(), fragmentShaderBlob->GetBufferSize(), nullptr, &pixelShader);
 
-        dxVertexShaderBlob->Release();
-        dxFragmentShaderBlob->Release();
+        vertexShaderBlob->Release();
+        fragmentShaderBlob->Release();
 
         if (FAILED(vsResult)) return nullptr;
         if (FAILED(psResult)) return nullptr;
 
         ShaderProgramImpl* shaderProgram = new ShaderProgramImpl();
-        shaderProgram->dxVertexShader = dxVertexShader;
-        shaderProgram->dxPixelShader = dxPixelShader;
+        shaderProgram->vertexShader = vertexShader;
+        shaderProgram->pixelShader = pixelShader;
         return (ShaderProgram*)shaderProgram;
     }
 }
 
 void D3D11Renderer::dispatchCompute(int x, int y, int z)
 {
-    auto dxContext = dxImmediateContext;
     applyBindingState(true);
-    dxContext->Dispatch(x, y, z);
+    m_immediateContext->Dispatch(x, y, z);
 }
 
-void D3D11Renderer::createInputBuffer(InputBufferDesc & bufferDesc,    List<unsigned int> & bufferData, ID3D11Buffer * &bufferOut,
-    ID3D11UnorderedAccessView * &viewOut, ID3D11ShaderResourceView * &srvOut)
+void D3D11Renderer::createInputBuffer(InputBufferDesc& bufferDesc, List<unsigned int>& bufferData, ID3D11Buffer*& bufferOut,
+    ID3D11UnorderedAccessView*& viewOut, ID3D11ShaderResourceView*& srvOut)
 {
-    auto dxContext = dxImmediateContext;
     D3D11_BUFFER_DESC desc = { 0 };
     List<unsigned int> newBuffer;
     desc.ByteWidth = (UINT)calcAligned((bufferData.Count() * sizeof(unsigned int)), 256);
@@ -798,7 +748,7 @@ void D3D11Renderer::createInputBuffer(InputBufferDesc & bufferDesc,    List<unsi
     }
     D3D11_SUBRESOURCE_DATA data = { 0 };
     data.pSysMem = newBuffer.Buffer();
-    dxDevice->CreateBuffer(&desc, &data, &bufferOut);
+    m_device->CreateBuffer(&desc, &data, &bufferOut);
     int elemSize = bufferDesc.stride <= 0 ? 1 : bufferDesc.stride;
     if (bufferDesc.type == InputBufferType::StorageBuffer)
     {
@@ -819,7 +769,7 @@ void D3D11Renderer::createInputBuffer(InputBufferDesc & bufferDesc,    List<unsi
             viewDesc.Format = DXGI_FORMAT_R32_TYPELESS;
         }
 
-        dxDevice->CreateUnorderedAccessView(bufferOut, &viewDesc, &viewOut);
+        m_device->CreateUnorderedAccessView(bufferOut, &viewDesc, &viewOut);
     }
     if (bufferDesc.type != InputBufferType::ConstantBuffer)
     {
@@ -831,11 +781,11 @@ void D3D11Renderer::createInputBuffer(InputBufferDesc & bufferDesc,    List<unsi
         srvDesc.Buffer.ElementOffset = 0;
         srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
         srvDesc.Format = DXGI_FORMAT_UNKNOWN;
-        dxDevice->CreateShaderResourceView(bufferOut, &srvDesc, &srvOut);
+        m_device->CreateShaderResourceView(bufferOut, &srvDesc, &srvOut);
     }
 }
 
-void D3D11Renderer::createInputTexture(const InputTextureDesc & inputDesc, ID3D11ShaderResourceView * &viewOut)
+void D3D11Renderer::createInputTexture(const InputTextureDesc& inputDesc, ID3D11ShaderResourceView*& viewOut)
 {
     TextureData texData;
     generateTextureData(texData, inputDesc);
@@ -867,7 +817,7 @@ void D3D11Renderer::createInputTexture(const InputTextureDesc & inputDesc, ID3D1
         desc.Usage = D3D11_USAGE_DEFAULT;
 
         ID3D11Texture1D * texture;
-        dxDevice->CreateTexture1D(&desc, subRes.Buffer(), &texture);
+        m_device->CreateTexture1D(&desc, subRes.Buffer(), &texture);
         D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc;
 
         viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
@@ -880,7 +830,7 @@ void D3D11Renderer::createInputTexture(const InputTextureDesc & inputDesc, ID3D1
         viewDesc.Texture1DArray.MipLevels = texData.mipLevels;
         viewDesc.Texture1DArray.MostDetailedMip = 0;
         viewDesc.Format = desc.Format;
-        dxDevice->CreateShaderResourceView(texture, &viewDesc, &viewOut);
+        m_device->CreateShaderResourceView(texture, &viewDesc, &viewOut);
     }
     else if (inputDesc.dimension == 2)
     {
@@ -922,8 +872,8 @@ void D3D11Renderer::createInputTexture(const InputTextureDesc & inputDesc, ID3D1
         desc.SampleDesc.Quality = 0;
         viewDesc.Format = desc.Format;
         ID3D11Texture2D * texture;
-        dxDevice->CreateTexture2D(&desc, subRes.Buffer(), &texture);
-        dxDevice->CreateShaderResourceView(texture, &viewDesc, &viewOut);
+        m_device->CreateTexture2D(&desc, subRes.Buffer(), &texture);
+        m_device->CreateShaderResourceView(texture, &viewDesc, &viewOut);
     }
     else if (inputDesc.dimension == 3)
     {
@@ -940,15 +890,15 @@ void D3D11Renderer::createInputTexture(const InputTextureDesc & inputDesc, ID3D1
         desc.Depth = texData.textureSize;
         desc.Usage = D3D11_USAGE_DEFAULT;
         ID3D11Texture3D * texture;
-        dxDevice->CreateTexture3D(&desc, subRes.Buffer(), &texture);
+        m_device->CreateTexture3D(&desc, subRes.Buffer(), &texture);
         viewDesc.Texture3D.MipLevels = 1;
         viewDesc.Texture3D.MostDetailedMip = 0;
         viewDesc.Format = desc.Format;
-        dxDevice->CreateShaderResourceView(texture, &viewDesc, &viewOut);
+        m_device->CreateShaderResourceView(texture, &viewDesc, &viewOut);
     }
 }
 
-void D3D11Renderer::createInputSampler(const InputSamplerDesc & inputDesc, ID3D11SamplerState * & stateOut)
+void D3D11Renderer::createInputSampler(const InputSamplerDesc& inputDesc, ID3D11SamplerState*& stateOut)
 {
     D3D11_SAMPLER_DESC desc;
     memset(&desc, 0, sizeof(desc));
@@ -966,12 +916,12 @@ void D3D11Renderer::createInputSampler(const InputSamplerDesc & inputDesc, ID3D1
         desc.MinLOD = 0.0f;
         desc.MaxLOD = 100.0f;
     }
-    dxDevice->CreateSamplerState(&desc, &stateOut);
+    m_device->CreateSamplerState(&desc, &stateOut);
 }
 
 BindingState * D3D11Renderer::createBindingState(const ShaderInputLayout& layout)
 {
-    BindingStateImpl * rs = new BindingStateImpl();
+    BindingStateImpl * rs = new BindingStateImpl;
     rs->numRenderTargets = layout.numRenderTargets;
     for (auto & entry : layout.entries)
     {
@@ -1012,37 +962,37 @@ BindingState * D3D11Renderer::createBindingState(const ShaderInputLayout& layout
 
 void D3D11Renderer::applyBindingState(bool isCompute)
 {
-    auto dxContext = dxImmediateContext;
-    for (auto & binding : currentBindings->bindings)
+    auto context = m_immediateContext;
+    for (auto & binding : m_currentBindings->bindings)
     {
         if (binding.type == ShaderInputType::Buffer)
         {
             if (binding.bufferType == InputBufferType::ConstantBuffer)
             {
                 if (isCompute)
-                    dxContext->CSSetConstantBuffers(binding.binding, 1, &binding.buffer);
+                    context->CSSetConstantBuffers(binding.binding, 1, &binding.buffer);
                 else
                 {
-                    dxContext->VSSetConstantBuffers(binding.binding, 1, &binding.buffer);
-                    dxContext->PSSetConstantBuffers(binding.binding, 1, &binding.buffer);
+                    context->VSSetConstantBuffers(binding.binding, 1, &binding.buffer);
+                    context->PSSetConstantBuffers(binding.binding, 1, &binding.buffer);
                 }
             }
             else if (binding.uav)
             {
                 if (isCompute)
-                    dxContext->CSSetUnorderedAccessViews(binding.binding, 1, &binding.uav, nullptr);
+                    context->CSSetUnorderedAccessViews(binding.binding, 1, &binding.uav, nullptr);
                 else
-                    dxContext->OMSetRenderTargetsAndUnorderedAccessViews(currentBindings->numRenderTargets,
-                        dxRenderTargetViews.Buffer(), nullptr, binding.binding, 1, &binding.uav, nullptr);
+                    context->OMSetRenderTargetsAndUnorderedAccessViews(m_currentBindings->numRenderTargets,
+                        m_renderTargetViews.Buffer(), nullptr, binding.binding, 1, &binding.uav, nullptr);
             }
             else
             {
                 if (isCompute)
-                    dxContext->CSSetShaderResources(binding.binding, 1, &binding.srv);
+                    context->CSSetShaderResources(binding.binding, 1, &binding.srv);
                 else
                 {
-                    dxContext->PSSetShaderResources(binding.binding, 1, &binding.srv);
-                    dxContext->VSSetShaderResources(binding.binding, 1, &binding.srv);
+                    context->PSSetShaderResources(binding.binding, 1, &binding.srv);
+                    context->VSSetShaderResources(binding.binding, 1, &binding.srv);
                 }
             }
         }
@@ -1051,30 +1001,30 @@ void D3D11Renderer::applyBindingState(bool isCompute)
             if (binding.uav)
             {
                 if (isCompute)
-                    dxContext->CSSetUnorderedAccessViews(binding.binding, 1, &binding.uav, nullptr);
+                    context->CSSetUnorderedAccessViews(binding.binding, 1, &binding.uav, nullptr);
                 else
-                    dxContext->OMSetRenderTargetsAndUnorderedAccessViews(D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL,
+                    context->OMSetRenderTargetsAndUnorderedAccessViews(D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL,
                         nullptr, nullptr, binding.binding, 1, &binding.uav, nullptr);
             }
             else
             {
                 if (isCompute)
-                    dxContext->CSSetShaderResources(binding.binding, 1, &binding.srv);
+                    context->CSSetShaderResources(binding.binding, 1, &binding.srv);
                 else
                 {
-                    dxContext->PSSetShaderResources(binding.binding, 1, &binding.srv);
-                    dxContext->VSSetShaderResources(binding.binding, 1, &binding.srv);
+                    context->PSSetShaderResources(binding.binding, 1, &binding.srv);
+                    context->VSSetShaderResources(binding.binding, 1, &binding.srv);
                 }
             }
         }
         else if (binding.type == ShaderInputType::Sampler)
         {
             if (isCompute)
-                dxContext->CSSetSamplers(binding.binding, 1, &binding.samplerState);
+                context->CSSetSamplers(binding.binding, 1, &binding.samplerState);
             else
             {
-                dxContext->PSSetSamplers(binding.binding, 1, &binding.samplerState);
-                dxContext->VSSetSamplers(binding.binding, 1, &binding.samplerState);
+                context->PSSetSamplers(binding.binding, 1, &binding.samplerState);
+                context->VSSetSamplers(binding.binding, 1, &binding.samplerState);
             }
         }
         else
@@ -1084,17 +1034,15 @@ void D3D11Renderer::applyBindingState(bool isCompute)
 
 void D3D11Renderer::setBindingState(BindingState* state)
 {
-    auto dxBindingState = (BindingStateImpl*)state;
-    currentBindings = dxBindingState;
+    m_currentBindings = (BindingStateImpl*)state;
 }
 
 void D3D11Renderer::serializeOutput(BindingState* state, const char* fileName)
 {
-    auto dxContext = dxImmediateContext;
-    auto dxBindingState = (BindingStateImpl*)state;
+    auto bindingState = (BindingStateImpl*)state;
     FILE * f = fopen(fileName, "wb");
     int id = 0;
-    for (auto & binding : dxBindingState->bindings)
+    for (auto & binding : bindingState->bindings)
     {
         if (binding.isOutput)
         {
@@ -1108,8 +1056,10 @@ void D3D11Renderer::serializeOutput(BindingState* state, const char* fileName)
                 bufDesc.ByteWidth = (UINT)calcAligned(binding.bufferLength, 256);
                 bufDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
                 bufDesc.Usage = D3D11_USAGE_STAGING;
-                dxDevice->CreateBuffer(&bufDesc, nullptr, &stageBuf);
-                dxContext->CopyResource(stageBuf, binding.buffer);
+                
+                m_device->CreateBuffer(&bufDesc, nullptr, &stageBuf);
+                m_immediateContext->CopyResource(stageBuf, binding.buffer);
+
                 auto ptr = (unsigned int *)map(stageBuf, MapFlavor::HostRead);
                 for (auto i = 0u; i < binding.bufferLength / sizeof(unsigned int); i++)
                     fprintf(f, "%X\n", ptr[i]);