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

8 files changed, 475 insertions, 554 deletions

diff --git a/source/core/list.h b/source/core/list.h
index 68563f20c..6c4a04fc7 100644
--- a/source/core/list.h
+++ b/source/core/list.h
@@ -4,6 +4,7 @@
 #include "allocator.h"
 #include "slang-math.h"
 #include "array-view.h"
+#include "slang-defines.h"
 
 #include <algorithm>
 #include <new>
@@ -29,6 +30,17 @@ namespace Slang
 				new (buffer + i) T();
 		}
 	};
+    template<typename T>
+    class Initializer<T, 1>
+    {
+    public:
+        static void Initialize(T * buffer, int size)
+        {
+            // It's pod so no initialization required
+            //for (int i = 0; i < size; i++)
+            //    new (buffer + i) T;
+        }
+    };
 
 	template<typename T, typename TAllocator>
 	class AllocateMethod
@@ -67,16 +79,6 @@ namespace Slang
 		}
 	};
 
-	template<typename T>
-	class Initializer<T, 1>
-	{
-	public:
-		static void Initialize(T * buffer, int size)
-		{
-			for (int i = 0; i<size; i++)
-				new (buffer + i) T;
-		}
-	};
 
 	template<typename T, typename TAllocator = StandardAllocator>
 	class List
@@ -201,10 +203,10 @@ namespace Slang
 			T* tmpBuffer = this->buffer;
 			this->buffer = other.buffer;
 			other.buffer = tmpBuffer;
-			int tmpBufferSize = this->bufferSize;
+			auto tmpBufferSize = this->bufferSize;
 			this->bufferSize = other.bufferSize;
 			other.bufferSize = tmpBufferSize;
-			int tmpCount = this->_count;
+			auto tmpCount = this->_count;
 			this->_count = other._count;
 			other._count = tmpCount;
 			TAllocator tmpAlloc = _Move(this->allocator);
@@ -468,15 +470,7 @@ namespace Slang
 			}
 		}
 
-#ifndef FORCE_INLINE
-#ifdef _MSC_VER
-#define FORCE_INLINE __forceinline
-#else
-#define FORCE_INLINE inline
-#endif
-#endif
-
-		FORCE_INLINE T & operator [](UInt id) const
+		SLANG_FORCE_INLINE T & operator [](UInt id) const
 		{
 #if _DEBUG
 			if(id >= _count)
diff --git a/source/core/slang-result.h b/source/core/slang-result.h
index da88c18b2..767d2c737 100644
--- a/source/core/slang-result.h
+++ b/source/core/slang-result.h
@@ -115,6 +115,8 @@ It can be useful to have a consistent short name for a facility, as used in the
 #define SLANG_RETURN_VOID_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return; } }
 //! Helper macro that will return false on failure.
 #define SLANG_RETURN_FALSE_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return false; } }
+//! Helper macro that will return nullptr on failure.
+#define SLANG_RETURN_NULL_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return nullptr; } }
 
 //! Helper macro that will assert if the return code from a call is failure, also returns the failure.
 #define SLANG_ASSERT_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { assert(false); return _res; } }
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]);
diff --git a/tools/render-test/render-d3d12.cpp b/tools/render-test/render-d3d12.cpp
index d481d7084..ed0ae93cb 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"
@@ -40,11 +40,11 @@ namespace renderer_test {
 // The Slang compiler currently generates HLSL source, so we'll need a utility
 // routine (defined later) to translate that into D3D11 shader bytecode.
 // Returns nullptr if compilation fails.
-ID3DBlob* compileHLSLShader(
+/* ID3DBlob* compileHLSLShader(
     char const* sourcePath,
     char const* source,
     char const* entryPointName,
-    char const* dxProfileName);
+    char const* dxProfileName); */
 
 //static char const* vertexProfileName   = "vs_4_0";
 //static char const* fragmentProfileName = "ps_4_0";
@@ -55,36 +55,36 @@ class D3D12Renderer : 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 BindingState * createBindingState(const ShaderInputLayout & layout) override;
+    virtual SlangResult captureScreenShot(const char* outputPath) 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;
     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 setBindingState(BindingState* state);
+    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;
 
     // ShaderCompiler implementation
-    virtual ShaderProgram* compileProgram(ShaderCompileRequest const& request) override;
+    virtual ShaderProgram* compileProgram(const ShaderCompileRequest& 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;
+    float m_clearColor[4] = { 0, 0, 0, 0 };
+    IDXGISwapChain* m_swapChain = nullptr;
+    ID3D12Device* m_device = nullptr;
 };
 
 Renderer* createD3D12Renderer()
@@ -123,15 +123,15 @@ 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)
+    HMODULE d3dModule = LoadLibraryA("d3d12.dll");
+    if (!d3dModule)
     {
         fprintf(stderr, "error: failed load 'd3d12.dll'\n");
         return SLANG_FAIL;
     }
 
 #define LOAD_PROC(TYPE, NAME) \
-        TYPE NAME##_ = (TYPE) loadProc(d3d12, #NAME); \
+        TYPE NAME##_ = (TYPE) loadProc(d3dModule, #NAME); \
         if (NAME##_ == nullptr) return SLANG_FAIL;
 
     UINT dxgiFactoryFlags = 0;
@@ -176,7 +176,7 @@ SlangResult D3D12Renderer::initialize(void* inWindowHandle)
         {
             // TODO: may want to allow software driver as fallback
         }
-        else if (SUCCEEDED(D3D12CreateDevice_(candidateAdapter, featureLevel, IID_PPV_ARGS(&dxDevice))))
+        else if (SUCCEEDED(D3D12CreateDevice_(candidateAdapter, featureLevel, IID_PPV_ARGS(&m_device))))
         {
             // We found one!
             adapter = candidateAdapter;
@@ -197,7 +197,7 @@ SlangResult D3D12Renderer::initialize(void* inWindowHandle)
     queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
 
     ID3D12CommandQueue* commandQueue;
-    SLANG_RETURN_ON_FAIL(dxDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&commandQueue)));
+    SLANG_RETURN_ON_FAIL(m_device->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&commandQueue)));
 
     // Swap Chain
     UINT frameCount = 2; // TODO: configure
@@ -229,9 +229,9 @@ SlangResult D3D12Renderer::initialize(void* inWindowHandle)
     rtvHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
 
     ID3D12DescriptorHeap* rtvHeap;
-    SLANG_RETURN_ON_FAIL(dxDevice->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&rtvHeap)));
+    SLANG_RETURN_ON_FAIL(m_device->CreateDescriptorHeap(&rtvHeapDesc, IID_PPV_ARGS(&rtvHeap)));
 
-    UINT rtvDescriptorSize = dxDevice->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+    UINT rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
 
     D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = rtvHeap->GetCPUDescriptorHandleForHeapStart();
 
@@ -240,18 +240,18 @@ SlangResult D3D12Renderer::initialize(void* inWindowHandle)
     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);
