From 3861be7ce5bd3ffc1bc60f2c3f7f41647145d575 Mon Sep 17 00:00:00 2001 From: Simon Kallweit <64953474+skallweitNV@users.noreply.github.com> Date: Thu, 19 Sep 2024 17:16:48 +0200 Subject: refactor render test to use latest slang-rhi (#5119) * refactor render test to use latest slang-rhi * update slang-rhi * update slang-rhi * update slang-rhi * update slang-rhi --- tools/render-test/options.cpp | 8 +- tools/render-test/options.h | 4 +- tools/render-test/render-test-main.cpp | 351 +++++++++++------------------ tools/render-test/shader-input-layout.cpp | 12 +- tools/render-test/shader-renderer-util.cpp | 184 ++++++--------- tools/render-test/shader-renderer-util.h | 16 +- tools/render-test/slang-support.cpp | 30 --- tools/render-test/slang-support.h | 4 +- 8 files changed, 233 insertions(+), 376 deletions(-) (limited to 'tools/render-test') diff --git a/tools/render-test/options.cpp b/tools/render-test/options.cpp index 2879acfac..dc1850d37 100644 --- a/tools/render-test/options.cpp +++ b/tools/render-test/options.cpp @@ -34,7 +34,7 @@ static rhi::DeviceType _toRenderType(Slang::RenderApiType apiType) case RenderApiType::CPU: return rhi::DeviceType::CPU; case RenderApiType::CUDA: return rhi::DeviceType::CUDA; default: - return rhi::DeviceType::Unknown; + return rhi::DeviceType::Default; } } @@ -244,7 +244,7 @@ static rhi::DeviceType _toRenderType(Slang::RenderApiType apiType) UnownedStringSlice argName = argSlice.tail(1); DeviceType deviceType = _toRenderType(RenderApiUtil::findApiTypeByName(argName)); - if (deviceType != DeviceType::Unknown) + if (deviceType != DeviceType::Default) { outOptions.deviceType = deviceType; continue; @@ -253,7 +253,7 @@ static rhi::DeviceType _toRenderType(Slang::RenderApiType apiType) // Lookup the target language type DeviceType targetLanguageDeviceType = _toRenderType(RenderApiUtil::findImplicitLanguageRenderApiType(argName)); - if (targetLanguageDeviceType != DeviceType::Unknown || argName == "glsl") + if (targetLanguageDeviceType != DeviceType::Default || argName == "glsl") { outOptions.targetLanguageDeviceType = targetLanguageDeviceType; outOptions.inputLanguageID = (argName == "hlsl" || argName == "glsl" || argName == "cpp" || argName == "cxx" || argName == "c") ? InputLanguageID::Native : InputLanguageID::Slang; @@ -266,7 +266,7 @@ static rhi::DeviceType _toRenderType(Slang::RenderApiType apiType) } // If a render option isn't set use defaultRenderType - outOptions.deviceType = (outOptions.deviceType == DeviceType::Unknown) + outOptions.deviceType = (outOptions.deviceType == DeviceType::Default) ? outOptions.targetLanguageDeviceType : outOptions.deviceType; diff --git a/tools/render-test/options.h b/tools/render-test/options.h index 6b0841c7d..bd5e65a1a 100644 --- a/tools/render-test/options.h +++ b/tools/render-test/options.h @@ -53,9 +53,9 @@ struct Options ShaderProgramType shaderType = ShaderProgramType::Graphics; /// The renderer type inferred from the target language type. Used if a rendererType is not explicitly set. - DeviceType targetLanguageDeviceType = DeviceType::Unknown; + DeviceType targetLanguageDeviceType = DeviceType::Default; /// The set render type - DeviceType deviceType = DeviceType::Unknown; + DeviceType deviceType = DeviceType::Default; InputLanguageID inputLanguageID = InputLanguageID::Slang; SlangSourceLanguage sourceLanguage = SLANG_SOURCE_LANGUAGE_UNKNOWN; diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp index 5712485cc..370225c7c 100644 --- a/tools/render-test/render-test-main.cpp +++ b/tools/render-test/render-test-main.cpp @@ -127,18 +127,18 @@ protected: IDevice* m_device; ComPtr m_queue; ComPtr m_transientHeap; - ComPtr m_renderPass; ComPtr m_inputLayout; - ComPtr m_vertexBuffer; + ComPtr m_vertexBuffer; ComPtr m_shaderProgram; - ComPtr m_pipelineState; - ComPtr m_framebufferLayout; - ComPtr m_framebuffer; - ComPtr m_colorBuffer; + ComPtr m_pipeline; + ComPtr m_depthBuffer; + ComPtr m_depthBufferView; + ComPtr m_colorBuffer; + ComPtr m_colorBufferView; - ComPtr m_blasBuffer; + ComPtr m_blasBuffer; ComPtr m_bottomLevelAccelerationStructure; - ComPtr m_tlasBuffer; + ComPtr m_tlasBuffer; ComPtr m_topLevelAccelerationStructure; ShaderCompilerUtil::OutputAndLayout m_compilationOutput; @@ -212,10 +212,10 @@ struct AssignValsFromLayoutContext for (size_t i = bufferData.getCount(); i < bufferSize / sizeof(uint32_t); i++) bufferData.add(0); - ComPtr bufferResource; - SLANG_RETURN_ON_FAIL(ShaderRendererUtil::createBufferResource(srcBuffer, /*entry.isOutput,*/ bufferSize, bufferData.getBuffer(), device, bufferResource)); + ComPtr bufferResource; + SLANG_RETURN_ON_FAIL(ShaderRendererUtil::createBuffer(srcBuffer, /*entry.isOutput,*/ bufferSize, bufferData.getBuffer(), device, bufferResource)); - ComPtr counterResource; + ComPtr counterResource; const auto explicitCounterCursor = dstCursor.getExplicitCounter(); if(srcBuffer.counter != ~0u) { @@ -238,7 +238,7 @@ struct AssignValsFromLayoutContext 1, Format::Unknown, }; - SLANG_RETURN_ON_FAIL(ShaderRendererUtil::createBufferResource( + SLANG_RETURN_ON_FAIL(ShaderRendererUtil::createBuffer( counterBufferDesc, sizeof(srcBuffer.counter), &srcBuffer.counter, @@ -254,11 +254,14 @@ struct AssignValsFromLayoutContext return SLANG_E_INVALID_ARG; } - IResourceView::Desc viewDesc = {}; - viewDesc.type = IResourceView::Type::UnorderedAccess; - viewDesc.format = srcBuffer.format; - auto bufferView = device->createBufferView(bufferResource, counterResource, viewDesc); - dstCursor.setResource(bufferView); + if (counterResource) + { + dstCursor.setBinding(Binding(bufferResource, counterResource)); + } + else + { + dstCursor.setBinding(bufferResource); + } maybeAddOutput(dstCursor, srcVal, bufferResource); return SLANG_OK; @@ -269,19 +272,13 @@ struct AssignValsFromLayoutContext auto& textureEntry = srcVal->textureVal; auto& samplerEntry = srcVal->samplerVal; - ComPtr texture; - SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTextureResource( + ComPtr texture; + SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTexture( textureEntry->textureDesc, ResourceState::ShaderResource, device, texture)); - auto sampler = _createSamplerState(device, samplerEntry->samplerDesc); - - IResourceView::Desc viewDesc = {}; - viewDesc.type = IResourceView::Type::ShaderResource; - auto textureView = device->createTextureView( - texture, - viewDesc); + auto sampler = _createSampler(device, samplerEntry->samplerDesc); - dstCursor.setCombinedTextureSampler(textureView, sampler); + dstCursor.setBinding(Binding(texture, sampler)); maybeAddOutput(dstCursor, srcVal, texture); return SLANG_OK; @@ -289,41 +286,23 @@ struct AssignValsFromLayoutContext SlangResult assignTexture(ShaderCursor const& dstCursor, ShaderInputLayout::TextureVal* srcVal) { - ComPtr texture; - ResourceState defaultState = ResourceState::ShaderResource; - IResourceView::Type viewType = IResourceView::Type::ShaderResource; + ComPtr texture; + ResourceState defaultState = srcVal->textureDesc.isRWTexture ? + ResourceState::UnorderedAccess : ResourceState::ShaderResource; - if (srcVal->textureDesc.isRWTexture) - { - defaultState = ResourceState::UnorderedAccess; - viewType = IResourceView::Type::UnorderedAccess; - } - - SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTextureResource( + SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTexture( srcVal->textureDesc, defaultState, device, texture)); - IResourceView::Desc viewDesc = {}; - viewDesc.type = viewType; - viewDesc.format = texture->getDesc()->format; - auto textureView = device->createTextureView( - texture, - viewDesc); - - if (!textureView) - { - return SLANG_FAIL; - } - - dstCursor.setResource(textureView); + dstCursor.setBinding(texture); maybeAddOutput(dstCursor, srcVal, texture); return SLANG_OK; } SlangResult assignSampler(ShaderCursor const& dstCursor, ShaderInputLayout::SamplerVal* srcVal) { - auto sampler = _createSamplerState(device, srcVal->samplerDesc); + auto sampler = _createSampler(device, srcVal->samplerDesc); - dstCursor.setSampler(sampler); + dstCursor.setBinding(sampler); return SLANG_OK; } @@ -437,7 +416,7 @@ struct AssignValsFromLayoutContext ShaderCursor const& dstCursor, ShaderInputLayout::AccelerationStructureVal* srcVal) { - dstCursor.setResource(accelerationStructure); + dstCursor.setBinding(accelerationStructure); return SLANG_OK; } @@ -511,7 +490,7 @@ Result RenderTestApp::applyBinding(PipelineType pipelineType, ICommandEncoder* e case PipelineType::Compute: { IComputeCommandEncoder* computeEncoder = static_cast(encoder); - auto rootObject = computeEncoder->bindPipeline(m_pipelineState); + auto rootObject = computeEncoder->bindPipeline(m_pipeline); SLANG_RETURN_ON_FAIL(_assignVarsFromLayout( m_device, slangSession, @@ -525,7 +504,7 @@ Result RenderTestApp::applyBinding(PipelineType pipelineType, ICommandEncoder* e case PipelineType::Graphics: { IRenderCommandEncoder* renderEncoder = static_cast(encoder); - auto rootObject = renderEncoder->bindPipeline(m_pipelineState); + auto rootObject = renderEncoder->bindPipeline(m_pipeline); SLANG_RETURN_ON_FAIL(_assignVarsFromLayout( m_device, slangSession, @@ -559,7 +538,7 @@ SlangResult RenderTestApp::initialize( // Once the shaders have been compiled we load them via the underlying API. // ComPtr outDiagnostics; - auto result = device->createProgram(m_compilationOutput.output.desc, m_shaderProgram.writeRef(), outDiagnostics.writeRef()); + auto result = device->createShaderProgram(m_compilationOutput.output.desc, m_shaderProgram.writeRef(), outDiagnostics.writeRef()); // If there was a failure creating a program, we can't continue // Special case SLANG_E_NOT_AVAILABLE error code to make it a failure, @@ -585,10 +564,10 @@ SlangResult RenderTestApp::initialize( case Options::ShaderProgramType::Compute: { - ComputePipelineStateDesc desc; + ComputePipelineDesc desc; desc.program = m_shaderProgram; - m_pipelineState = device->createComputePipelineState(desc); + m_pipeline = device->createComputePipeline(desc); } break; @@ -614,37 +593,44 @@ SlangResult RenderTestApp::initialize( SLANG_RETURN_ON_FAIL(device->createInputLayout( sizeof(Vertex), inputElements, SLANG_COUNT_OF(inputElements), inputLayout.writeRef())); - IBufferResource::Desc vertexBufferDesc; - vertexBufferDesc.type = IResource::Type::Buffer; - vertexBufferDesc.sizeInBytes = kVertexCount * sizeof(Vertex); + BufferDesc vertexBufferDesc; + vertexBufferDesc.size = kVertexCount * sizeof(Vertex); vertexBufferDesc.memoryType = MemoryType::Upload; + vertexBufferDesc.usage = BufferUsage::VertexBuffer; vertexBufferDesc.defaultState = ResourceState::VertexBuffer; - vertexBufferDesc.allowedStates = ResourceStateSet(ResourceState::VertexBuffer); - SLANG_RETURN_ON_FAIL(device->createBufferResource( + SLANG_RETURN_ON_FAIL(device->createBuffer( vertexBufferDesc, kVertexData, m_vertexBuffer.writeRef())); - GraphicsPipelineStateDesc desc; + ColorTargetState colorTarget; + colorTarget.format = Format::R8G8B8A8_UNORM; + RenderPipelineDesc desc; desc.program = m_shaderProgram; desc.inputLayout = inputLayout; - desc.framebufferLayout = m_framebufferLayout; - m_pipelineState = device->createGraphicsPipelineState(desc); + desc.targets = &colorTarget; + desc.targetCount = 1; + desc.depthStencil.format = Format::D32_FLOAT; + m_pipeline = device->createRenderPipeline(desc); } break; case Options::ShaderProgramType::GraphicsMeshCompute: case Options::ShaderProgramType::GraphicsTaskMeshCompute: { - GraphicsPipelineStateDesc desc; + ColorTargetState colorTarget; + colorTarget.format = Format::R8G8B8A8_UNORM; + RenderPipelineDesc desc; desc.program = m_shaderProgram; - desc.framebufferLayout = m_framebufferLayout; - m_pipelineState = device->createGraphicsPipelineState(desc); + desc.targets = &colorTarget; + desc.targetCount = 1; + desc.depthStencil.format = Format::D32_FLOAT; + m_pipeline = device->createRenderPipeline(desc); } } } // If success must have a pipeline state - return m_pipelineState ? SLANG_OK : SLANG_FAIL; + return m_pipeline ? SLANG_OK : SLANG_FAIL; } Result RenderTestApp::_initializeShaders( @@ -655,7 +641,7 @@ Result RenderTestApp::_initializeShaders( { SLANG_RETURN_ON_FAIL(ShaderCompilerUtil::compileWithLayout(device->getSlangSession()->getGlobalSession(), m_options, input, m_compilationOutput)); m_shaderInputLayout = m_compilationOutput.layout; - m_shaderProgram = device->createProgram(m_compilationOutput.output.desc); + m_shaderProgram = device->createShaderProgram(m_compilationOutput.output.desc); return m_shaderProgram ? SLANG_OK : SLANG_FAIL; } @@ -670,102 +656,54 @@ void RenderTestApp::_initializeRenderPass() m_queue = m_device->createCommandQueue(queueDesc); SLANG_ASSERT(m_queue); - rhi::ITextureResource::Desc depthBufferDesc; - depthBufferDesc.type = IResource::Type::Texture2D; + rhi::TextureDesc depthBufferDesc; + depthBufferDesc.type = TextureType::Texture2D; depthBufferDesc.size.width = gWindowWidth; depthBufferDesc.size.height = gWindowHeight; depthBufferDesc.size.depth = 1; depthBufferDesc.numMipLevels = 1; depthBufferDesc.format = Format::D32_FLOAT; + depthBufferDesc.usage = TextureUsage::DepthWrite; depthBufferDesc.defaultState = ResourceState::DepthWrite; - depthBufferDesc.allowedStates = ResourceState::DepthWrite; - - ComPtr depthBufferResource = - m_device->createTextureResource(depthBufferDesc, nullptr); - SLANG_ASSERT(depthBufferResource); + m_depthBuffer = m_device->createTexture(depthBufferDesc, nullptr); + SLANG_ASSERT(m_depthBuffer); + m_depthBufferView = m_device->createTextureView(m_depthBuffer, {}); + SLANG_ASSERT(m_depthBufferView); - rhi::ITextureResource::Desc colorBufferDesc; - colorBufferDesc.type = IResource::Type::Texture2D; + rhi::TextureDesc colorBufferDesc; + colorBufferDesc.type = TextureType::Texture2D; colorBufferDesc.size.width = gWindowWidth; colorBufferDesc.size.height = gWindowHeight; colorBufferDesc.size.depth = 1; colorBufferDesc.numMipLevels = 1; colorBufferDesc.format = Format::R8G8B8A8_UNORM; + colorBufferDesc.usage = TextureUsage::RenderTarget; colorBufferDesc.defaultState = ResourceState::RenderTarget; - colorBufferDesc.allowedStates = ResourceState::RenderTarget; - m_colorBuffer = m_device->createTextureResource(colorBufferDesc, nullptr); + m_colorBuffer = m_device->createTexture(colorBufferDesc, nullptr); SLANG_ASSERT(m_colorBuffer); - - rhi::IResourceView::Desc colorBufferViewDesc = {}; - memset(&colorBufferViewDesc, 0, sizeof(colorBufferViewDesc)); - colorBufferViewDesc.format = rhi::Format::R8G8B8A8_UNORM; - colorBufferViewDesc.renderTarget.shape = rhi::IResource::Type::Texture2D; - colorBufferViewDesc.type = rhi::IResourceView::Type::RenderTarget; - ComPtr rtv = - m_device->createTextureView(m_colorBuffer.get(), colorBufferViewDesc); - SLANG_ASSERT(rtv); - - rhi::IResourceView::Desc depthBufferViewDesc = {}; - memset(&depthBufferViewDesc, 0, sizeof(depthBufferViewDesc)); - depthBufferViewDesc.format = rhi::Format::D32_FLOAT; - depthBufferViewDesc.renderTarget.shape = rhi::IResource::Type::Texture2D; - depthBufferViewDesc.type = rhi::IResourceView::Type::DepthStencil; - ComPtr dsv = - m_device->createTextureView(depthBufferResource.get(), depthBufferViewDesc); - SLANG_ASSERT(dsv); - - IFramebufferLayout::TargetLayout colorTarget = {rhi::Format::R8G8B8A8_UNORM, 1}; - IFramebufferLayout::TargetLayout depthTarget = {rhi::Format::D32_FLOAT, 1}; - rhi::IFramebufferLayout::Desc framebufferLayoutDesc; - framebufferLayoutDesc.renderTargetCount = 1; - framebufferLayoutDesc.renderTargets = &colorTarget; - framebufferLayoutDesc.depthStencil = &depthTarget; - m_device->createFramebufferLayout(framebufferLayoutDesc, m_framebufferLayout.writeRef()); - - rhi::IFramebuffer::Desc framebufferDesc; - framebufferDesc.renderTargetCount = 1; - framebufferDesc.depthStencilView = dsv.get(); - framebufferDesc.renderTargetViews = rtv.readRef(); - framebufferDesc.layout = m_framebufferLayout; - m_device->createFramebuffer(framebufferDesc, m_framebuffer.writeRef()); - - IRenderPassLayout::Desc renderPassDesc = {}; - renderPassDesc.framebufferLayout = m_framebufferLayout; - renderPassDesc.renderTargetCount = 1; - IRenderPassLayout::TargetAccessDesc renderTargetAccess = {}; - IRenderPassLayout::TargetAccessDesc depthStencilAccess = {}; - renderTargetAccess.loadOp = IRenderPassLayout::TargetLoadOp::Clear; - renderTargetAccess.storeOp = IRenderPassLayout::TargetStoreOp::Store; - renderTargetAccess.initialState = ResourceState::Undefined; - renderTargetAccess.finalState = ResourceState::RenderTarget; - depthStencilAccess.loadOp = IRenderPassLayout::TargetLoadOp::Clear; - depthStencilAccess.storeOp = IRenderPassLayout::TargetStoreOp::Store; - depthStencilAccess.initialState = ResourceState::Undefined; - depthStencilAccess.finalState = ResourceState::DepthWrite; - renderPassDesc.renderTargetAccess = &renderTargetAccess; - renderPassDesc.depthStencilAccess = &depthStencilAccess; - m_device->createRenderPassLayout(renderPassDesc, m_renderPass.writeRef()); + m_colorBufferView = m_device->createTextureView(m_colorBuffer, {}); + SLANG_ASSERT(m_colorBufferView); } void RenderTestApp::_initializeAccelerationStructure() { if (!m_device->hasFeature("ray-tracing")) return; - IBufferResource::Desc vertexBufferDesc = {}; - vertexBufferDesc.type = IResource::Type::Buffer; - vertexBufferDesc.sizeInBytes = kVertexCount * sizeof(Vertex); - vertexBufferDesc.defaultState = ResourceState::ShaderResource; - ComPtr vertexBuffer = - m_device->createBufferResource(vertexBufferDesc, &kVertexData[0]); - - IBufferResource::Desc transformBufferDesc = {}; - transformBufferDesc.type = IResource::Type::Buffer; - transformBufferDesc.sizeInBytes = sizeof(float) * 12; - transformBufferDesc.defaultState = ResourceState::ShaderResource; + BufferDesc vertexBufferDesc = {}; + vertexBufferDesc.size = kVertexCount * sizeof(Vertex); + vertexBufferDesc.usage = BufferUsage::AccelerationStructureBuildInput; + vertexBufferDesc.defaultState = ResourceState::AccelerationStructureBuildInput; + ComPtr vertexBuffer = + m_device->createBuffer(vertexBufferDesc, &kVertexData[0]); + + BufferDesc transformBufferDesc = {}; + transformBufferDesc.size = sizeof(float) * 12; + transformBufferDesc.usage = BufferUsage::AccelerationStructureBuildInput; + transformBufferDesc.defaultState = ResourceState::AccelerationStructureBuildInput; float transformData[12] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f}; - ComPtr transformBuffer = - m_device->createBufferResource(transformBufferDesc, &transformData); + ComPtr transformBuffer = + m_device->createBuffer(transformBufferDesc, &transformData); // Build bottom level acceleration structure. { @@ -792,20 +730,20 @@ void RenderTestApp::_initializeAccelerationStructure() m_device->getAccelerationStructurePrebuildInfo( accelerationStructureBuildInputs, &accelerationStructurePrebuildInfo); // Allocate buffers for acceleration structure. - IBufferResource::Desc asDraftBufferDesc = {}; - asDraftBufferDesc.type = IResource::Type::Buffer; + BufferDesc asDraftBufferDesc = {}; + asDraftBufferDesc.usage = BufferUsage::AccelerationStructure; asDraftBufferDesc.defaultState = ResourceState::AccelerationStructure; - asDraftBufferDesc.sizeInBytes = accelerationStructurePrebuildInfo.resultDataMaxSize; - ComPtr draftBuffer = m_device->createBufferResource(asDraftBufferDesc); - IBufferResource::Desc scratchBufferDesc = {}; - scratchBufferDesc.type = IResource::Type::Buffer; + asDraftBufferDesc.size = accelerationStructurePrebuildInfo.resultDataMaxSize; + ComPtr draftBuffer = m_device->createBuffer(asDraftBufferDesc); + BufferDesc scratchBufferDesc = {}; + scratchBufferDesc.usage = BufferUsage::UnorderedAccess; scratchBufferDesc.defaultState = ResourceState::UnorderedAccess; - scratchBufferDesc.sizeInBytes = accelerationStructurePrebuildInfo.scratchDataSize; - ComPtr scratchBuffer = m_device->createBufferResource(scratchBufferDesc); + scratchBufferDesc.size = accelerationStructurePrebuildInfo.scratchDataSize; + ComPtr scratchBuffer = m_device->createBuffer(scratchBufferDesc); // Build acceleration structure. ComPtr compactedSizeQuery; - IQueryPool::Desc queryPoolDesc = {}; + QueryPoolDesc queryPoolDesc = {}; queryPoolDesc.count = 1; queryPoolDesc.type = QueryType::AccelerationStructureCompactedSize; m_device->createQueryPool(queryPoolDesc, compactedSizeQuery.writeRef()); @@ -837,11 +775,11 @@ void RenderTestApp::_initializeAccelerationStructure() uint64_t compactedSize = 0; compactedSizeQuery->getResult(0, 1, &compactedSize); - IBufferResource::Desc asBufferDesc = {}; - asBufferDesc.type = IResource::Type::Buffer; + BufferDesc asBufferDesc = {}; + asBufferDesc.usage = BufferUsage::AccelerationStructure; asBufferDesc.defaultState = ResourceState::AccelerationStructure; - asBufferDesc.sizeInBytes = (Size)compactedSize; - m_blasBuffer = m_device->createBufferResource(asBufferDesc); + asBufferDesc.size = (Size)compactedSize; + m_blasBuffer = m_device->createBuffer(asBufferDesc); IAccelerationStructure::CreateDesc createDesc; createDesc.buffer = m_blasBuffer; createDesc.kind = IAccelerationStructure::Kind::BottomLevel; @@ -874,13 +812,13 @@ void RenderTestApp::_initializeAccelerationStructure() 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f}; memcpy(&instanceDescs[0].transform[0][0], transformMatrix, sizeof(float) * 12); - IBufferResource::Desc instanceBufferDesc = {}; - instanceBufferDesc.type = IResource::Type::Buffer; - instanceBufferDesc.sizeInBytes = + BufferDesc instanceBufferDesc = {}; + instanceBufferDesc.size = instanceDescs.getCount() * sizeof(IAccelerationStructure::InstanceDesc); + instanceBufferDesc.usage = BufferUsage::AccelerationStructureBuildInput; instanceBufferDesc.defaultState = ResourceState::AccelerationStructureBuildInput; - ComPtr instanceBuffer = - m_device->createBufferResource(instanceBufferDesc, instanceDescs.getBuffer()); + ComPtr instanceBuffer = + m_device->createBuffer(instanceBufferDesc, instanceDescs.getBuffer()); IAccelerationStructure::BuildInputs accelerationStructureBuildInputs = {}; IAccelerationStructure::PrebuildInfo accelerationStructurePrebuildInfo = {}; @@ -892,17 +830,17 @@ void RenderTestApp::_initializeAccelerationStructure() m_device->getAccelerationStructurePrebuildInfo( accelerationStructureBuildInputs, &accelerationStructurePrebuildInfo); - IBufferResource::Desc asBufferDesc = {}; - asBufferDesc.type = IResource::Type::Buffer; + BufferDesc asBufferDesc = {}; + asBufferDesc.usage = BufferUsage::AccelerationStructure; asBufferDesc.defaultState = ResourceState::AccelerationStructure; - asBufferDesc.sizeInBytes = (size_t)accelerationStructurePrebuildInfo.resultDataMaxSize; - m_tlasBuffer = m_device->createBufferResource(asBufferDesc); + asBufferDesc.size = (size_t)accelerationStructurePrebuildInfo.resultDataMaxSize; + m_tlasBuffer = m_device->createBuffer(asBufferDesc); - IBufferResource::Desc scratchBufferDesc = {}; - scratchBufferDesc.type = IResource::Type::Buffer; + BufferDesc scratchBufferDesc = {}; + scratchBufferDesc.usage = BufferUsage::UnorderedAccess; scratchBufferDesc.defaultState = ResourceState::UnorderedAccess; - scratchBufferDesc.sizeInBytes = (size_t)accelerationStructurePrebuildInfo.scratchDataSize; - ComPtr scratchBuffer = m_device->createBufferResource(scratchBufferDesc); + scratchBufferDesc.size = (size_t)accelerationStructurePrebuildInfo.scratchDataSize; + ComPtr scratchBuffer = m_device->createBuffer(scratchBufferDesc); IAccelerationStructure::CreateDesc createDesc = {}; createDesc.buffer = m_tlasBuffer; @@ -987,48 +925,16 @@ Result RenderTestApp::writeBindingOutput(const String& fileName) for(auto outputItem : m_outputPlan.items) { auto resource = outputItem.resource; - if (resource && resource->getType() == IResource::Type::Buffer) + IBuffer* buffer = nullptr; + resource->queryInterface(IBuffer::getTypeGuid(), (void**)&buffer); + if (buffer) { - IBufferResource* bufferResource = static_cast(resource.get()); - auto bufferDesc = *bufferResource->getDesc(); - const size_t bufferSize = bufferDesc.sizeInBytes; + const BufferDesc& bufferDesc = buffer->getDesc(); + const size_t bufferSize = bufferDesc.size; ComPtr blob; - if(bufferDesc.memoryType == MemoryType::ReadBack) - { - // The buffer is already allocated for CPU access, so we can read it back directly. - // - m_device->readBufferResource(bufferResource, 0, bufferSize, blob.writeRef()); - } - else - { - // The buffer is not CPU-readable, so we will copy it using a staging buffer. - - auto stagingBufferDesc = bufferDesc; - stagingBufferDesc.memoryType = MemoryType::ReadBack; - stagingBufferDesc.allowedStates = - ResourceStateSet(ResourceState::CopyDestination, ResourceState::CopySource); - stagingBufferDesc.defaultState = ResourceState::CopyDestination; - - ComPtr stagingBuffer; - SLANG_RETURN_ON_FAIL(m_device->createBufferResource(stagingBufferDesc, nullptr, stagingBuffer.writeRef())); - - ComPtr commandBuffer; - SLANG_RETURN_ON_FAIL( - m_transientHeap->createCommandBuffer(commandBuffer.writeRef())); - - IResourceCommandEncoder* encoder = nullptr; - commandBuffer->encodeResourceCommands(&encoder); - encoder->copyBuffer(stagingBuffer, 0, bufferResource, 0, bufferSize); - encoder->endEncoding(); - - commandBuffer->close(); - m_queue->executeCommandBuffer(commandBuffer); - m_transientHeap->finish(); - m_transientHeap->synchronizeAndReset(); - - SLANG_RETURN_ON_FAIL(m_device->readBufferResource(stagingBuffer, 0, bufferSize, blob.writeRef())); - } + m_device->readBuffer(buffer, 0, bufferSize, blob.writeRef()); + buffer->release(); if (!blob) { @@ -1054,7 +960,7 @@ Result RenderTestApp::writeScreen(const String& filename) { size_t rowPitch, pixelSize; ComPtr blob; - SLANG_RETURN_ON_FAIL(m_device->readTextureResource( + SLANG_RETURN_ON_FAIL(m_device->readTexture( m_colorBuffer, ResourceState::RenderTarget, blob.writeRef(), &rowPitch, &pixelSize)); auto bufferSize = blob->getBufferSize(); uint32_t width = static_cast(rowPitch / pixelSize); @@ -1073,7 +979,24 @@ Result RenderTestApp::update() } else { - auto encoder = commandBuffer->encodeRenderCommands(m_renderPass, m_framebuffer); + RenderPassColorAttachment colorAttachment = {}; + colorAttachment.view = m_colorBufferView; + colorAttachment.loadOp = LoadOp::Clear; + colorAttachment.storeOp = StoreOp::Store; + colorAttachment.initialState = ResourceState::Undefined; + colorAttachment.finalState = ResourceState::RenderTarget; + RenderPassDepthStencilAttachment depthStencilAttachment = {}; + depthStencilAttachment.view = m_depthBufferView; + depthStencilAttachment.depthLoadOp = LoadOp::Clear; + depthStencilAttachment.depthStoreOp = StoreOp::Store; + depthStencilAttachment.initialState = ResourceState::Undefined; + depthStencilAttachment.finalState = ResourceState::DepthWrite; + RenderPassDesc renderPass = {}; + renderPass.colorAttachments = &colorAttachment; + renderPass.colorAttachmentCount = 1; + renderPass.depthStencilAttachment = &depthStencilAttachment; + + auto encoder = commandBuffer->encodeRenderCommands(renderPass); rhi::Viewport viewport = {}; viewport.maxZ = 1.0f; viewport.extentX = (float)gWindowWidth; @@ -1113,7 +1036,7 @@ Result RenderTestApp::update() if (binding.resource && binding.resource->isBuffer()) { BufferResource* bufferResource = static_cast(binding.resource.Ptr()); - const size_t bufferSize = bufferResource->getDesc().sizeInBytes; + const size_t bufferSize = bufferResource->getDesc().size; unsigned int* ptr = (unsigned int*)m_renderer->map(bufferResource, MapFlavor::HostRead); if (!ptr) { @@ -1252,7 +1175,7 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi // Parse command-line options SLANG_RETURN_ON_FAIL(Options::parse(argcIn, argvIn, StdWriters::getError(), options)); - if (options.deviceType == DeviceType::Unknown) + if (options.deviceType == DeviceType::Default) { return SLANG_OK; } diff --git a/tools/render-test/shader-input-layout.cpp b/tools/render-test/shader-input-layout.cpp index 97b82e1e9..61951db50 100644 --- a/tools/render-test/shader-input-layout.cpp +++ b/tools/render-test/shader-input-layout.cpp @@ -19,9 +19,15 @@ namespace renderer_test Format _getFormatFromName(const UnownedStringSlice& slice) { -#define SLANG_FORMAT_CASE(name, blockSizeInBytes, pixelsPerBlock) if (slice == #name) return Format::name; else - - SLANG_RHI_FORMAT(SLANG_FORMAT_CASE) + for (int i = 0; i < int(Format::_Count); ++i) + { + FormatInfo info; + rhiGetFormatInfo(Format(i), &info); + if (slice == info.name) + { + return Format(i); + } + } return Format::Unknown; } diff --git a/tools/render-test/shader-renderer-util.cpp b/tools/render-test/shader-renderer-util.cpp index c2f7583a7..5448979b4 100644 --- a/tools/render-test/shader-renderer-util.cpp +++ b/tools/render-test/shader-renderer-util.cpp @@ -13,49 +13,26 @@ inline int calcMipSize(int size, int level) return size > 0 ? size : 1; } -inline ITextureResource::Extents calcMipSize(ITextureResource::Extents size, int mipLevel) +inline Extents calcMipSize(Extents size, int mipLevel) { - ITextureResource::Extents rs; + Extents rs; rs.width = calcMipSize(size.width, mipLevel); rs.height = calcMipSize(size.height, mipLevel); rs.depth = calcMipSize(size.depth, mipLevel); return rs; } -/// Calculate the effective array size - in essence the amount if mip map sets needed. -/// In practice takes into account if the arraySize is 0 (it's not an array, but it will still have -/// at least one mip set) and if the type is a cubemap (multiplies the amount of mip sets by 6) -inline int calcEffectiveArraySize(const ITextureResource::Desc& desc) -{ - const int arrSize = (desc.arraySize > 0) ? desc.arraySize : 1; - - switch (desc.type) - { - case IResource::Type::Texture1D: // fallthru - case IResource::Type::Texture2D: - { - return arrSize; - } - case IResource::Type::TextureCube: - return arrSize * 6; - case IResource::Type::Texture3D: - return 1; - default: - return 0; - } -} - /// Given the type works out the maximum dimension size -inline int calcMaxDimension(ITextureResource::Extents size, IResource::Type type) +inline int calcMaxDimension(Extents size, TextureType type) { switch (type) { - case IResource::Type::Texture1D: + case TextureType::Texture1D: return size.width; - case IResource::Type::Texture3D: + case TextureType::Texture3D: return Math::Max(Math::Max(size.width, size.height), size.depth); - case IResource::Type::TextureCube: // fallthru - case IResource::Type::Texture2D: + case TextureType::TextureCube: // fallthru + case TextureType::Texture2D: { return Math::Max(size.width, size.height); } @@ -65,115 +42,103 @@ inline int calcMaxDimension(ITextureResource::Extents size, IResource::Type type } /// Given the type, calculates the number of mip maps. 0 on error -inline int calcNumMipLevels(IResource::Type type, ITextureResource::Extents size) +inline int calcNumMipLevels(TextureType type, Extents size) { const int maxDimensionSize = calcMaxDimension(size, type); return (maxDimensionSize > 0) ? (Math::Log2Floor(maxDimensionSize) + 1) : 0; } -/// Calculate the total number of sub resources. 0 on error. -inline int calcNumSubResources(const ITextureResource::Desc& desc) -{ - const int numMipMaps = - (desc.numMipLevels > 0) ? desc.numMipLevels : calcNumMipLevels(desc.type, desc.size); - const int arrSize = (desc.arraySize > 0) ? desc.arraySize : 1; - - switch (desc.type) - { - case IResource::Type::Texture1D: - case IResource::Type::Texture2D: - case IResource::Type::Texture3D: - { - return numMipMaps * arrSize; - } - case IResource::Type::TextureCube: - { - // There are 6 faces to a cubemap - return numMipMaps * arrSize * 6; - } - default: - return 0; - } -} - -/* static */ Result ShaderRendererUtil::generateTextureResource( +/* static */ Result ShaderRendererUtil::generateTexture( const InputTextureDesc& inputDesc, ResourceState defaultState, IDevice* device, - ComPtr& textureOut) + ComPtr& textureOut) { TextureData texData; generateTextureData(texData, inputDesc); - return createTextureResource(inputDesc, texData, defaultState, device, textureOut); + return createTexture(inputDesc, texData, defaultState, device, textureOut); } -/* static */ Result ShaderRendererUtil::createTextureResource( +/* static */ Result ShaderRendererUtil::createTexture( const InputTextureDesc& inputDesc, const TextureData& texData, ResourceState defaultState, IDevice* device, - ComPtr& textureOut) + ComPtr& textureOut) { - ITextureResource::Desc textureResourceDesc = {}; + TextureDesc textureDesc = {}; // Default to R8G8B8A8_UNORM const Format format = (inputDesc.format == Format::Unknown) ? Format::R8G8B8A8_UNORM : inputDesc.format; - textureResourceDesc.sampleDesc = ITextureResource::SampleDesc{inputDesc.sampleCount, 0}; - textureResourceDesc.format = format; - textureResourceDesc.numMipLevels = texData.m_mipLevels; - textureResourceDesc.arraySize = inputDesc.arrayLength; - textureResourceDesc.allowedStates = - ResourceStateSet(defaultState, ResourceState::CopyDestination, ResourceState::CopySource); - textureResourceDesc.defaultState = defaultState; + textureDesc.sampleCount = inputDesc.sampleCount; + textureDesc.format = format; + textureDesc.numMipLevels = texData.m_mipLevels; + textureDesc.arrayLength = inputDesc.arrayLength > 0 ? inputDesc.arrayLength : 1; + textureDesc.usage = TextureUsage::CopyDestination | TextureUsage::CopySource; + switch (defaultState) + { + case ResourceState::ShaderResource: + textureDesc.usage |= TextureUsage::ShaderResource; + break; + case ResourceState::UnorderedAccess: + textureDesc.usage |= TextureUsage::UnorderedAccess; + break; + default: + return SLANG_FAIL; + } + textureDesc.defaultState = defaultState; // It's the same size in all dimensions switch (inputDesc.dimension) { case 1: { - textureResourceDesc.type = IResource::Type::Texture1D; - textureResourceDesc.size.width = inputDesc.size; - textureResourceDesc.size.height = 1; - textureResourceDesc.size.depth = 1; + textureDesc.type = TextureType::Texture1D; + textureDesc.size.width = inputDesc.size; + textureDesc.size.height = 1; + textureDesc.size.depth = 1; break; } case 2: { - textureResourceDesc.type = inputDesc.isCube ? IResource::Type::TextureCube : IResource::Type::Texture2D; - textureResourceDesc.size.width = inputDesc.size; - textureResourceDesc.size.height = inputDesc.size; - textureResourceDesc.size.depth = 1; + textureDesc.type = inputDesc.isCube ? TextureType::TextureCube : TextureType::Texture2D; + textureDesc.size.width = inputDesc.size; + textureDesc.size.height = inputDesc.size; + textureDesc.size.depth = 1; break; } case 3: { - textureResourceDesc.type = IResource::Type::Texture3D; - textureResourceDesc.size.width = inputDesc.size; - textureResourceDesc.size.height = inputDesc.size; - textureResourceDesc.size.depth = inputDesc.size; + textureDesc.type = TextureType::Texture3D; + textureDesc.size.width = inputDesc.size; + textureDesc.size.height = inputDesc.size; + textureDesc.size.depth = inputDesc.size; break; } } - const int effectiveArraySize = calcEffectiveArraySize(textureResourceDesc); - const int numSubResources = calcNumSubResources(textureResourceDesc); + if (textureDesc.numMipLevels == 0) + { + textureDesc.numMipLevels = calcNumMipLevels(textureDesc.type, textureDesc.size); + } - List initSubresources; + List initSubresources; + int arrayLayerCount = textureDesc.arrayLength * (textureDesc.type == TextureType::TextureCube ? 6 : 1); int subResourceCounter = 0; - for( int a = 0; a < effectiveArraySize; ++a ) + for( int a = 0; a < arrayLayerCount; ++a ) { - for( int m = 0; m < textureResourceDesc.numMipLevels; ++m ) + for( int m = 0; m < textureDesc.numMipLevels; ++m ) { int subResourceIndex = subResourceCounter++; - const int mipWidth = calcMipSize(textureResourceDesc.size.width, m); - const int mipHeight = calcMipSize(textureResourceDesc.size.height, m); + const int mipWidth = calcMipSize(textureDesc.size.width, m); + const int mipHeight = calcMipSize(textureDesc.size.height, m); auto strideY = mipWidth * sizeof(uint32_t); auto strideZ = mipHeight * strideY; - ITextureResource::SubresourceData subresourceData; + SubresourceData subresourceData; subresourceData.data = texData.m_slices[subResourceIndex].values; subresourceData.strideY = strideY; subresourceData.strideZ = strideZ; @@ -182,31 +147,26 @@ inline int calcNumSubResources(const ITextureResource::Desc& desc) } } - textureOut = device->createTextureResource(textureResourceDesc, initSubresources.getBuffer()); + textureOut = device->createTexture(textureDesc, initSubresources.getBuffer()); return textureOut ? SLANG_OK : SLANG_FAIL; } -/* static */ Result ShaderRendererUtil::createBufferResource( +/* static */ Result ShaderRendererUtil::createBuffer( const InputBufferDesc& inputDesc, size_t bufferSize, const void* initData, IDevice* device, - Slang::ComPtr& bufferOut) + Slang::ComPtr& bufferOut) { - IBufferResource::Desc srcDesc; - srcDesc.type = IResource::Type::Buffer; - srcDesc.sizeInBytes = bufferSize; - srcDesc.format = inputDesc.format; - srcDesc.elementSize = inputDesc.stride; - srcDesc.defaultState = ResourceState::UnorderedAccess; - srcDesc.allowedStates = ResourceStateSet( - ResourceState::CopyDestination, - ResourceState::CopySource, - ResourceState::UnorderedAccess, - ResourceState::ShaderResource); - - ComPtr bufferResource = device->createBufferResource(srcDesc, initData); + BufferDesc bufferDesc; + bufferDesc.size = bufferSize; + bufferDesc.format = inputDesc.format; + bufferDesc.elementSize = inputDesc.stride; + bufferDesc.usage = BufferUsage::CopyDestination | BufferUsage::CopySource | BufferUsage::ShaderResource | BufferUsage::UnorderedAccess; + bufferDesc.defaultState = ResourceState::UnorderedAccess; + + ComPtr bufferResource = device->createBuffer(bufferDesc, initData); if (!bufferResource) { return SLANG_FAIL; @@ -216,21 +176,21 @@ inline int calcNumSubResources(const ITextureResource::Desc& desc) return SLANG_OK; } -static ISamplerState::Desc _calcSamplerDesc(const InputSamplerDesc& srcDesc) +static SamplerDesc _calcSamplerDesc(const InputSamplerDesc& srcDesc) { - ISamplerState::Desc dstDesc; + SamplerDesc samplerDesc; if (srcDesc.isCompareSampler) { - dstDesc.reductionOp = TextureReductionOp::Comparison; - dstDesc.comparisonFunc = ComparisonFunc::Less; + samplerDesc.reductionOp = TextureReductionOp::Comparison; + samplerDesc.comparisonFunc = ComparisonFunc::Less; } - return dstDesc; + return samplerDesc; } -ComPtr _createSamplerState(IDevice* device, +ComPtr _createSampler(IDevice* device, const InputSamplerDesc& srcDesc) { - return device->createSamplerState(_calcSamplerDesc(srcDesc)); + return device->createSampler(_calcSamplerDesc(srcDesc)); } } // renderer_test diff --git a/tools/render-test/shader-renderer-util.h b/tools/render-test/shader-renderer-util.h index 188562fa8..8d0075f3f 100644 --- a/tools/render-test/shader-renderer-util.h +++ b/tools/render-test/shader-renderer-util.h @@ -8,33 +8,33 @@ namespace renderer_test { using namespace Slang; -ComPtr _createSamplerState(IDevice* device, const InputSamplerDesc& srcDesc); +ComPtr _createSampler(IDevice* device, const InputSamplerDesc& srcDesc); /// Utility class containing functions that construct items on the renderer using the ShaderInputLayout representation struct ShaderRendererUtil { - /// Generate a texture using the InputTextureDesc and construct a TextureResource using the Renderer with the contents - static Slang::Result generateTextureResource( + /// Generate a texture using the InputTextureDesc and construct a Texture using the Renderer with the contents + static Slang::Result generateTexture( const InputTextureDesc& inputDesc, ResourceState defaultState, IDevice* device, - ComPtr& textureOut); + ComPtr& textureOut); /// Create texture resource using inputDesc, and texData to describe format, and contents - static Slang::Result createTextureResource( + static Slang::Result createTexture( const InputTextureDesc& inputDesc, const TextureData& texData, ResourceState defaultState, IDevice* device, - ComPtr& textureOut); + ComPtr& textureOut); /// Create the BufferResource using the renderer from the contents of inputDesc - static Slang::Result createBufferResource( + static Slang::Result createBuffer( const InputBufferDesc& inputDesc, size_t bufferSize, const void* initData, IDevice* device, - ComPtr& bufferOut); + ComPtr& bufferOut); }; } // renderer_test diff --git a/tools/render-test/slang-support.cpp b/tools/render-test/slang-support.cpp index c819aede2..1f174dc72 100644 --- a/tools/render-test/slang-support.cpp +++ b/tools/render-test/slang-support.cpp @@ -23,36 +23,6 @@ static const char rtEntryPointName[] = "raygenMain"; static const char taskEntryPointName[] = "taskMain"; static const char meshEntryPointName[] = "meshMain"; -rhi::StageType translateStage(SlangStage slangStage) -{ - switch(slangStage) - { - default: - SLANG_ASSERT(!"unhandled case"); - return rhi::StageType::Unknown; - -#define CASE(FROM, TO) \ - case SLANG_STAGE_##FROM: return rhi::StageType::TO - - CASE(VERTEX, Vertex); - CASE(HULL, Hull); - CASE(DOMAIN, Domain); - CASE(GEOMETRY, Geometry); - CASE(FRAGMENT, Fragment); - - CASE(COMPUTE, Compute); - - CASE(RAY_GENERATION, RayGeneration); - CASE(INTERSECTION, Intersection); - CASE(ANY_HIT, AnyHit); - CASE(CLOSEST_HIT, ClosestHit); - CASE(MISS, Miss); - CASE(CALLABLE, Callable); - -#undef CASE - } -} - void ShaderCompilerUtil::Output::set( slang::IComponentType* inSlangProgram) { diff --git a/tools/render-test/slang-support.h b/tools/render-test/slang-support.h index e08440377..c93008999 100644 --- a/tools/render-test/slang-support.h +++ b/tools/render-test/slang-support.h @@ -10,8 +10,6 @@ namespace renderer_test { -rhi::StageType translateStage(SlangStage slangStage); - struct ShaderCompileRequest { struct SourceInfo @@ -71,7 +69,7 @@ struct ShaderCompilerUtil } ComPtr slangProgram; - IShaderProgram::Desc desc = {}; + ShaderProgramDesc desc = {}; /// Compile request that owns the lifetime of compiled kernel code. ComPtr m_requestForKernels = nullptr; -- cgit v1.2.3