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