+        m_device->CreateRenderTargetView(backBufferResources[ff], nullptr, rtvHandle);
         rtvHandle.ptr += rtvDescriptorSize;
     }
 
     ID3D12CommandAllocator* commandAllocator;
-    SLANG_RETURN_ON_FAIL(dxDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&commandAllocator)));
+    SLANG_RETURN_ON_FAIL(m_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&commandAllocator)));
     return SLANG_OK;
 }
 
-void D3D12Renderer::setClearColor(float const* color)
+void D3D12Renderer::setClearColor(const float color[4])
 {
-    memcpy(clearColor, color, sizeof(clearColor));
+    memcpy(m_clearColor, color, sizeof(m_clearColor));
 }
 
 void D3D12Renderer::clearFrame()
@@ -262,7 +262,7 @@ void D3D12Renderer::presentFrame()
 {
 }
 
-SlangResult D3D12Renderer::captureScreenShot(char const* outputPath)
+SlangResult D3D12Renderer::captureScreenShot(const char* outputPath)
 {
     return SLANG_FAIL;
 }
@@ -272,13 +272,13 @@ ShaderCompiler* D3D12Renderer::getShaderCompiler()
     return this;
 }
 
-Buffer* D3D12Renderer::createBuffer(BufferDesc const& desc)
+Buffer* D3D12Renderer::createBuffer(const BufferDesc& desc)
 {
     return nullptr;
 }
 
 
-InputLayout* D3D12Renderer::createInputLayout(InputElementDesc const* inputElements, UInt inputElementCount) 
+InputLayout* D3D12Renderer::createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount) 
 {
     return nullptr;
 }
@@ -300,7 +300,7 @@ void D3D12Renderer::setPrimitiveTopology(PrimitiveTopology topology)
 {
 }
 
-void D3D12Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* strides, UInt const* offsets)
+void D3D12Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt * strides, const UInt* offsets)
 {
 }
 
@@ -308,7 +308,7 @@ void D3D12Renderer::setShaderProgram(ShaderProgram* inProgram)
 {
 }
 
-void D3D12Renderer::setConstantBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets)
+void D3D12Renderer::setConstantBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt* offsets)
 {
 }
 
@@ -321,25 +321,24 @@ void D3D12Renderer::dispatchCompute(int x, int y, int z)
 {
 }
 
-BindingState* D3D12Renderer::createBindingState(const ShaderInputLayout & layout)
+BindingState* D3D12Renderer::createBindingState(const ShaderInputLayout& layout)
 {
     return nullptr;
 }
 
-void D3D12Renderer::setBindingState(BindingState * state)
+void D3D12Renderer::setBindingState(BindingState* state)
 {
 }
 
-void D3D12Renderer::serializeOutput(BindingState* state, const char * fileName)
+void D3D12Renderer::serializeOutput(BindingState* state, const char* fileName)
 {
 }
 
 // ShaderCompiler interface
 
-ShaderProgram* D3D12Renderer::compileProgram(ShaderCompileRequest const& request)
+ShaderProgram* D3D12Renderer::compileProgram(const ShaderCompileRequest& request)
 {
     return nullptr;
 }
 
 } // renderer_test
-
diff --git a/tools/render-test/render-gl.cpp b/tools/render-test/render-gl.cpp
index 7f6e401e5..9c77fe7ba 100644
--- a/tools/render-test/render-gl.cpp
+++ b/tools/render-test/render-gl.cpp
@@ -77,28 +77,28 @@ 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 BindingState * createBindingState(const ShaderInputLayout & layout) 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;
     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 setBindingState(BindingState* state);
+    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;
 
     // ShaderCompiler implementation
-    virtual ShaderProgram* compileProgram(ShaderCompileRequest const& request) override;
+    virtual ShaderProgram* compileProgram(const ShaderCompileRequest& request) override;
 
     protected:
     enum
@@ -140,27 +140,26 @@ public:
         List<BindingEntryImpl> entries;
     };
 
-    void bindBufferImpl(int target, UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets);
+    void bindBufferImpl(int target, UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt* offsets);
     void flushStateForDraw();
     GLuint loadShader(GLenum stage, char const* source);
     void createInputBuffer(BindingEntryImpl& rs, InputBufferDesc bufDesc, List<unsigned int>& bufferData);
-    void debugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, GLchar const* message);
+    void debugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message);
     void createInputTexture(BindingEntryImpl& rs, InputTextureDesc texDesc, InputSamplerDesc samplerDesc);
     void createInputSampler(BindingEntryImpl& rs, InputSamplerDesc samplerDesc);
 
-    static void APIENTRY staticDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, GLchar const* message, void const* userParam);
+    static void APIENTRY staticDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam);
     static VertexAttributeFormat getVertexAttributeFormat(Format format);
 
-    InputLayoutImpl* boundInputLayout = nullptr;
-
-    GLenum boundPrimitiveTopology = GL_TRIANGLES;
-
-    HDC     deviceContext;
-    HGLRC   glContext;
-    float clearColor[4] = { 0, 0, 0, 0 };
-    GLuint  boundVertexStreamBuffers[kMaxVertexStreams];
-    UInt    boundVertexStreamStrides[kMaxVertexStreams];
-    UInt    boundVertexStreamOffsets[kMaxVertexStreams];
+    HDC     m_hdc;
+    HGLRC   m_glContext;
+    float   m_clearColor[4] = { 0, 0, 0, 0 };
+    
+    InputLayoutImpl* m_boundInputLayout = nullptr;
+    GLenum m_boundPrimitiveTopology = GL_TRIANGLES;
+    GLuint  m_boundVertexStreamBuffers[kMaxVertexStreams];
+    UInt    m_boundVertexStreamStrides[kMaxVertexStreams];
+    UInt    m_boundVertexStreamOffsets[kMaxVertexStreams];
 
     // Declare a function pointer for each OpenGL
     // extension function we need to load
@@ -174,7 +173,7 @@ Renderer* createGLRenderer()
     return new GLRenderer();
 }
 
-void GLRenderer::debugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, GLchar const* message)
+void GLRenderer::debugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message)
 {
     ::OutputDebugStringA("GL: ");
     ::OutputDebugStringA(message);
@@ -189,7 +188,7 @@ void GLRenderer::debugCallback(GLenum source, GLenum type, GLuint id, GLenum sev
     }
 }
 
-/* static */void APIENTRY GLRenderer::staticDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, GLchar const* message, void const* userParam)
+/* static */void APIENTRY GLRenderer::staticDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam)
 {
     ((GLRenderer*)userParam)->debugCallback(source, type, id, severity, length, message);
 }
@@ -209,7 +208,7 @@ void GLRenderer::debugCallback(GLenum source, GLenum type, GLuint id, GLenum sev
     }
 }
 
