From 5000d27d993d9ac33ef80482eb44235298d5177e Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Thu, 22 Mar 2018 18:08:19 -0400 Subject: 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 --- tools/render-test/render-d3d11.cpp | 542 +++++++++++++++++-------------------- tools/render-test/render-d3d12.cpp | 73 +++-- tools/render-test/render-gl.cpp | 131 +++++---- tools/render-test/render-vk.cpp | 215 ++++++--------- tools/render-test/render.h | 18 +- 5 files changed, 446 insertions(+), 533 deletions(-) (limited to 'tools/render-test') 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 & bufferData, ID3D11Buffer * &bufferOut, - ID3D11UnorderedAccessView * &viewOut, ID3D11ShaderResourceView * &srvOut); + void createInputBuffer(InputBufferDesc& bufferDesc, List& 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 dxRenderTargetViews; - List 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 m_renderTargetViews; + List 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 & bufferData, ID3D11Buffer * &bufferOut, - ID3D11UnorderedAccessView * &viewOut, ID3D11ShaderResourceView * &srvOut) +void D3D11Renderer::createInputBuffer(InputBufferDesc& bufferDesc, List& bufferData, ID3D11Buffer*& bufferOut, + ID3D11UnorderedAccessView*& viewOut, ID3D11ShaderResourceView*& srvOut) { - auto dxContext = dxImmediateContext; D3D11_BUFFER_DESC desc = { 0 }; List newBuffer; desc.ByteWidth = (UINT)calcAligned((bufferData.Count() * sizeof(unsigned int)), 256); @@ -798,7 +748,7 @@ void D3D11Renderer::createInputBuffer(InputBufferDesc & bufferDesc, ListCreateBuffer(&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, ListCreateUnorderedAccessView(bufferOut, &viewDesc, &viewOut); + m_device->CreateUnorderedAccessView(bufferOut, &viewDesc, &viewOut); } if (bufferDesc.type != InputBufferType::ConstantBuffer) { @@ -831,11 +781,11 @@ void D3D11Renderer::createInputBuffer(InputBufferDesc & bufferDesc, ListCreateShaderResourceView(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 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& 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& bufferData, +void VKRenderer::createInputBuffer(const ShaderInputLayoutEntry& entry, const InputBufferDesc& bufferDesc, const Slang::List& 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, - ©Info); + vkCmdCopyBuffer(commandBuffer, bb.buffer, staging.buffer, 1, ©Info); 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 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; -- cgit v1.2.3