From c73ccbc5616dff16ecacb9198f725f498a7e6c84 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Fri, 20 Apr 2018 14:59:17 -0400 Subject: Fixes/improvements based on feature/render-binding-resource (#511) * Dx12 rendering works in test framework. * Turn on dx12 render tests. * Split out functions for construction or Renderer types into ShaderRendererUtil. Removed the serialization of buffers code into test-render * Improvements in documentation and typename in BindingState types. RegisterSet -> CompactBindIndexSlice RegisterList -> BindIndexSlice RegisterDesc -> ShaderBindSet * Fix debug build break. --- tools/render-test/shader-renderer-util.cpp | 200 +++++++++++++++++++++++++++++ 1 file changed, 200 insertions(+) create mode 100644 tools/render-test/shader-renderer-util.cpp (limited to 'tools/render-test/shader-renderer-util.cpp') diff --git a/tools/render-test/shader-renderer-util.cpp b/tools/render-test/shader-renderer-util.cpp new file mode 100644 index 000000000..c0cf982c9 --- /dev/null +++ b/tools/render-test/shader-renderer-util.cpp @@ -0,0 +1,200 @@ +// shader-renderer-util.cpp + +#include "shader-renderer-util.h" + +namespace renderer_test { + +using namespace Slang; + +/* static */Result ShaderRendererUtil::generateTextureResource(const InputTextureDesc& inputDesc, int bindFlags, Renderer* renderer, RefPtr& textureOut) +{ + TextureData texData; + generateTextureData(texData, inputDesc); + return createTextureResource(inputDesc, texData, bindFlags, renderer, textureOut); +} + +/* static */Result ShaderRendererUtil::createTextureResource(const InputTextureDesc& inputDesc, const TextureData& texData, int bindFlags, Renderer* renderer, RefPtr& textureOut) +{ + TextureResource::Desc textureResourceDesc; + textureResourceDesc.init(); + + textureResourceDesc.format = Format::RGBA_Unorm_UInt8; + textureResourceDesc.numMipLevels = texData.mipLevels; + textureResourceDesc.arraySize = inputDesc.arrayLength; + textureResourceDesc.bindFlags = bindFlags; + + // It's the same size in all dimensions + Resource::Type type = Resource::Type::Unknown; + switch (inputDesc.dimension) + { + case 1: + { + type = Resource::Type::Texture1D; + textureResourceDesc.size.init(inputDesc.size); + break; + } + case 2: + { + type = inputDesc.isCube ? Resource::Type::TextureCube : Resource::Type::Texture2D; + textureResourceDesc.size.init(inputDesc.size, inputDesc.size); + break; + } + case 3: + { + type = Resource::Type::Texture3D; + textureResourceDesc.size.init(inputDesc.size, inputDesc.size, inputDesc.size); + break; + } + } + + const int effectiveArraySize = textureResourceDesc.calcEffectiveArraySize(type); + const int numSubResources = textureResourceDesc.calcNumSubResources(type); + + Resource::Usage initialUsage = Resource::Usage::GenericRead; + TextureResource::Data initData; + + List mipRowStrides; + mipRowStrides.SetSize(textureResourceDesc.numMipLevels); + List subResources; + subResources.SetSize(numSubResources); + + // Set up the src row strides + for (int i = 0; i < textureResourceDesc.numMipLevels; i++) + { + const int mipWidth = TextureResource::calcMipSize(textureResourceDesc.size.width, i); + mipRowStrides[i] = mipWidth * sizeof(uint32_t); + } + + // Set up pointers the the data + { + int subResourceIndex = 0; + const int numGen = int(texData.dataBuffer.Count()); + for (int i = 0; i < numSubResources; i++) + { + subResources[i] = texData.dataBuffer[subResourceIndex].Buffer(); + // Wrap around + subResourceIndex = (subResourceIndex + 1 >= numGen) ? 0 : (subResourceIndex + 1); + } + } + + initData.mipRowStrides = mipRowStrides.Buffer(); + initData.numMips = textureResourceDesc.numMipLevels; + initData.numSubResources = numSubResources; + initData.subResources = subResources.Buffer(); + + textureOut = renderer->createTextureResource(type, Resource::Usage::GenericRead, textureResourceDesc, &initData); + + return textureOut ? SLANG_OK : SLANG_FAIL; +} + +/* static */Result ShaderRendererUtil::createBufferResource(const InputBufferDesc& inputDesc, bool isOutput, size_t bufferSize, const void* initData, Renderer* renderer, Slang::RefPtr& bufferOut) +{ + Resource::Usage initialUsage = Resource::Usage::GenericRead; + + BufferResource::Desc srcDesc; + srcDesc.init(bufferSize); + + int bindFlags = 0; + if (inputDesc.type == InputBufferType::ConstantBuffer) + { + bindFlags |= Resource::BindFlag::ConstantBuffer; + srcDesc.cpuAccessFlags |= Resource::AccessFlag::Write; + initialUsage = Resource::Usage::ConstantBuffer; + } + else + { + bindFlags |= Resource::BindFlag::UnorderedAccess | Resource::BindFlag::PixelShaderResource | Resource::BindFlag::NonPixelShaderResource; + srcDesc.elementSize = inputDesc.stride; + initialUsage = Resource::Usage::UnorderedAccess; + } + + if (isOutput) + { + srcDesc.cpuAccessFlags |= Resource::AccessFlag::Read; + } + + srcDesc.bindFlags = bindFlags; + + RefPtr bufferResource = renderer->createBufferResource(initialUsage, srcDesc, initData); + if (!bufferResource) + { + return SLANG_FAIL; + } + + bufferOut = bufferResource; + return SLANG_OK; +} + +static BindingState::SamplerDesc _calcSamplerDesc(const InputSamplerDesc& srcDesc) +{ + BindingState::SamplerDesc dstDesc; + dstDesc.isCompareSampler = srcDesc.isCompareSampler; + return dstDesc; +} + +/* static */Result ShaderRendererUtil::createBindingStateDesc(ShaderInputLayoutEntry* srcEntries, int numEntries, Renderer* renderer, BindingState::Desc& descOut) +{ + const int textureBindFlags = Resource::BindFlag::NonPixelShaderResource | Resource::BindFlag::PixelShaderResource; + + descOut.clear(); + for (int i = 0; i < numEntries; i++) + { + const ShaderInputLayoutEntry& srcEntry = srcEntries[i]; + + BindingState::ShaderBindSet shaderBindSet; + shaderBindSet.set(BindingState::ShaderStyle::Hlsl, descOut.makeCompactSlice(srcEntry.hlslBinding)); + shaderBindSet.set(BindingState::ShaderStyle::Glsl, descOut.makeCompactSlice(srcEntry.glslBinding.Buffer(), int(srcEntry.glslBinding.Count()))); + + switch (srcEntry.type) + { + case ShaderInputType::Buffer: + { + const InputBufferDesc& srcBuffer = srcEntry.bufferDesc; + + const size_t bufferSize = srcEntry.bufferData.Count() * sizeof(uint32_t); + + RefPtr bufferResource; + SLANG_RETURN_ON_FAIL(createBufferResource(srcEntry.bufferDesc, srcEntry.isOutput, bufferSize, srcEntry.bufferData.Buffer(), renderer, bufferResource)); + + descOut.addBufferResource(bufferResource, shaderBindSet); + break; + } + case ShaderInputType::CombinedTextureSampler: + { + RefPtr texture; + SLANG_RETURN_ON_FAIL(generateTextureResource(srcEntry.textureDesc, textureBindFlags, renderer, texture)); + descOut.addCombinedTextureSampler(texture, _calcSamplerDesc(srcEntry.samplerDesc), shaderBindSet); + break; + } + case ShaderInputType::Texture: + { + RefPtr texture; + SLANG_RETURN_ON_FAIL(generateTextureResource(srcEntry.textureDesc, textureBindFlags, renderer, texture)); + + descOut.addTextureResource(texture, shaderBindSet); + break; + } + case ShaderInputType::Sampler: + { + descOut.addSampler(_calcSamplerDesc(srcEntry.samplerDesc), shaderBindSet); + break; + } + default: + { + assert(!"Unhandled type"); + return SLANG_FAIL; + } + } + } + + return SLANG_OK; +} + +/* static */Result ShaderRendererUtil::createBindingStateDesc(const ShaderInputLayout& layout, Renderer* renderer, BindingState::Desc& descOut) +{ + SLANG_RETURN_ON_FAIL(createBindingStateDesc(layout.entries.Buffer(), int(layout.entries.Count()), renderer, descOut)); + descOut.m_numRenderTargets = layout.numRenderTargets; + return SLANG_OK; +} + +} // renderer_test -- cgit v1.2.3