-void GLRenderer::bindBufferImpl(int target, UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets)
+void GLRenderer::bindBufferImpl(int target, UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt* offsets)
 {
     for (UInt ii = 0; ii < slotCount; ++ii)
     {
@@ -226,7 +225,7 @@ void GLRenderer::bindBufferImpl(int target, UInt startSlot, UInt slotCount, Buff
 
 void GLRenderer::flushStateForDraw()
 {
-    auto layout = this->boundInputLayout;
+    auto layout = m_boundInputLayout;
     auto attrCount = layout->attributeCount;
     for (UInt ii = 0; ii < attrCount; ++ii)
     {
@@ -234,15 +233,15 @@ void GLRenderer::flushStateForDraw()
 
         auto streamIndex = attr.streamIndex;
 
-        glBindBuffer(GL_ARRAY_BUFFER, boundVertexStreamBuffers[streamIndex]);
+        glBindBuffer(GL_ARRAY_BUFFER, m_boundVertexStreamBuffers[streamIndex]);
 
         glVertexAttribPointer(
             (GLuint)ii,
             attr.format.componentCount,
             attr.format.componentType,
             attr.format.normalized,
-            (GLsizei)boundVertexStreamStrides[streamIndex],
-            (GLvoid*)(attr.offset + boundVertexStreamOffsets[streamIndex]));
+            (GLsizei)m_boundVertexStreamStrides[streamIndex],
+            (GLvoid*)(attr.offset + m_boundVertexStreamOffsets[streamIndex]));
 
         glEnableVertexAttribArray((GLuint)ii);
     }
@@ -252,7 +251,7 @@ void GLRenderer::flushStateForDraw()
     }
 }
 
-GLuint GLRenderer::loadShader(GLenum stage, char const* source)
+GLuint GLRenderer::loadShader(GLenum stage, const char* source)
 {
     // GLSL is monumentally stupid. It officially requires the `#version` directive
     // to be the first thing in the file, which wouldn't be so bad but the API
@@ -262,12 +261,12 @@ GLuint GLRenderer::loadShader(GLenum stage, char const* source)
     // We are going to solve this problem by doing some surgery on the source
     // that was passed in.
 
-    char const* sourceBegin = source;
-    char const* sourceEnd = source + strlen(source);
+    const char* sourceBegin = source;
+    const char* sourceEnd = source + strlen(source);
 
     // Look for a version directive in the user-provided source.
-    char const* versionBegin = strstr(source, "#version");
-    char const* versionEnd = nullptr;
+    const char* versionBegin = strstr(source, "#version");
+    const char* versionEnd = nullptr;
     if (versionBegin)
     {
         // If we found a directive, then scan for the end-of-line
@@ -291,12 +290,12 @@ GLuint GLRenderer::loadShader(GLenum stage, char const* source)
     }
 
     enum { kMaxSourceStringCount = 16 };
-    GLchar const* sourceStrings[kMaxSourceStringCount];
+    const GLchar* sourceStrings[kMaxSourceStringCount];
     GLint sourceStringLengths[kMaxSourceStringCount];
 
     int sourceStringCount = 0;
 
-    char const* stagePrelude = "\n";
+    const char* stagePrelude = "\n";
     switch (stage)
     {
 #define CASE(NAME) case GL_##NAME##_SHADER: stagePrelude = "#define __GLSL_" #NAME "__ 1\n"; break
@@ -311,7 +310,7 @@ GLuint GLRenderer::loadShader(GLenum stage, char const* source)
 #undef CASE
     }
 
-    char const* prelude =
+    const char* prelude =
         "#define __GLSL__ 1\n"
         ;
 
@@ -353,7 +352,7 @@ GLuint GLRenderer::loadShader(GLenum stage, char const* source)
         if (infoSize > 0)
         {
             fprintf(stderr, "%s", infoBuffer);
-            OutputDebugStringA(infoBuffer);
+            ::OutputDebugStringA(infoBuffer);
         }
 
         glDeleteShader(shaderID);
@@ -488,7 +487,7 @@ SlangResult GLRenderer::initialize(void* inWindowHandle)
 {
     auto windowHandle = (HWND)inWindowHandle;
 
-    deviceContext = ::GetDC(windowHandle);
+    m_hdc = ::GetDC(windowHandle);
 
     PIXELFORMATDESCRIPTOR pixelFormatDesc = { sizeof(PIXELFORMATDESCRIPTOR) };
     pixelFormatDesc.nVersion = 1;
@@ -499,11 +498,11 @@ SlangResult GLRenderer::initialize(void* inWindowHandle)
     pixelFormatDesc.cStencilBits = 8;
     pixelFormatDesc.iLayerType = PFD_MAIN_PLANE;
 
-    int pixelFormatIndex = ChoosePixelFormat(deviceContext, &pixelFormatDesc);
-    SetPixelFormat(deviceContext, pixelFormatIndex, &pixelFormatDesc);
+    int pixelFormatIndex = ChoosePixelFormat(m_hdc, &pixelFormatDesc);
+    SetPixelFormat(m_hdc, pixelFormatIndex, &pixelFormatDesc);
 
-    glContext = wglCreateContext(deviceContext);
-    wglMakeCurrent(deviceContext, glContext);
+    m_glContext = wglCreateContext(m_hdc);
+    wglMakeCurrent(m_hdc, m_glContext);
 
     auto renderer = glGetString(GL_RENDERER);
     auto extensions = glGetString(GL_EXTENSIONS);
@@ -528,7 +527,7 @@ SlangResult GLRenderer::initialize(void* inWindowHandle)
     return SLANG_OK;
 }
 
-void GLRenderer::setClearColor(float const* color)
+void GLRenderer::setClearColor(const float color[4])
 {
     glClearColor(color[0], color[1], color[2], color[3]);
 }
@@ -541,10 +540,10 @@ void GLRenderer::clearFrame()
 void GLRenderer::presentFrame()
 {
     glFlush();
-    ::SwapBuffers(deviceContext);
+    ::SwapBuffers(m_hdc);
 }
 
-SlangResult GLRenderer::captureScreenShot(char const* outputPath)
+SlangResult GLRenderer::captureScreenShot(const char* outputPath)
 {
     int width = gWindowWidth;
     int height = gWindowHeight;
@@ -595,7 +594,7 @@ ShaderCompiler* GLRenderer::getShaderCompiler()
     return this;
 }
 
-Buffer* GLRenderer::createBuffer(BufferDesc const& desc)
+Buffer* GLRenderer::createBuffer(const BufferDesc& desc)
 {
     // TODO: should derive target from desc...
     GLenum target = GL_UNIFORM_BUFFER;
@@ -612,9 +611,9 @@ Buffer* GLRenderer::createBuffer(BufferDesc const& desc)
     return (Buffer*)(uintptr_t)bufferID;
 }
 
-InputLayout* GLRenderer::createInputLayout(InputElementDesc const* inputElements, UInt inputElementCount)
+InputLayout* GLRenderer::createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount)
 {
-    InputLayoutImpl* inputLayout = new InputLayoutImpl();
+    InputLayoutImpl* inputLayout = new InputLayoutImpl;
 
     inputLayout->attributeCount = inputElementCount;
     for (UInt ii = 0; ii < inputElementCount; ++ii)
@@ -662,7 +661,7 @@ void GLRenderer::unmap(Buffer* buffer)
 
 void GLRenderer::setInputLayout(InputLayout* inputLayout)
 {
-    boundInputLayout = (InputLayoutImpl*)inputLayout;
+    m_boundInputLayout = (InputLayoutImpl*)inputLayout;
 }
 
 void GLRenderer::setPrimitiveTopology(PrimitiveTopology topology)
@@ -676,10 +675,10 @@ void GLRenderer::setPrimitiveTopology(PrimitiveTopology topology)
 
 #undef CASE
     }
-    boundPrimitiveTopology = glTopology;
+    m_boundPrimitiveTopology = glTopology;
 }
 
