From 9a5672d7b8a155117a2c3f8375e3b8a5b43d91b7 Mon Sep 17 00:00:00 2001 From: Yong He Date: Sat, 24 Apr 2021 00:17:43 -0700 Subject: Remove resource `Usage` from `gfx` interface. (#1813) * Fix `model-viewer` crash when using Vulkan. Fixing an issue in shader object layout creation for to make sure a correct descriptor set layout is calculated for types that need an implicit constant buffer. * Fix formatting. * Fixes. * Fix memory leak in vulkan. * Remove resource `Usage` from `gfx` interface. --- tools/gfx/d3d12/render-d3d12.cpp | 137 +++++++++++++++------------------------ 1 file changed, 52 insertions(+), 85 deletions(-) (limited to 'tools/gfx/d3d12/render-d3d12.cpp') diff --git a/tools/gfx/d3d12/render-d3d12.cpp b/tools/gfx/d3d12/render-d3d12.cpp index fd1121d1b..a752222d6 100644 --- a/tools/gfx/d3d12/render-d3d12.cpp +++ b/tools/gfx/d3d12/render-d3d12.cpp @@ -63,8 +63,6 @@ struct ID3D12GraphicsCommandList1 {}; namespace gfx { using namespace Slang; -static D3D12_RESOURCE_STATES _calcResourceState(IResource::Usage usage); - class D3D12Device : public RendererBase { public: @@ -81,12 +79,10 @@ public: ISwapchain** outSwapchain) override; virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource( - IResource::Usage initialUsage, const ITextureResource::Desc& desc, const ITextureResource::SubresourceData* initData, ITextureResource** outResource) override; virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource( - IResource::Usage initialUsage, const IBufferResource::Desc& desc, const void* initData, IBufferResource** outResource) override; @@ -189,16 +185,15 @@ public: public: typedef BufferResource Parent; - BufferResourceImpl(IResource::Usage initialUsage, const Desc& desc): - Parent(desc), m_initialUsage(initialUsage) - , m_defaultState(_calcResourceState(initialUsage)) + BufferResourceImpl(const Desc& desc) + : Parent(desc) + , m_defaultState(D3DUtil::translateResourceState(desc.defaultState)) { } D3D12Resource m_resource; ///< The resource typically in gpu memory D3D12Resource m_uploadResource; ///< If the resource can be written to, and is in gpu memory (ie not Memory backed), will have upload resource - Usage m_initialUsage; D3D12_RESOURCE_STATES m_defaultState; }; @@ -207,10 +202,10 @@ public: public: typedef TextureResource Parent; - TextureResourceImpl(const Desc& desc): - Parent(desc) + TextureResourceImpl(const Desc& desc) + : Parent(desc) + , m_defaultState(D3DUtil::translateResourceState(desc.defaultState)) { - m_defaultState = _calcResourceState(desc.initialUsage); } D3D12Resource m_resource; @@ -528,10 +523,13 @@ public: { ComPtr bufferResourcePtr; IBufferResource::Desc bufferDesc; - bufferDesc.init(desc.constantBufferSize); + bufferDesc.type = IResource::Type::Buffer; + bufferDesc.defaultState = ResourceState::ConstantBuffer; + bufferDesc.allowedStates = + ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination); + bufferDesc.sizeInBytes = desc.constantBufferSize; bufferDesc.cpuAccessFlags |= IResource::AccessFlag::Write; SLANG_RETURN_ON_FAIL(device->createBufferResource( - IResource::Usage::ConstantBuffer, bufferDesc, nullptr, bufferResourcePtr.writeRef())); @@ -2796,10 +2794,6 @@ public: for (UInt i = 0; i < slotCount; i++) { BufferResourceImpl* buffer = static_cast(buffers[i]); - if (buffer) - { - assert(buffer->m_initialUsage == IResource::Usage::VertexBuffer); - } BoundVertexBuffer& boundBuffer = m_boundVertexBuffers[startSlot + i]; boundBuffer.m_buffer = buffer; @@ -3210,9 +3204,18 @@ public: ComPtr d3dResource; m_swapChain->GetBuffer(i, IID_PPV_ARGS(d3dResource.writeRef())); ITextureResource::Desc imageDesc = {}; - imageDesc.setDefaults(IResource::Usage::RenderTarget); - imageDesc.init2D( - IResource::Type::Texture2D, m_desc.format, m_desc.width, m_desc.height, 0); + imageDesc.allowedStates = ResourceStateSet( + ResourceState::Present, + ResourceState::RenderTarget, + ResourceState::CopyDestination); + imageDesc.type = IResource::Type::Texture2D; + imageDesc.arraySize = 0; + imageDesc.format = m_desc.format; + imageDesc.size.width = m_desc.width; + imageDesc.size.height = m_desc.height; + imageDesc.size.depth = 1; + imageDesc.numMipLevels = 1; + imageDesc.defaultState = ResourceState::Present; RefPtr image = new TextureResourceImpl(imageDesc); image->m_resource.setResource(d3dResource.get()); image->m_defaultState = D3D12_RESOURCE_STATE_PRESENT; @@ -4033,53 +4036,32 @@ SlangResult D3D12Device::readTextureResource( outPixelSize); } -static D3D12_RESOURCE_STATES _calcResourceState(IResource::Usage usage) +static D3D12_RESOURCE_FLAGS _calcResourceFlag(ResourceState state) { - typedef IResource::Usage Usage; - switch (usage) + switch (state) { - case Usage::VertexBuffer: return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER; - case Usage::IndexBuffer: return D3D12_RESOURCE_STATE_INDEX_BUFFER; - case Usage::ConstantBuffer: return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER; - case Usage::StreamOutput: return D3D12_RESOURCE_STATE_STREAM_OUT; - case Usage::RenderTarget: return D3D12_RESOURCE_STATE_RENDER_TARGET; - case Usage::DepthWrite: return D3D12_RESOURCE_STATE_DEPTH_WRITE; - case Usage::DepthRead: return D3D12_RESOURCE_STATE_DEPTH_READ; - case Usage::UnorderedAccess: return D3D12_RESOURCE_STATE_UNORDERED_ACCESS; - case Usage::PixelShaderResource: return D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; - case Usage::NonPixelShaderResource: return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; - case Usage::ShaderResource: return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE | - D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; - case Usage::GenericRead: return D3D12_RESOURCE_STATE_GENERIC_READ; - case Usage::CopySource: return D3D12_RESOURCE_STATE_COPY_SOURCE; - case Usage::CopyDest: return D3D12_RESOURCE_STATE_COPY_DEST; - default: return D3D12_RESOURCE_STATES(0); - } -} - -static D3D12_RESOURCE_FLAGS _calcResourceFlag(IResource::BindFlag::Enum bindFlag) -{ - typedef IResource::BindFlag BindFlag; - switch (bindFlag) - { - case BindFlag::RenderTarget: return D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; - case BindFlag::DepthStencil: return D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; - case BindFlag::UnorderedAccess: return D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; - default: return D3D12_RESOURCE_FLAG_NONE; + case ResourceState::RenderTarget: + return D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; + case ResourceState::DepthRead: + case ResourceState::DepthWrite: + return D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; + case ResourceState::UnorderedAccess: + return D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; + default: + return D3D12_RESOURCE_FLAG_NONE; } } -static D3D12_RESOURCE_FLAGS _calcResourceBindFlags(IResource::Usage initialUsage, int bindFlags) +static D3D12_RESOURCE_FLAGS _calcResourceFlags(ResourceStateSet states) { int dstFlags = 0; - while (bindFlags) + for (uint32_t i = 0; i < (uint32_t)ResourceState::_Count; i++) { - int lsb = bindFlags & -bindFlags; - - dstFlags |= _calcResourceFlag(IResource::BindFlag::Enum(lsb)); - bindFlags &= ~lsb; + auto state = (ResourceState)i; + if (states.contains(state)) + dstFlags |= _calcResourceFlag(state); } - return D3D12_RESOURCE_FLAGS(dstFlags); + return (D3D12_RESOURCE_FLAGS)dstFlags; } static D3D12_RESOURCE_DIMENSION _calcResourceDimension(IResource::Type type) @@ -4098,13 +4080,12 @@ static D3D12_RESOURCE_DIMENSION _calcResourceDimension(IResource::Type type) } } -Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource) +Result D3D12Device::createTextureResource(const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource) { // Description of uploading on Dx12 // https://msdn.microsoft.com/en-us/library/windows/desktop/dn899215%28v=vs.85%29.aspx - TextureResource::Desc srcDesc(descIn); - srcDesc.setDefaults(initialUsage); + TextureResource::Desc srcDesc = fixupTextureDesc(descIn); const DXGI_FORMAT pixelFormat = D3DUtil::getMapFormat(srcDesc.format); if (pixelFormat == DXGI_FORMAT_UNKNOWN) @@ -4112,7 +4093,7 @@ Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const I return SLANG_FAIL; } - const int arraySize = srcDesc.calcEffectiveArraySize(); + const int arraySize = calcEffectiveArraySize(srcDesc); const D3D12_RESOURCE_DIMENSION dimension = _calcResourceDimension(srcDesc.type); if (dimension == D3D12_RESOURCE_DIMENSION_UNKNOWN) @@ -4138,20 +4119,7 @@ Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const I resourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE; resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; - switch (initialUsage) - { - case IResource::Usage::RenderTarget: - resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; - break; - case IResource::Usage::DepthWrite: - resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; - break; - case IResource::Usage::UnorderedAccess: - resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; - break; - default: - break; - } + resourceDesc.Flags |= _calcResourceFlags(srcDesc.allowedStates); resourceDesc.Alignment = 0; @@ -4251,7 +4219,7 @@ Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const I const D3D12_PLACED_SUBRESOURCE_FOOTPRINT& layout = layouts[j]; const D3D12_SUBRESOURCE_FOOTPRINT& footprint = layout.Footprint; - const TextureResource::Size mipSize = srcDesc.size.calcMipSize(j); + const TextureResource::Size mipSize = calcMipSize(srcDesc.size, j); assert(footprint.Width == mipSize.width && footprint.Height == mipSize.height && footprint.Depth == mipSize.depth); @@ -4314,10 +4282,10 @@ Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const I } { auto encodeInfo = encodeResourceCommands(); - const D3D12_RESOURCE_STATES finalState = _calcResourceState(initialUsage); { D3D12BarrierSubmitter submitter(encodeInfo.d3dCommandList); - texture->m_resource.transition(D3D12_RESOURCE_STATE_COPY_DEST, finalState, submitter); + texture->m_resource.transition( + D3D12_RESOURCE_STATE_COPY_DEST, texture->m_defaultState, submitter); } submitResourceCommandsAndWait(encodeInfo); } @@ -4326,10 +4294,9 @@ Result D3D12Device::createTextureResource(IResource::Usage initialUsage, const I return SLANG_OK; } -Result D3D12Device::createBufferResource(IResource::Usage initialUsage, const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource) +Result D3D12Device::createBufferResource(const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource) { - BufferResource::Desc srcDesc(descIn); - srcDesc.setDefaults(initialUsage); + BufferResource::Desc srcDesc = fixupBufferDesc(descIn); // Always align up to 256 bytes, since that is required for constant buffers. // @@ -4337,14 +4304,14 @@ Result D3D12Device::createBufferResource(IResource::Usage initialUsage, const IB // const size_t alignedSizeInBytes = D3DUtil::calcAligned(srcDesc.sizeInBytes, 256); - RefPtr buffer(new BufferResourceImpl(initialUsage, srcDesc)); + RefPtr buffer(new BufferResourceImpl(srcDesc)); D3D12_RESOURCE_DESC bufferDesc; _initBufferResourceDesc(alignedSizeInBytes, bufferDesc); - bufferDesc.Flags = _calcResourceBindFlags(initialUsage, srcDesc.bindFlags); + bufferDesc.Flags |= _calcResourceFlags(srcDesc.allowedStates); - const D3D12_RESOURCE_STATES initialState = _calcResourceState(initialUsage); + const D3D12_RESOURCE_STATES initialState = buffer->m_defaultState; SLANG_RETURN_ON_FAIL(createBuffer(bufferDesc, initData, srcDesc.sizeInBytes, buffer->m_uploadResource, initialState, buffer->m_resource)); returnComPtr(outResource, buffer); -- cgit v1.2.3