-void GLRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* strides, UInt const* offsets)
+void GLRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt* strides, const UInt* offsets)
 {
     for (UInt ii = 0; ii < slotCount; ++ii)
     {
@@ -688,9 +687,9 @@ void GLRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, Buffer* const*
         Buffer* buffer = buffers[ii];
         GLuint bufferID = (GLuint)(uintptr_t)buffer;
 
-        boundVertexStreamBuffers[slot] = bufferID;
-        boundVertexStreamStrides[slot] = strides[ii];
-        boundVertexStreamOffsets[slot] = offsets[ii];
+        m_boundVertexStreamBuffers[slot] = bufferID;
+        m_boundVertexStreamStrides[slot] = strides[ii];
+        m_boundVertexStreamOffsets[slot] = offsets[ii];
     }
 }
 
@@ -700,7 +699,7 @@ void GLRenderer::setShaderProgram(ShaderProgram* program)
     glUseProgram(programID);
 }
 
-void GLRenderer::setConstantBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets) 
+void GLRenderer::setConstantBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt* offsets) 
 {
     bindBufferImpl(GL_UNIFORM_BUFFER, startSlot, slotCount, buffers, offsets);
 }
@@ -709,7 +708,7 @@ void GLRenderer::draw(UInt vertexCount, UInt startVertex = 0)
 {
     flushStateForDraw();
 
-    glDrawArrays(boundPrimitiveTopology, (GLint)startVertex, (GLsizei)vertexCount);
+    glDrawArrays(m_boundPrimitiveTopology, (GLint)startVertex, (GLsizei)vertexCount);
 }
 
 void GLRenderer::dispatchCompute(int x, int y, int z)
@@ -717,9 +716,9 @@ void GLRenderer::dispatchCompute(int x, int y, int z)
     glDispatchCompute(x, y, z);
 }
 
-BindingState* GLRenderer::createBindingState(const ShaderInputLayout & layout)
+BindingState* GLRenderer::createBindingState(const ShaderInputLayout& layout)
 {
-    BindingStateImpl * rs = new BindingStateImpl();
+    BindingStateImpl* rs = new BindingStateImpl;
     for (auto & entry : layout.entries)
     {
         BindingEntryImpl rsEntry;
@@ -746,10 +745,10 @@ BindingState* GLRenderer::createBindingState(const ShaderInputLayout & layout)
     return (BindingState*)rs;
 }
 
-void GLRenderer::setBindingState(BindingState * state)
+void GLRenderer::setBindingState(BindingState* stateIn)
 {
-    BindingStateImpl * glState = (BindingStateImpl*)state;
-    for (auto & entry : glState->entries)
+    BindingStateImpl* state = (BindingStateImpl*)stateIn;
+    for (auto & entry : state->entries)
     {
         switch (entry.type)
         {
@@ -769,12 +768,12 @@ void GLRenderer::setBindingState(BindingState * state)
     }
 }
 
-void GLRenderer::serializeOutput(BindingState* state, const char * fileName)
+void GLRenderer::serializeOutput(BindingState* stateIn, const char* fileName)
 {
-    BindingStateImpl * glState = (BindingStateImpl*)state;
+    BindingStateImpl * state = (BindingStateImpl*)stateIn;
     FILE * f;
     fopen_s(&f, fileName, "wt");
-    for (auto & entry : glState->entries)
+    for (auto & entry : state->entries)
     {
         if (entry.isOutput)
         {
@@ -791,7 +790,7 @@ void GLRenderer::serializeOutput(BindingState* state, const char * fileName)
 
 // ShaderCompiler interface
 
-ShaderProgram* GLRenderer::compileProgram(ShaderCompileRequest const& request) 
+ShaderProgram* GLRenderer::compileProgram(const ShaderCompileRequest& request) 
 {
     auto programID = glCreateProgram();
     if (request.computeShader.name)
diff --git a/tools/render-test/render-vk.cpp b/tools/render-test/render-vk.cpp
index 2c74c8883..ff22c91ea 100644
--- a/tools/render-test/render-vk.cpp
+++ b/tools/render-test/render-vk.cpp
@@ -83,28 +83,28 @@ class VKRenderer : 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 SlangResult captureScreenShot(const char* 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 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;
     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 setBindingState(BindingState* state);
+    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;
 
     // ShaderCompiler implementation
-    virtual ShaderProgram* compileProgram(ShaderCompileRequest const& request) override;
+    virtual ShaderProgram* compileProgram(const ShaderCompileRequest& request) override;
 
     protected:
 
@@ -148,7 +148,7 @@ public:
 
     VkBool32 handleDebugMessage(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t srcObject,
         size_t location, int32_t msgCode, const char* pLayerPrefix, const char* pMsg);
-    BufferImpl createBufferImpl(size_t bufferSize, VkBufferUsageFlags usage, VkMemoryPropertyFlags reqMemoryProperties, void const* initData = nullptr);
+    BufferImpl createBufferImpl(size_t bufferSize, VkBufferUsageFlags usage, VkMemoryPropertyFlags reqMemoryProperties, const void* initData = nullptr);
 
     VkCommandBuffer getCommandBuffer();
     VkCommandBuffer beginCommandBuffer();
@@ -168,22 +168,21 @@ public:
     static VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageCallback(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t srcObject,
         size_t location, int32_t msgCode, const char* pLayerPrefix, const char* pMsg, void* pUserData);
 
-    VkInstance                          instance;
-    VkPhysicalDevice                    physicalDevice;
-    VkPhysicalDeviceProperties          deviceProperties;
-    VkPhysicalDeviceFeatures            deviceFeatures;
-    VkPhysicalDeviceMemoryProperties    deviceMemoryProperties;
-    VkPhysicalDeviceFeatures            enabledFeatures;
-    VkDevice                            device;
-    VkQueue                             queue;
-    VkCommandPool                       commandPool;
-    VkSubmitInfo                        submitInfo;
-    VkDebugReportCallbackEXT            debugReportCallback;
+    VkInstance                          m_instance;
+    VkPhysicalDevice                    m_physicalDevice;
+    VkPhysicalDeviceProperties          m_deviceProperties;
+    VkPhysicalDeviceFeatures            m_deviceFeatures;
+    VkPhysicalDeviceMemoryProperties    m_deviceMemoryProperties;
+    VkDevice                            m_device;
+    VkQueue                             m_queue;
+    VkCommandPool                       m_commandPool;
+    VkSubmitInfo                        m_submitInfo;
+    VkDebugReportCallbackEXT            m_debugReportCallback;
 
-    BindingStateImpl* currentBindingState = nullptr;
-    ShaderProgramImpl* currentProgram = nullptr;
+    BindingStateImpl* m_currentBindingState = nullptr;
+    ShaderProgramImpl* m_currentProgram = nullptr;
 
-    float clearColor[4];
+    float m_clearColor[4] = { 0, 0, 0, 0 };;
 
 #define DECLARE_PROC(NAME) PFN_##NAME NAME;
     DECLARE_PROC(vkGetInstanceProcAddr);
@@ -196,7 +195,7 @@ public:
 
 Renderer* createVKRenderer()
 {
-    return new VKRenderer();
+    return new VKRenderer;
 }
 
 /* static */SlangResult VKRenderer::toSlangResult(VkResult res)
@@ -243,13 +242,12 @@ VkBool32 VKRenderer::handleDebugMessage(VkDebugReportFlagsEXT flags, VkDebugRepo
 VkCommandBuffer VKRenderer::getCommandBuffer()
 {
     VkCommandBufferAllocateInfo info = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
-    info.commandPool = commandPool;
+    info.commandPool = m_commandPool;
     info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
     info.commandBufferCount = 1;
 
     VkCommandBuffer commandBuffer;
-    checkResult(vkAllocateCommandBuffers(
-        device, &info, &commandBuffer));
+    checkResult(vkAllocateCommandBuffers(m_device, &info, &commandBuffer));
 
     return commandBuffer;
 }
@@ -272,13 +270,13 @@ void VKRenderer::flushCommandBuffer(VkCommandBuffer commandBuffer)
     submitInfo.commandBufferCount = 1;
     submitInfo.pCommandBuffers = &commandBuffer;
 
-    checkResult(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
-    checkResult(vkQueueWaitIdle(queue));
+    checkResult(vkQueueSubmit(m_queue, 1, &submitInfo, VK_NULL_HANDLE));
+    checkResult(vkQueueWaitIdle(m_queue));
 
-    vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
+    vkFreeCommandBuffers(m_device, m_commandPool, 1, &commandBuffer);
 }
 
-VKRenderer::BufferImpl VKRenderer::createBufferImpl(size_t bufferSize, VkBufferUsageFlags usage, VkMemoryPropertyFlags reqMemoryProperties, void const* initData)
+VKRenderer::BufferImpl VKRenderer::createBufferImpl(size_t bufferSize, VkBufferUsageFlags usage, VkMemoryPropertyFlags reqMemoryProperties, const void* initData)
 {
     if (initData)
     {
@@ -291,27 +289,23 @@ VKRenderer::BufferImpl VKRenderer::createBufferImpl(size_t bufferSize, VkBufferU
     bufferCreateInfo.usage = usage;
 
     VkBuffer buffer;
-    checkResult(vkCreateBuffer(
-        device, &bufferCreateInfo, nullptr, &buffer));
+    checkResult(vkCreateBuffer(m_device, &bufferCreateInfo, nullptr, &buffer));
 
     VkMemoryRequirements memoryReqs = {};
-    vkGetBufferMemoryRequirements(device, buffer, &memoryReqs);
+    vkGetBufferMemoryRequirements(m_device, buffer, &memoryReqs);
 
-    uint32_t memoryTypeIndex = getMemoryTypeIndex(
-        memoryReqs.memoryTypeBits, reqMemoryProperties);
+    uint32_t memoryTypeIndex = getMemoryTypeIndex(memoryReqs.memoryTypeBits, reqMemoryProperties);
 
-    VkMemoryPropertyFlags actualMemoryProperites = deviceMemoryProperties.memoryTypes[memoryTypeIndex].propertyFlags;
+    VkMemoryPropertyFlags actualMemoryProperites = m_deviceMemoryProperties.memoryTypes[memoryTypeIndex].propertyFlags;
 
     VkMemoryAllocateInfo allocateInfo = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
     allocateInfo.allocationSize = memoryReqs.size;
     allocateInfo.memoryTypeIndex = memoryTypeIndex;
 
     VkDeviceMemory memory;
-    checkResult(vkAllocateMemory(
-        device, &allocateInfo, nullptr, &memory));
+    checkResult(vkAllocateMemory(m_device, &allocateInfo, nullptr, &memory));
 
-    checkResult(vkBindBufferMemory(
-        device, buffer, memory, 0));
+    checkResult(vkBindBufferMemory(m_device, buffer, memory, 0));
 
     if (initData)
     {
@@ -324,9 +318,9 @@ VKRenderer::BufferImpl VKRenderer::createBufferImpl(size_t bufferSize, VkBufferU
 
         // Copy into staging buffer
         void* mappedData = nullptr;
-        checkResult(vkMapMemory(device, staging.memory, 0, bufferSize, 0, &mappedData));
+        checkResult(vkMapMemory(m_device, staging.memory, 0, bufferSize, 0, &mappedData));
         memcpy(mappedData, initData, bufferSize);
-        vkUnmapMemory(device, staging.memory);
+        vkUnmapMemory(m_device, staging.memory);
 
         // Copy from staging buffer to real buffer
         VkCommandBuffer commandBuffer = beginCommandBuffer();
@@ -338,8 +332,8 @@ VKRenderer::BufferImpl VKRenderer::createBufferImpl(size_t bufferSize, VkBufferU
         flushCommandBuffer(commandBuffer);
 
         // Now destroy the staging buffer
-        vkDestroyBuffer(device, staging.buffer, nullptr);
-        vkFreeMemory(device, staging.memory, nullptr);
+        vkDestroyBuffer(m_device, staging.buffer, nullptr);
+        vkFreeMemory(m_device, staging.memory, nullptr);
     }
 
     BufferImpl impl;
@@ -354,7 +348,7 @@ uint32_t VKRenderer::getMemoryTypeIndex(uint32_t inTypeBits, VkMemoryPropertyFla
     uint32_t typeIndex = 0;
     while (typeBits)
     {
-        if ((deviceMemoryProperties.memoryTypes[typeIndex].propertyFlags & properties) == properties)
+        if ((m_deviceMemoryProperties.memoryTypes[typeIndex].propertyFlags & properties) == properties)
         {
             return typeIndex;
         }
@@ -378,7 +372,7 @@ void VKRenderer::createInputSampler(const InputSamplerDesc& inputDesc, VkSampler
     assert(!"unimplemented");
 }
 
-void VKRenderer::createInputBuffer(const ShaderInputLayoutEntry& entry,    const InputBufferDesc& bufferDesc, const Slang::List<unsigned int>& bufferData, 
+void VKRenderer::createInputBuffer(const ShaderInputLayoutEntry& entry, const InputBufferDesc& bufferDesc, const Slang::List<unsigned int>& bufferData, 
     VkBuffer& bufferOut, VkBufferView& uavOut, VkImageView& srvOut)
 {
     size_t bufferSize = bufferData.Count() * sizeof(unsigned int);
@@ -443,7 +437,7 @@ VkPipelineShaderStageCreateInfo VKRenderer::compileEntryPoint(const ShaderCompil
     moduleCreateInfo.codeSize = codeSize;
 
     VkShaderModule module;
-    checkResult(vkCreateShaderModule(device, &moduleCreateInfo, nullptr, &module));
+    checkResult(vkCreateShaderModule(m_device, &moduleCreateInfo, nullptr, &module));
 
     //::free(codeBegin);
 
@@ -508,13 +502,13 @@ SlangResult VKRenderer::initialize(void* inWindowHandle)
     instanceCreateInfo.ppEnabledLayerNames = layerNames;
 #endif
 
-    instance = 0;
+    m_instance = 0;
 
-#define LOAD_INSTANCE_PROC(NAME) NAME = (PFN_##NAME) vkGetInstanceProcAddr(instance, #NAME);
+#define LOAD_INSTANCE_PROC(NAME) NAME = (PFN_##NAME) vkGetInstanceProcAddr(m_instance, #NAME);
 
     FOREACH_GLOBAL_PROC(LOAD_INSTANCE_PROC);
 
-    RETURN_ON_VK_FAIL(vkCreateInstance(&instanceCreateInfo, nullptr, &instance));
+    RETURN_ON_VK_FAIL(vkCreateInstance(&instanceCreateInfo, nullptr, &m_instance));
 
     FOREACH_INSTANCE_PROC(LOAD_INSTANCE_PROC);
 
@@ -529,34 +523,29 @@ SlangResult VKRenderer::initialize(void* inWindowHandle)
     debugCreateInfo.pUserData = this;
     debugCreateInfo.flags = debugFlags;
 
-    RETURN_ON_VK_FAIL(vkCreateDebugReportCallbackEXT(instance, &debugCreateInfo, nullptr, &debugReportCallback));
+    RETURN_ON_VK_FAIL(vkCreateDebugReportCallbackEXT(m_instance, &debugCreateInfo, nullptr, &m_debugReportCallback));
 
 #endif
 
     uint32_t physicalDeviceCount = 0;
-    RETURN_ON_VK_FAIL(vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, nullptr));
+    RETURN_ON_VK_FAIL(vkEnumeratePhysicalDevices(m_instance, &physicalDeviceCount, nullptr));
 
-    VkPhysicalDevice* physicalDevices = (VkPhysicalDevice*)alloca(
-        physicalDeviceCount * sizeof(VkPhysicalDevice));
-    RETURN_ON_VK_FAIL(vkEnumeratePhysicalDevices(
-        instance, &physicalDeviceCount, physicalDevices));
+    VkPhysicalDevice* physicalDevices = (VkPhysicalDevice*)alloca(physicalDeviceCount * sizeof(VkPhysicalDevice));
+    RETURN_ON_VK_FAIL(vkEnumeratePhysicalDevices(m_instance, &physicalDeviceCount, physicalDevices));
 
     uint32_t selectedDeviceIndex = 0;
     // TODO: allow override of selected device
-    physicalDevice = physicalDevices[selectedDeviceIndex];
+    m_physicalDevice = physicalDevices[selectedDeviceIndex];
 
-    vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
-    vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures);
-    vkGetPhysicalDeviceMemoryProperties(physicalDevice, &deviceMemoryProperties);
+    vkGetPhysicalDeviceProperties(m_physicalDevice, &m_deviceProperties);
+    vkGetPhysicalDeviceFeatures(m_physicalDevice, &m_deviceFeatures);
+    vkGetPhysicalDeviceMemoryProperties(m_physicalDevice, &m_deviceMemoryProperties);
 
     uint32_t queueFamilyCount = 0;
-    vkGetPhysicalDeviceQueueFamilyProperties(
-        physicalDevice, &queueFamilyCount, nullptr);
+    vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice, &queueFamilyCount, nullptr);
 
-    VkQueueFamilyProperties* queueFamilies = (VkQueueFamilyProperties*)alloca(
-        queueFamilyCount * sizeof(VkQueueFamilyProperties));
-    vkGetPhysicalDeviceQueueFamilyProperties(
-        physicalDevice, &queueFamilyCount, queueFamilies);
+    VkQueueFamilyProperties* queueFamilies = (VkQueueFamilyProperties*)alloca(queueFamilyCount * sizeof(VkQueueFamilyProperties));
+    vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice, &queueFamilyCount, queueFamilies);
 
     // Find a queue that can service our needs
     VkQueueFlags reqQueueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT;
@@ -586,28 +575,26 @@ SlangResult VKRenderer::initialize(void* inWindowHandle)
     VkDeviceCreateInfo deviceCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
     deviceCreateInfo.queueCreateInfoCount = 1;
     deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo;
-    deviceCreateInfo.pEnabledFeatures = &enabledFeatures;
+    deviceCreateInfo.pEnabledFeatures = &m_deviceFeatures;
 
     deviceCreateInfo.enabledExtensionCount = sizeof(deviceExtensions) / sizeof(deviceExtensions[0]);
     deviceCreateInfo.ppEnabledExtensionNames = &deviceExtensions[0];
 
-    RETURN_ON_VK_FAIL(vkCreateDevice(
-        physicalDevice, &deviceCreateInfo, nullptr, &device));
+    RETURN_ON_VK_FAIL(vkCreateDevice(m_physicalDevice, &deviceCreateInfo, nullptr, &m_device));
 
-#define LOAD_DEVICE_PROC(NAME) NAME = (PFN_##NAME) vkGetDeviceProcAddr(device, #NAME);
+#define LOAD_DEVICE_PROC(NAME) NAME = (PFN_##NAME) vkGetDeviceProcAddr(m_device, #NAME);
     FOREACH_DEVICE_PROC(LOAD_DEVICE_PROC)
 #undef LOAD_DEVICE_PROC
 
         // Create a command pool
 
-        VkCommandPoolCreateInfo commandPoolCreateInfo = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
+    VkCommandPoolCreateInfo commandPoolCreateInfo = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
     commandPoolCreateInfo.queueFamilyIndex = queueFamilyIndex;
     commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
 
-    RETURN_ON_VK_FAIL(vkCreateCommandPool(
-        device, &commandPoolCreateInfo, nullptr, &commandPool));
+    RETURN_ON_VK_FAIL(vkCreateCommandPool(m_device, &commandPoolCreateInfo, nullptr, &m_commandPool));
 
-    vkGetDeviceQueue(device, queueFamilyIndex, 0, &queue);
+    vkGetDeviceQueue(m_device, queueFamilyIndex, 0, &m_queue);
 
     // set up swap chain
 
@@ -630,10 +617,10 @@ SlangResult VKRenderer::initialize(void* inWindowHandle)
     return SLANG_OK;
 }
 
-void VKRenderer::setClearColor(float const* color)
+void VKRenderer::setClearColor(const float color[4])
 {
     for (int ii = 0; ii < 4; ++ii)
-        clearColor[ii] = color[ii];
+        m_clearColor[ii] = color[ii];
 }
 
 void VKRenderer::clearFrame()
@@ -654,7 +641,7 @@ ShaderCompiler* VKRenderer::getShaderCompiler()
     return this;
 }
 
-Buffer* VKRenderer::createBuffer(BufferDesc const& desc)
+Buffer* VKRenderer::createBuffer(const BufferDesc& desc)
 {
     size_t bufferSize = desc.size;
 
@@ -685,7 +672,7 @@ Buffer* VKRenderer::createBuffer(BufferDesc const& desc)
     return (Buffer*)bufferPtr;
 }
 
-InputLayout* VKRenderer::createInputLayout(InputElementDesc const* inputElements, UInt inputElementCount) 
+InputLayout* VKRenderer::createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount) 
 {
     InputLayoutImpl* impl = new InputLayoutImpl;
 
@@ -711,16 +698,16 @@ void VKRenderer::setPrimitiveTopology(PrimitiveTopology topology)
 {
 }
 
-void VKRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* strides, UInt const* offsets)
+void VKRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt* strides, const UInt* offsets)
 {
 }
 
 void VKRenderer::setShaderProgram(ShaderProgram* program)
 {
-    currentProgram = (ShaderProgramImpl*)program;
+    m_currentProgram = (ShaderProgramImpl*)program;
 }
 
-void VKRenderer::setConstantBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets) 
+void VKRenderer::setConstantBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt* offsets) 
 {
 }
 
@@ -769,12 +756,12 @@ BindingState* VKRenderer::createBindingState(const ShaderInputLayout& layout)
     return (BindingState*)bindingState;
 }
 
-void VKRenderer::setBindingState(BindingState * state)
+void VKRenderer::setBindingState(BindingState* state)
 {
-    currentBindingState = (BindingStateImpl*)state;
+    m_currentBindingState = (BindingStateImpl*)state;
 }
 
-void VKRenderer::serializeOutput(BindingState* s, const char * fileName)
+void VKRenderer::serializeOutput(BindingState* s, const char* fileName)
 {
     auto state = (BindingStateImpl*)s;
 
@@ -788,9 +775,7 @@ void VKRenderer::serializeOutput(BindingState* s, const char * fileName)
             {
                 // create staging buffer
                 size_t bufferSize = bb.bufferLength;
-                BufferImpl staging = createBufferImpl(
-                    bufferSize,
-                    VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+                BufferImpl staging = createBufferImpl(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
                     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
 
                 // Copy from real buffer to staging buffer
@@ -798,28 +783,23 @@ void VKRenderer::serializeOutput(BindingState* s, const char * fileName)
 
                 VkBufferCopy copyInfo = {};
                 copyInfo.size = bufferSize;
-                vkCmdCopyBuffer(
-                    commandBuffer,
-                    bb.buffer,
-                    staging.buffer,
-                    1,
-                    &copyInfo);
+                vkCmdCopyBuffer(commandBuffer, bb.buffer, staging.buffer, 1, &copyInfo);
 
                 flushCommandBuffer(commandBuffer);
 
                 // Write out the data from the buffer
                 void* mappedData = nullptr;
-                checkResult(vkMapMemory(device, staging.memory, 0, bufferSize, 0, &mappedData));
+                checkResult(vkMapMemory(m_device, staging.memory, 0, bufferSize, 0, &mappedData));
 
                 auto ptr = (unsigned int *)mappedData;
                 for (auto i = 0u; i < bufferSize / sizeof(unsigned int); i++)
                     fprintf(f, "%X\n", ptr[i]);
 
-                vkUnmapMemory(device, staging.memory);
+                vkUnmapMemory(m_device, staging.memory);
 
                 // Now destroy the staging buffer
-                vkDestroyBuffer(device, staging.buffer, nullptr);
-                vkFreeMemory(device, staging.memory, nullptr);
+                vkDestroyBuffer(m_device, staging.buffer, nullptr);
+                vkFreeMemory(m_device, staging.memory, nullptr);
             }
             else
             {
@@ -839,7 +819,7 @@ void VKRenderer::dispatchCompute(int x, int y, int z)
 
     Slang::List<VkDescriptorSetLayoutBinding> bindings;
 
-    for (auto bb : currentBindingState->bindings)
+    for (auto bb : m_currentBindingState->bindings)
     {
         switch (bb.type)
         {
@@ -877,8 +857,7 @@ void VKRenderer::dispatchCompute(int x, int y, int z)
     descriptorSetLayoutInfo.pBindings = bindings.Buffer();
 
     VkDescriptorSetLayout descriptorSetLayout = 0;
-    checkResult(vkCreateDescriptorSetLayout(
-        device, &descriptorSetLayoutInfo, nullptr, &descriptorSetLayout));
+    checkResult(vkCreateDescriptorSetLayout(m_device, &descriptorSetLayoutInfo, nullptr, &descriptorSetLayout));
 
     // Create a descriptor pool for allocating sets
 
@@ -895,8 +874,7 @@ void VKRenderer::dispatchCompute(int x, int y, int z)
     descriptorPoolInfo.pPoolSizes = poolSizes;
 
     VkDescriptorPool descriptorPool;
-    checkResult(vkCreateDescriptorPool(
-        device, &descriptorPoolInfo, nullptr, &descriptorPool));
+    checkResult(vkCreateDescriptorPool(m_device, &descriptorPoolInfo, nullptr, &descriptorPool));
 
     // Create a descriptor set based on our layout
 
@@ -906,11 +884,10 @@ void VKRenderer::dispatchCompute(int x, int y, int z)
     descriptorSetAllocInfo.pSetLayouts = &descriptorSetLayout;
 
     VkDescriptorSet descriptorSet;
-    checkResult(vkAllocateDescriptorSets(
-        device, &descriptorSetAllocInfo, &descriptorSet));
+    checkResult(vkAllocateDescriptorSets(m_device, &descriptorSetAllocInfo, &descriptorSet));
 
     // Fill in the descritpor set, using our binding information
-    for (auto bb : currentBindingState->bindings)
+    for (auto bb : m_currentBindingState->bindings)
     {
         switch (bb.type)
         {
@@ -933,12 +910,7 @@ void VKRenderer::dispatchCompute(int x, int y, int z)
                         writeInfo.dstArrayElement = 0;
                         writeInfo.pBufferInfo = &bufferInfo;
 
-                        vkUpdateDescriptorSets(
-                            device,
-                            1,
-                            &writeInfo,
-                            0,
-                            nullptr);
+                        vkUpdateDescriptorSets(m_device, 1, &writeInfo, 0, nullptr);
                     }
                     break;
 
@@ -955,7 +927,6 @@ void VKRenderer::dispatchCompute(int x, int y, int z)
         }
     }
 
-
     // Create a pipeline layout based on our descriptor set layout(s)
 
     VkPipelineLayoutCreateInfo pipelineLayoutInfo = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
@@ -963,27 +934,24 @@ void VKRenderer::dispatchCompute(int x, int y, int z)
     pipelineLayoutInfo.pSetLayouts = &descriptorSetLayout;
 
     VkPipelineLayout pipelineLayout = 0;
-    checkResult(vkCreatePipelineLayout(
-        device, &pipelineLayoutInfo, nullptr, &pipelineLayout));
+    checkResult(vkCreatePipelineLayout(m_device, &pipelineLayoutInfo, nullptr, &pipelineLayout));
 
     // Then create a pipeline to use that layout
 
     VkComputePipelineCreateInfo computePipelineInfo = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO };
-    computePipelineInfo.stage = currentProgram->compute;
+    computePipelineInfo.stage = m_currentProgram->compute;
     computePipelineInfo.layout = pipelineLayout;
 
     VkPipelineCache pipelineCache = 0;
 
     VkPipeline pipeline;
-    checkResult(vkCreateComputePipelines(
-        device, pipelineCache, 1, &computePipelineInfo, nullptr, &pipeline));
+    checkResult(vkCreateComputePipelines(m_device, pipelineCache, 1, &computePipelineInfo, nullptr, &pipeline));
 
     // Also create descriptor sets based on the given pipeline layout
 
     VkCommandBuffer commandBuffer = beginCommandBuffer();
 
-    vkCmdBindPipeline(
-        commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
+    vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
 
     vkCmdBindDescriptorSets(
         commandBuffer,
@@ -998,13 +966,11 @@ void VKRenderer::dispatchCompute(int x, int y, int z)
 
     flushCommandBuffer(commandBuffer);
 
-    vkDestroyPipeline(device, pipeline, nullptr);
+    vkDestroyPipeline(m_device, pipeline, nullptr);
 
     // TODO: need to free up the other resources too...
 }
 
-
-
 // ShaderCompiler interface
 ShaderProgram* VKRenderer::compileProgram(const ShaderCompileRequest & request) 
 {
@@ -1021,5 +987,4 @@ ShaderProgram* VKRenderer::compileProgram(const ShaderCompileRequest & request)
     return (ShaderProgram*)impl;
 }
 
-
 } // renderer_test
diff --git a/tools/render-test/render.h b/tools/render-test/render.h
index bc63caa77..08d364b05 100644
--- a/tools/render-test/render.h
+++ b/tools/render-test/render.h
@@ -96,17 +96,17 @@ class Renderer
 public:
     virtual SlangResult initialize(void* inWindowHandle) = 0;
 
-    virtual void setClearColor(float const* color) = 0;
+    virtual void setClearColor(const float color[4]) = 0;
     virtual void clearFrame() = 0;
 
     virtual void presentFrame() = 0;
 
-    virtual SlangResult captureScreenShot(char const* outputPath) = 0;
-    virtual void serializeOutput(BindingState * state, char const* outputPath) = 0;
-    virtual Buffer* createBuffer(BufferDesc const& desc) = 0;
+    virtual SlangResult captureScreenShot(const char* outputPath) = 0;
+    virtual void serializeOutput(BindingState* state, const char* outputPath) = 0;
+    virtual Buffer* createBuffer(const BufferDesc& desc) = 0;
 
-    virtual InputLayout* createInputLayout(InputElementDesc const* inputElements, UInt inputElementCount) = 0;
-    virtual BindingState* createBindingState(const ShaderInputLayout & shaderInput) = 0;
+    virtual InputLayout* createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount) = 0;
+    virtual BindingState* createBindingState(const ShaderInputLayout& shaderInput) = 0;
     virtual ShaderCompiler* getShaderCompiler() = 0;
 
     virtual void* map(Buffer* buffer, MapFlavor flavor) = 0;
@@ -114,14 +114,14 @@ public:
 
     virtual void setInputLayout(InputLayout* inputLayout) = 0;
     virtual void setPrimitiveTopology(PrimitiveTopology topology) = 0;
-    virtual void setBindingState(BindingState * state) = 0;
-    virtual void setVertexBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* strides, UInt const* offsets) = 0;
+    virtual void setBindingState(BindingState* state) = 0;
+    virtual void setVertexBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt* strides, const UInt* offsets) = 0;
 
     inline void setVertexBuffer(UInt slot, Buffer* buffer, UInt stride, UInt offset = 0);
 
     virtual void setShaderProgram(ShaderProgram* program) = 0;
 
-    virtual void setConstantBuffers(UInt startSlot, UInt slotCount, Buffer* const* buffers, UInt const* offsets) = 0;
+    virtual void setConstantBuffers(UInt startSlot, UInt slotCount, Buffer*const* buffers, const UInt* offsets) = 0;
     inline void setConstantBuffer(UInt slot, Buffer* buffer, UInt offset = 0);
 
     virtual void draw(UInt vertexCount, UInt startVertex = 0) = 0;
diff --git a/tools/slang-test/README.md b/tools/slang-test/README.md
index 7da0c3191..95ed497ba 100644
--- a/tools/slang-test/README.md
+++ b/tools/slang-test/README.md
@@ -4,6 +4,18 @@ Slang Test is a command line tool that is used to coordinate tests via other com
 
 Slang Test can be thought of as the 'hub' running multiple tests and accumulating the results. In the distribution tests are held in the 'tests' directory. Inside this directory there are tests grouped together via other directories. Inside those directories are the actual tests themselves. The tests exist as .hlsl, .slang and .glsl and other file extensions. The top line of each of these files describe what kind of test will be performed with a specialized comment '//TEST'. 
 
+Most command line options are prefixed by - for both switches and parameter options. On the command line you can specify a 'free parameter', and this value specifies the prefix of the name of the test to run. Note that such a prefix includes the path, with each directory separated via '/'.
+
+An example command line:
+
+```
+slang-test -bindir "E:\slang\bin\windows-x64\Debug\\" -category full tests/compute/array-param
+```
+
+* The -bindir value means that the tools slang-test will use the binaries found in this directory. 
+* The -category full means that all tests can be run.
+* The final 'free parameter' is 'tests/compute/array-param' and means only tests starting with this string will run.
+
 ## Test Categories
 
 There are the following test categories