From 3bba4e41b9b40bffa3217e6a559906ff2a15471b Mon Sep 17 00:00:00 2001 From: turanszkij Date: Sun, 22 Sep 2019 15:53:58 +0100 Subject: [PATCH] start subresource refactor --- Editor/ModelImporter_GLTF.cpp | 15 +- WickedEngine/RenderPath3D.cpp | 33 +- WickedEngine/wiGraphicsDescriptors.h | 7 + WickedEngine/wiGraphicsDevice.h | 2 + WickedEngine/wiGraphicsDevice_DX11.cpp | 942 +++++------------------ WickedEngine/wiGraphicsDevice_DX11.h | 9 +- WickedEngine/wiGraphicsDevice_DX12.cpp | 561 ++------------ WickedEngine/wiGraphicsDevice_DX12.h | 1 + WickedEngine/wiGraphicsDevice_Vulkan.cpp | 486 +++--------- WickedEngine/wiGraphicsDevice_Vulkan.h | 1 + WickedEngine/wiGraphicsResource.cpp | 21 - WickedEngine/wiGraphicsResource.h | 28 +- WickedEngine/wiOcean.cpp | 15 +- WickedEngine/wiRenderer.cpp | 90 ++- WickedEngine/wiResourceManager.cpp | 17 +- WickedEngine/wiVersion.cpp | 2 +- 16 files changed, 509 insertions(+), 1721 deletions(-) diff --git a/Editor/ModelImporter_GLTF.cpp b/Editor/ModelImporter_GLTF.cpp index 99cb4436d..6dfe6149f 100644 --- a/Editor/ModelImporter_GLTF.cpp +++ b/Editor/ModelImporter_GLTF.cpp @@ -102,6 +102,8 @@ void RegisterTexture2D(tinygltf::Image *image, const string& type_name) if (!image->image.empty()) { + GraphicsDevice* device = wiRenderer::GetDevice(); + TextureDesc desc; desc.ArraySize = 1; desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; @@ -123,11 +125,18 @@ void RegisterTexture2D(tinygltf::Image *image, const string& type_name) } Texture2D* tex = new Texture2D; - tex->RequestIndependentShaderResourcesForMIPs(true); - tex->RequestIndependentUnorderedAccessResourcesForMIPs(true); - HRESULT hr = wiRenderer::GetDevice()->CreateTexture2D(&desc, InitData.data(), tex); + HRESULT hr = device->CreateTexture2D(&desc, InitData.data(), tex); assert(SUCCEEDED(hr)); + for (UINT i = 0; i < tex->GetDesc().MipLevels; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(tex, SRV, 0, 1, i, 1); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(tex, SRV, 0, 1, i, 1); + assert(subresource_index == i); + } + if (tex != nullptr) { wiRenderer::AddDeferredMIPGen(tex); diff --git a/WickedEngine/RenderPath3D.cpp b/WickedEngine/RenderPath3D.cpp index 8f4102a55..996c735b2 100644 --- a/WickedEngine/RenderPath3D.cpp +++ b/WickedEngine/RenderPath3D.cpp @@ -26,10 +26,17 @@ void RenderPath3D::ResizeBuffers() desc.Width = wiRenderer::GetInternalResolution().x / 2; desc.Height = wiRenderer::GetInternalResolution().y / 2; desc.MipLevels = 5; - rtSSR.RequestIndependentUnorderedAccessResourcesForMIPs(true); - rtSSR.RequestIndependentShaderResourcesForMIPs(true); device->CreateTexture2D(&desc, nullptr, &rtSSR); device->SetName(&rtSSR, "rtSSR"); + + for (UINT i = 0; i < rtSSR.GetDesc().MipLevels; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(&rtSSR, SRV, 0, 1, i, 1); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(&rtSSR, SRV, 0, 1, i, 1); + assert(subresource_index == i); + } } { TextureDesc desc; @@ -65,10 +72,17 @@ void RenderPath3D::ResizeBuffers() desc.Width = wiRenderer::GetInternalResolution().x; desc.Height = wiRenderer::GetInternalResolution().y; desc.MipLevels = 8; - rtSceneCopy.RequestIndependentShaderResourcesForMIPs(true); - rtSceneCopy.RequestIndependentUnorderedAccessResourcesForMIPs(true); device->CreateTexture2D(&desc, nullptr, &rtSceneCopy); device->SetName(&rtSceneCopy, "rtSceneCopy"); + + for (UINT i = 0; i < rtSceneCopy.GetDesc().MipLevels; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(&rtSceneCopy, SRV, 0, 1, i, 1); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(&rtSceneCopy, SRV, 0, 1, i, 1); + assert(subresource_index == i); + } } { TextureDesc desc; @@ -134,10 +148,17 @@ void RenderPath3D::ResizeBuffers() desc.Width = wiRenderer::GetInternalResolution().x / 4; desc.Height = wiRenderer::GetInternalResolution().y / 4; desc.MipLevels = 5; - rtBloom.RequestIndependentShaderResourcesForMIPs(true); - rtBloom.RequestIndependentUnorderedAccessResourcesForMIPs(true); device->CreateTexture2D(&desc, nullptr, &rtBloom); device->SetName(&rtBloom, "rtBloom"); + + for (UINT i = 0; i < rtBloom.GetDesc().MipLevels; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(&rtBloom, SRV, 0, 1, i, 1); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(&rtBloom, SRV, 0, 1, i, 1); + assert(subresource_index == i); + } } { TextureDesc desc; diff --git a/WickedEngine/wiGraphicsDescriptors.h b/WickedEngine/wiGraphicsDescriptors.h index 04214ebad..5b65c96c6 100644 --- a/WickedEngine/wiGraphicsDescriptors.h +++ b/WickedEngine/wiGraphicsDescriptors.h @@ -262,6 +262,13 @@ namespace wiGraphics INDEXFORMAT_16BIT, INDEXFORMAT_32BIT, }; + enum SUBRESOURCE_TYPE + { + SRV, + UAV, + RTV, + DSV, + }; // Flags //////////////////////////////////////////// enum CLEAR_FLAG diff --git a/WickedEngine/wiGraphicsDevice.h b/WickedEngine/wiGraphicsDevice.h index 20e7c10f9..9c9c681f2 100644 --- a/WickedEngine/wiGraphicsDevice.h +++ b/WickedEngine/wiGraphicsDevice.h @@ -49,6 +49,8 @@ namespace wiGraphics virtual HRESULT CreateQuery(const GPUQueryDesc *pDesc, GPUQuery *pQuery) = 0; virtual HRESULT CreatePipelineState(const PipelineStateDesc* pDesc, PipelineState* pso) = 0; + virtual int CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, UINT firstSlice, UINT sliceCount = 1, UINT firstMip = 0, UINT mipCount = 0) = 0; + virtual void DestroyResource(GPUResource* pResource) = 0; virtual void DestroyBuffer(GPUBuffer *pBuffer) = 0; diff --git a/WickedEngine/wiGraphicsDevice_DX11.cpp b/WickedEngine/wiGraphicsDevice_DX11.cpp index 57d86772e..dd45715da 100644 --- a/WickedEngine/wiGraphicsDevice_DX11.cpp +++ b/WickedEngine/wiGraphicsDevice_DX11.cpp @@ -1411,11 +1411,11 @@ HRESULT GraphicsDevice_DX11::CreateTexture1D(const TextureDesc* pDesc, const Sub } } - HRESULT hr = S_OK; + HRESULT hr; hr = device->CreateTexture1D(&desc, data, (ID3D11Texture1D**)&(pTexture1D->resource)); SAFE_DELETE_ARRAY(data); - assert(SUCCEEDED(hr) && "Texture1D creation failed!"); + assert(SUCCEEDED(hr)); if (FAILED(hr)) return hr; @@ -1424,20 +1424,15 @@ HRESULT GraphicsDevice_DX11::CreateTexture1D(const TextureDesc* pDesc, const Sub pTexture1D->desc.MipLevels = (UINT)log2(pTexture1D->desc.Width); } - CreateShaderResourceView(pTexture1D); - + if (pTexture1D->desc.BindFlags & BIND_SHADER_RESOURCE) + { + hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture1D->resource, nullptr, (ID3D11ShaderResourceView**)&pTexture1D->SRV); + assert(SUCCEEDED(hr)); + } if (desc.BindFlags & D3D11_BIND_UNORDERED_ACCESS) { - assert(pTexture1D->independentRTVArraySlices == false && "TextureArray UAV not implemented!"); - - D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc; - ZeroMemory(&uav_desc, sizeof(uav_desc)); - uav_desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE1D; - uav_desc.Texture2D.MipSlice = 0; - - hr = device->CreateUnorderedAccessView((ID3D11Resource*)pTexture1D->resource, &uav_desc, (ID3D11UnorderedAccessView**)&pTexture1D->UAV); - - assert(SUCCEEDED(hr) && "UnorderedAccessView of the Texture1D could not be created!"); + hr = device->CreateUnorderedAccessView((ID3D11Resource*)pTexture1D->resource, nullptr, (ID3D11UnorderedAccessView**)&pTexture1D->UAV); + assert(SUCCEEDED(hr)); } return hr; @@ -1465,11 +1460,11 @@ HRESULT GraphicsDevice_DX11::CreateTexture2D(const TextureDesc* pDesc, const Sub D3D11_TEXTURE2D_DESC desc = _ConvertTextureDesc2D(&pTexture2D->desc); - D3D11_SUBRESOURCE_DATA* data = nullptr; + std::vector data; if (pInitialData != nullptr) { UINT dataCount = pDesc->ArraySize * std::max(1u, pDesc->MipLevels); - data = new D3D11_SUBRESOURCE_DATA[dataCount]; + data.resize(dataCount); for (UINT slice = 0; slice < dataCount; ++slice) { data[slice] = _ConvertSubresourceData(pInitialData[slice]); @@ -1478,9 +1473,8 @@ HRESULT GraphicsDevice_DX11::CreateTexture2D(const TextureDesc* pDesc, const Sub HRESULT hr = S_OK; - hr = device->CreateTexture2D(&desc, data, (ID3D11Texture2D**)&(pTexture2D->resource)); - assert(SUCCEEDED(hr) && "Texture2D creation failed!"); - SAFE_DELETE_ARRAY(data); + hr = device->CreateTexture2D(&desc, data.data(), (ID3D11Texture2D**)&(pTexture2D->resource)); + assert(SUCCEEDED(hr)); if (FAILED(hr)) return hr; @@ -1489,71 +1483,25 @@ HRESULT GraphicsDevice_DX11::CreateTexture2D(const TextureDesc* pDesc, const Sub pTexture2D->desc.MipLevels = (UINT)log2(std::max(pTexture2D->desc.Width, pTexture2D->desc.Height)); } - CreateRenderTargetView(pTexture2D); - CreateShaderResourceView(pTexture2D); - CreateDepthStencilView(pTexture2D); - - + if (desc.BindFlags & D3D11_BIND_RENDER_TARGET) + { + hr = device->CreateRenderTargetView((ID3D11Resource*)pTexture2D->resource, nullptr, (ID3D11RenderTargetView**)&pTexture2D->RTV); + assert(SUCCEEDED(hr)); + } + if (desc.BindFlags & D3D11_BIND_DEPTH_STENCIL) + { + hr = device->CreateDepthStencilView((ID3D11Resource*)pTexture2D->resource, nullptr, (ID3D11DepthStencilView**)&pTexture2D->DSV); + assert(SUCCEEDED(hr)); + } + if (desc.BindFlags & D3D11_BIND_SHADER_RESOURCE) + { + hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture2D->resource, nullptr, (ID3D11ShaderResourceView**)&pTexture2D->SRV); + assert(SUCCEEDED(hr)); + } if (desc.BindFlags & D3D11_BIND_UNORDERED_ACCESS) { - - if (desc.ArraySize > 1) - { - D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc; - ZeroMemory(&uav_desc, sizeof(uav_desc)); - uav_desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2DARRAY; - uav_desc.Texture2DArray.FirstArraySlice = 0; - uav_desc.Texture2DArray.ArraySize = desc.ArraySize; - uav_desc.Texture2DArray.MipSlice = 0; - - if (pTexture2D->independentUAVMIPs) - { - // Create subresource UAVs: - UINT miplevels = pTexture2D->desc.MipLevels; - for (UINT i = 0; i < miplevels; ++i) - { - uav_desc.Texture2DArray.MipSlice = i; - - pTexture2D->additionalUAVs.push_back(WI_NULL_HANDLE); - hr = device->CreateUnorderedAccessView((ID3D11Resource*)pTexture2D->resource, &uav_desc, (ID3D11UnorderedAccessView**)&pTexture2D->additionalUAVs[i]); - assert(SUCCEEDED(hr) && "UnorderedAccessView of the Texture2D could not be created!"); - } - } - - { - // Create main resource UAV: - uav_desc.Texture2DArray.MipSlice = 0; - hr = device->CreateUnorderedAccessView((ID3D11Resource*)pTexture2D->resource, &uav_desc, (ID3D11UnorderedAccessView**)&pTexture2D->UAV); - } - } - else - { - D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc; - ZeroMemory(&uav_desc, sizeof(uav_desc)); - uav_desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D; - - if (pTexture2D->independentUAVMIPs) - { - // Create subresource UAVs: - UINT miplevels = pTexture2D->desc.MipLevels; - for (UINT i = 0; i < miplevels; ++i) - { - uav_desc.Texture2D.MipSlice = i; - - pTexture2D->additionalUAVs.push_back(WI_NULL_HANDLE); - hr = device->CreateUnorderedAccessView((ID3D11Resource*)pTexture2D->resource, &uav_desc, (ID3D11UnorderedAccessView**)&pTexture2D->additionalUAVs[i]); - assert(SUCCEEDED(hr) && "UnorderedAccessView of the Texture2D could not be created!"); - } - } - - { - // Create main resource UAV: - uav_desc.Texture2D.MipSlice = 0; - hr = device->CreateUnorderedAccessView((ID3D11Resource*)pTexture2D->resource, &uav_desc, (ID3D11UnorderedAccessView**)&pTexture2D->UAV); - } - } - - assert(SUCCEEDED(hr) && "UnorderedAccessView of the Texture2D could not be created!"); + hr = device->CreateUnorderedAccessView((ID3D11Resource*)pTexture2D->resource, nullptr, (ID3D11UnorderedAccessView**)&pTexture2D->UAV); + assert(SUCCEEDED(hr)); } return hr; @@ -1569,21 +1517,19 @@ HRESULT GraphicsDevice_DX11::CreateTexture3D(const TextureDesc* pDesc, const Sub D3D11_TEXTURE3D_DESC desc = _ConvertTextureDesc3D(&pTexture3D->desc); - D3D11_SUBRESOURCE_DATA* data = nullptr; + D3D11_SUBRESOURCE_DATA data; if (pInitialData != nullptr) { - data = new D3D11_SUBRESOURCE_DATA[1]; for (UINT slice = 0; slice < 1; ++slice) { - data[slice] = _ConvertSubresourceData(pInitialData[slice]); + data = _ConvertSubresourceData(pInitialData[slice]); } } HRESULT hr = S_OK; - hr = device->CreateTexture3D(&desc, data, (ID3D11Texture3D**)&(pTexture3D->resource)); - SAFE_DELETE_ARRAY(data); - assert(SUCCEEDED(hr) && "Texture3D creation failed!"); + hr = device->CreateTexture3D(&desc, &data, (ID3D11Texture3D**)&(pTexture3D->resource)); + assert(SUCCEEDED(hr)); if (FAILED(hr)) return hr; @@ -1592,652 +1538,21 @@ HRESULT GraphicsDevice_DX11::CreateTexture3D(const TextureDesc* pDesc, const Sub pTexture3D->desc.MipLevels = (UINT)log2(std::max(pTexture3D->desc.Width, std::max(pTexture3D->desc.Height, pTexture3D->desc.Depth))); } - CreateShaderResourceView(pTexture3D); - CreateRenderTargetView(pTexture3D); - + if (desc.BindFlags & D3D11_BIND_RENDER_TARGET) + { + hr = device->CreateRenderTargetView((ID3D11Resource*)pTexture3D->resource, nullptr, (ID3D11RenderTargetView**)&pTexture3D->RTV); + assert(SUCCEEDED(hr)); + } + if (desc.BindFlags & D3D11_BIND_SHADER_RESOURCE) + { + hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture3D->resource, nullptr, (ID3D11ShaderResourceView**)&pTexture3D->SRV); + assert(SUCCEEDED(hr)); + } if (desc.BindFlags & D3D11_BIND_UNORDERED_ACCESS) { - D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc; - ZeroMemory(&uav_desc, sizeof(uav_desc)); - uav_desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D; - uav_desc.Texture3D.FirstWSlice = 0; - - if (pTexture3D->independentUAVMIPs) - { - // Create subresource UAVs: - UINT miplevels = pTexture3D->desc.MipLevels; - uav_desc.Texture3D.WSize = desc.Depth; - for (UINT i = 0; i < miplevels; ++i) - { - uav_desc.Texture3D.MipSlice = i; - - pTexture3D->additionalUAVs.push_back(WI_NULL_HANDLE); - hr = device->CreateUnorderedAccessView((ID3D11Resource*)pTexture3D->resource, &uav_desc, (ID3D11UnorderedAccessView**)&pTexture3D->additionalUAVs[i]); - assert(SUCCEEDED(hr) && "UnorderedAccessView of the Texture3D could not be created!"); - - uav_desc.Texture3D.WSize /= 2; - } - } - - { - // Create main resource UAV: - uav_desc.Texture3D.MipSlice = 0; - uav_desc.Texture3D.WSize = desc.Depth; - hr = device->CreateUnorderedAccessView((ID3D11Resource*)pTexture3D->resource, &uav_desc, (ID3D11UnorderedAccessView**)&pTexture3D->UAV); - assert(SUCCEEDED(hr) && "UnorderedAccessView of the Texture3D could not be created!"); - } - } - - return hr; -} -HRESULT GraphicsDevice_DX11::CreateShaderResourceView(Texture1D* pTexture) -{ - if (pTexture->SRV != WI_NULL_HANDLE) - { - return E_FAIL; - } - - HRESULT hr = E_FAIL; - if (pTexture->desc.BindFlags & BIND_SHADER_RESOURCE) - { - UINT arraySize = pTexture->desc.ArraySize; - - D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc; - ZeroMemory(&shaderResourceViewDesc, sizeof(shaderResourceViewDesc)); - shaderResourceViewDesc.Format = _ConvertFormat(pTexture->desc.Format); - - if (arraySize > 1) - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY; - shaderResourceViewDesc.Texture1DArray.FirstArraySlice = 0; - shaderResourceViewDesc.Texture1DArray.ArraySize = arraySize; - shaderResourceViewDesc.Texture1DArray.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.Texture1DArray.MipLevels = -1; //...to least detailed - } - else - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D; - shaderResourceViewDesc.Texture1D.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.Texture1D.MipLevels = -1; //...to least detailed - } - - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->SRV); - - assert(SUCCEEDED(hr) && "ShaderResourceView Creation failed!"); - } - - return hr; -} -HRESULT GraphicsDevice_DX11::CreateShaderResourceView(Texture2D* pTexture) -{ - if (pTexture->SRV != WI_NULL_HANDLE) - { - return E_FAIL; - } - - HRESULT hr = E_FAIL; - if (pTexture->desc.BindFlags & BIND_SHADER_RESOURCE) - { - UINT arraySize = pTexture->desc.ArraySize; - UINT sampleCount = pTexture->desc.SampleDesc.Count; - bool multisampled = sampleCount > 1; - - D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc; - ZeroMemory(&shaderResourceViewDesc, sizeof(shaderResourceViewDesc)); - // Try to resolve shader resource format: - switch (pTexture->desc.Format) - { - case FORMAT_R16_TYPELESS: - shaderResourceViewDesc.Format = DXGI_FORMAT_R16_UNORM; - break; - case FORMAT_R32_TYPELESS: - shaderResourceViewDesc.Format = DXGI_FORMAT_R32_FLOAT; - break; - case FORMAT_R24G8_TYPELESS: - shaderResourceViewDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; - break; - case FORMAT_R32G8X24_TYPELESS: - shaderResourceViewDesc.Format = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS; - break; - default: - shaderResourceViewDesc.Format = _ConvertFormat(pTexture->desc.Format); - break; - } - - if (arraySize > 1) - { - if (pTexture->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - if (arraySize > 6) - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY; - shaderResourceViewDesc.TextureCubeArray.First2DArrayFace = 0; - shaderResourceViewDesc.TextureCubeArray.NumCubes = arraySize / 6; - shaderResourceViewDesc.TextureCubeArray.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.TextureCubeArray.MipLevels = -1; //...to least detailed - } - else - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; - shaderResourceViewDesc.TextureCube.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.TextureCube.MipLevels = -1; //...to least detailed - } - } - else - { - if (multisampled) - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY; - shaderResourceViewDesc.Texture2DMSArray.FirstArraySlice = 0; - shaderResourceViewDesc.Texture2DMSArray.ArraySize = arraySize; - } - else - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; - shaderResourceViewDesc.Texture2DArray.FirstArraySlice = 0; - shaderResourceViewDesc.Texture2DArray.ArraySize = arraySize; - shaderResourceViewDesc.Texture2DArray.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.Texture2DArray.MipLevels = -1; //...to least detailed - } - } - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->SRV); - assert(SUCCEEDED(hr) && "ShaderResourceView Creation failed!"); - - - if (pTexture->independentSRVMIPs) - { - if (pTexture->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - // independent MIPs - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY; - shaderResourceViewDesc.TextureCubeArray.First2DArrayFace = 0; - shaderResourceViewDesc.TextureCubeArray.NumCubes = arraySize / 6; - - for (UINT j = 0; j < pTexture->desc.MipLevels; ++j) - { - shaderResourceViewDesc.TextureCubeArray.MostDetailedMip = j; - shaderResourceViewDesc.TextureCubeArray.MipLevels = 1; - - pTexture->additionalSRVs.push_back(WI_NULL_HANDLE); - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->additionalSRVs.back()); - assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); - } - } - else - { - UINT slices = arraySize; - - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; - shaderResourceViewDesc.Texture2DArray.FirstArraySlice = 0; - shaderResourceViewDesc.Texture2DArray.ArraySize = pTexture->desc.ArraySize; - - for (UINT j = 0; j < pTexture->desc.MipLevels; ++j) - { - shaderResourceViewDesc.Texture2DArray.MostDetailedMip = j; - shaderResourceViewDesc.Texture2DArray.MipLevels = 1; - - pTexture->additionalSRVs.push_back(WI_NULL_HANDLE); - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->additionalSRVs.back()); - assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); - } - } - } - - if (pTexture->independentSRVArraySlices) - { - if (pTexture->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - UINT slices = arraySize / 6; - - // independent cubemaps - for (UINT i = 0; i < slices; ++i) - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY; - shaderResourceViewDesc.TextureCubeArray.First2DArrayFace = i * 6; - shaderResourceViewDesc.TextureCubeArray.NumCubes = 1; - shaderResourceViewDesc.TextureCubeArray.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.TextureCubeArray.MipLevels = -1; //...to least detailed - - pTexture->additionalSRVs.push_back(WI_NULL_HANDLE); - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->additionalSRVs.back()); - assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); - } - } - else - { - UINT slices = arraySize; - - // independent slices - for (UINT i = 0; i < slices; ++i) - { - if (multisampled) - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY; - shaderResourceViewDesc.Texture2DMSArray.FirstArraySlice = i; - shaderResourceViewDesc.Texture2DMSArray.ArraySize = 1; - } - else - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; - shaderResourceViewDesc.Texture2DArray.FirstArraySlice = i; - shaderResourceViewDesc.Texture2DArray.ArraySize = 1; - shaderResourceViewDesc.Texture2DArray.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.Texture2DArray.MipLevels = -1; //...to least detailed - } - - pTexture->additionalSRVs.push_back(WI_NULL_HANDLE); - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->additionalSRVs.back()); - assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); - } - } - - } - - } - else - { - if (multisampled) - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS; - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->SRV); - assert(SUCCEEDED(hr) && "ShaderResourceView Creation failed!"); - } - else - { - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; - - if (pTexture->independentSRVMIPs) - { - // Create subresource SRVs: - UINT miplevels = pTexture->desc.MipLevels; - for (UINT i = 0; i < miplevels; ++i) - { - shaderResourceViewDesc.Texture2D.MostDetailedMip = i; - shaderResourceViewDesc.Texture2D.MipLevels = 1; - - pTexture->additionalSRVs.push_back(WI_NULL_HANDLE); - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->additionalSRVs.back()); - assert(SUCCEEDED(hr) && "ShaderResourceView Creation failed!"); - } - } - - { - // Create full-resource SRV: - shaderResourceViewDesc.Texture2D.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.Texture2D.MipLevels = -1; //...to least detailed - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->SRV); - assert(SUCCEEDED(hr) && "ShaderResourceView Creation failed!"); - } - } - } - } - - return hr; -} -HRESULT GraphicsDevice_DX11::CreateShaderResourceView(Texture3D* pTexture) -{ - if (pTexture->SRV != WI_NULL_HANDLE) - { - return E_FAIL; - } - - HRESULT hr = E_FAIL; - if (pTexture->desc.BindFlags & BIND_SHADER_RESOURCE) - { - - D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc; - ZeroMemory(&shaderResourceViewDesc, sizeof(shaderResourceViewDesc)); - shaderResourceViewDesc.Format = _ConvertFormat(pTexture->desc.Format); - shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; - - if (pTexture->independentSRVMIPs) - { - // Create subresource SRVs: - UINT miplevels = pTexture->desc.MipLevels; - for (UINT i = 0; i < miplevels; ++i) - { - shaderResourceViewDesc.Texture3D.MostDetailedMip = i; - shaderResourceViewDesc.Texture3D.MipLevels = 1; - - pTexture->additionalSRVs.push_back(WI_NULL_HANDLE); - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->additionalSRVs[i]); - assert(SUCCEEDED(hr) && "ShaderResourceView Creation failed!"); - } - } - - { - // Create full-resource SRV: - shaderResourceViewDesc.Texture3D.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.Texture3D.MipLevels = -1; //...to least detailed - - hr = device->CreateShaderResourceView((ID3D11Resource*)pTexture->resource, &shaderResourceViewDesc, (ID3D11ShaderResourceView**)&pTexture->SRV); - assert(SUCCEEDED(hr) && "ShaderResourceView Creation failed!"); - } - - } - - return hr; -} -HRESULT GraphicsDevice_DX11::CreateRenderTargetView(Texture2D* pTexture) -{ - if (!pTexture->additionalRTVs.empty()) - { - return E_FAIL; - } - - HRESULT hr = E_FAIL; - if (pTexture->desc.BindFlags & BIND_RENDER_TARGET) - { - UINT arraySize = pTexture->desc.ArraySize; - UINT sampleCount = pTexture->desc.SampleDesc.Count; - bool multisampled = sampleCount > 1; - - D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc; - ZeroMemory(&renderTargetViewDesc, sizeof(renderTargetViewDesc)); - renderTargetViewDesc.Format = _ConvertFormat(pTexture->desc.Format); - renderTargetViewDesc.Texture2DArray.MipSlice = 0; - - if (pTexture->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - // TextureCube, TextureCubeArray... - UINT slices = arraySize / 6; - - renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; - renderTargetViewDesc.Texture2DArray.MipSlice = 0; - - if (pTexture->independentRTVCubemapFaces) - { - // independent faces - for (UINT i = 0; i < arraySize; ++i) - { - renderTargetViewDesc.Texture2DArray.FirstArraySlice = i; - renderTargetViewDesc.Texture2DArray.ArraySize = 1; - - pTexture->additionalRTVs.push_back(WI_NULL_HANDLE); - hr = device->CreateRenderTargetView((ID3D11Resource*)pTexture->resource, &renderTargetViewDesc, (ID3D11RenderTargetView**)&pTexture->additionalRTVs[i]); - assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); - } - } - else if (pTexture->independentRTVArraySlices) - { - // independent slices - for (UINT i = 0; i < slices; ++i) - { - renderTargetViewDesc.Texture2DArray.FirstArraySlice = i * 6; - renderTargetViewDesc.Texture2DArray.ArraySize = 6; - - pTexture->additionalRTVs.push_back(WI_NULL_HANDLE); - hr = device->CreateRenderTargetView((ID3D11Resource*)pTexture->resource, &renderTargetViewDesc, (ID3D11RenderTargetView**)&pTexture->additionalRTVs[i]); - assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); - } - } - - { - // Create full-resource RTVs: - renderTargetViewDesc.Texture2DArray.FirstArraySlice = 0; - renderTargetViewDesc.Texture2DArray.ArraySize = arraySize; - - hr = device->CreateRenderTargetView((ID3D11Resource*)pTexture->resource, &renderTargetViewDesc, (ID3D11RenderTargetView**)&pTexture->RTV); - assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); - } - } - else - { - // Texture2D, Texture2DArray... - if (arraySize > 1 && pTexture->independentRTVArraySlices) - { - // Create subresource RTVs: - for (UINT i = 0; i < arraySize; ++i) - { - if (multisampled) - { - renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY; - renderTargetViewDesc.Texture2DMSArray.FirstArraySlice = i; - renderTargetViewDesc.Texture2DMSArray.ArraySize = 1; - } - else - { - renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; - renderTargetViewDesc.Texture2DArray.FirstArraySlice = i; - renderTargetViewDesc.Texture2DArray.ArraySize = 1; - renderTargetViewDesc.Texture2DArray.MipSlice = 0; - } - - pTexture->additionalRTVs.push_back(WI_NULL_HANDLE); - hr = device->CreateRenderTargetView((ID3D11Resource*)pTexture->resource, &renderTargetViewDesc, (ID3D11RenderTargetView**)&pTexture->additionalRTVs[i]); - assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); - } - } - - { - // Create the full-resource RTV: - if (arraySize > 1) - { - if (multisampled) - { - renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY; - renderTargetViewDesc.Texture2DMSArray.FirstArraySlice = 0; - renderTargetViewDesc.Texture2DMSArray.ArraySize = arraySize; - } - else - { - renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; - renderTargetViewDesc.Texture2DArray.FirstArraySlice = 0; - renderTargetViewDesc.Texture2DArray.ArraySize = arraySize; - renderTargetViewDesc.Texture2DArray.MipSlice = 0; - } - } - else - { - if (multisampled) - { - renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS; - } - else - { - renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; - renderTargetViewDesc.Texture2D.MipSlice = 0; - } - } - - hr = device->CreateRenderTargetView((ID3D11Resource*)pTexture->resource, &renderTargetViewDesc, (ID3D11RenderTargetView**)&pTexture->RTV); - assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); - } - } - } - - return hr; -} -HRESULT GraphicsDevice_DX11::CreateRenderTargetView(Texture3D* pTexture) -{ - if (!pTexture->additionalRTVs.empty()) - { - return E_FAIL; - } - - HRESULT hr = E_FAIL; - if (pTexture->desc.BindFlags & BIND_RENDER_TARGET) - { - - D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc; - ZeroMemory(&renderTargetViewDesc, sizeof(renderTargetViewDesc)); - renderTargetViewDesc.Format = _ConvertFormat(pTexture->desc.Format); - - if (pTexture->independentRTVArraySlices) - { - // Create Subresource RTVs: - for (UINT i = 0; i < pTexture->GetDesc().Depth; ++i) - { - renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; - renderTargetViewDesc.Texture3D.MipSlice = 0; - renderTargetViewDesc.Texture3D.FirstWSlice = i; - renderTargetViewDesc.Texture3D.WSize = 1; - - pTexture->additionalRTVs.push_back(WI_NULL_HANDLE); - hr = device->CreateRenderTargetView((ID3D11Resource*)pTexture->resource, &renderTargetViewDesc, (ID3D11RenderTargetView**)&pTexture->additionalRTVs[i]); - } - } - - { - // Create full-resource RTV: - renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; - renderTargetViewDesc.Texture3D.MipSlice = 0; - renderTargetViewDesc.Texture3D.FirstWSlice = 0; - renderTargetViewDesc.Texture3D.WSize = -1; - - pTexture->additionalRTVs.push_back(WI_NULL_HANDLE); - hr = device->CreateRenderTargetView((ID3D11Resource*)pTexture->resource, &renderTargetViewDesc, (ID3D11RenderTargetView**)&pTexture->additionalRTVs[0]); - } - - assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); - } - - return hr; -} -HRESULT GraphicsDevice_DX11::CreateDepthStencilView(Texture2D* pTexture) -{ - if (!pTexture->additionalDSVs.empty()) - { - return E_FAIL; - } - - HRESULT hr = E_FAIL; - if (pTexture->desc.BindFlags & BIND_DEPTH_STENCIL) - { - UINT arraySize = pTexture->desc.ArraySize; - UINT sampleCount = pTexture->desc.SampleDesc.Count; - bool multisampled = sampleCount > 1; - - D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc; - ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc)); - depthStencilViewDesc.Texture2DArray.MipSlice = 0; - depthStencilViewDesc.Flags = 0; - - // Try to resolve depth stencil format: - switch (pTexture->desc.Format) - { - case FORMAT_R16_TYPELESS: - depthStencilViewDesc.Format = DXGI_FORMAT_D16_UNORM; - break; - case FORMAT_R32_TYPELESS: - depthStencilViewDesc.Format = DXGI_FORMAT_D32_FLOAT; - break; - case FORMAT_R24G8_TYPELESS: - depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; - break; - case FORMAT_R32G8X24_TYPELESS: - depthStencilViewDesc.Format = DXGI_FORMAT_D32_FLOAT_S8X24_UINT; - break; - default: - depthStencilViewDesc.Format = _ConvertFormat(pTexture->desc.Format); - break; - } - - if (pTexture->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - // TextureCube, TextureCubeArray... - UINT slices = arraySize / 6; - - depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY; - depthStencilViewDesc.Texture2DArray.MipSlice = 0; - - if (pTexture->independentRTVCubemapFaces) - { - // independent faces - for (UINT i = 0; i < arraySize; ++i) - { - depthStencilViewDesc.Texture2DArray.FirstArraySlice = i; - depthStencilViewDesc.Texture2DArray.ArraySize = 1; - - pTexture->additionalDSVs.push_back(WI_NULL_HANDLE); - hr = device->CreateDepthStencilView((ID3D11Resource*)pTexture->resource, &depthStencilViewDesc, (ID3D11DepthStencilView**)&pTexture->additionalDSVs[i]); - } - } - else if (pTexture->independentRTVArraySlices) - { - // independent slices - for (UINT i = 0; i < slices; ++i) - { - depthStencilViewDesc.Texture2DArray.FirstArraySlice = i * 6; - depthStencilViewDesc.Texture2DArray.ArraySize = 6; - - pTexture->additionalDSVs.push_back(WI_NULL_HANDLE); - hr = device->CreateDepthStencilView((ID3D11Resource*)pTexture->resource, &depthStencilViewDesc, (ID3D11DepthStencilView**)&pTexture->additionalDSVs[i]); - } - } - - { - // Create full-resource DSV: - depthStencilViewDesc.Texture2DArray.FirstArraySlice = 0; - depthStencilViewDesc.Texture2DArray.ArraySize = arraySize; - - hr = device->CreateDepthStencilView((ID3D11Resource*)pTexture->resource, &depthStencilViewDesc, (ID3D11DepthStencilView**)&pTexture->DSV); - } - } - else - { - // Texture2D, Texture2DArray... - if (arraySize > 1 && pTexture->independentRTVArraySlices) - { - // Create subresource DSVs: - for (UINT i = 0; i < arraySize; ++i) - { - if (multisampled) - { - depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY; - depthStencilViewDesc.Texture2DMSArray.FirstArraySlice = i; - depthStencilViewDesc.Texture2DMSArray.ArraySize = 1; - } - else - { - depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY; - depthStencilViewDesc.Texture2DArray.MipSlice = 0; - depthStencilViewDesc.Texture2DArray.FirstArraySlice = i; - depthStencilViewDesc.Texture2DArray.ArraySize = 1; - } - - pTexture->additionalDSVs.push_back(WI_NULL_HANDLE); - hr = device->CreateDepthStencilView((ID3D11Resource*)pTexture->resource, &depthStencilViewDesc, (ID3D11DepthStencilView**)&pTexture->additionalDSVs[i]); - } - } - else - { - // Create full-resource DSV: - if (arraySize > 1) - { - if (multisampled) - { - depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY; - depthStencilViewDesc.Texture2DMSArray.FirstArraySlice = 0; - depthStencilViewDesc.Texture2DMSArray.ArraySize = arraySize; - } - else - { - depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY; - depthStencilViewDesc.Texture2DArray.FirstArraySlice = 0; - depthStencilViewDesc.Texture2DArray.ArraySize = arraySize; - depthStencilViewDesc.Texture2DArray.MipSlice = 0; - } - } - else - { - if (multisampled) - { - depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS; - } - else - { - depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; - depthStencilViewDesc.Texture2D.MipSlice = 0; - } - } - - hr = device->CreateDepthStencilView((ID3D11Resource*)pTexture->resource, &depthStencilViewDesc, (ID3D11DepthStencilView**)&pTexture->DSV); - } - } - - assert(SUCCEEDED(hr) && "DepthStencilView Creation failed!"); + hr = device->CreateUnorderedAccessView((ID3D11Resource*)pTexture3D->resource, nullptr, (ID3D11UnorderedAccessView**)&pTexture3D->UAV); + assert(SUCCEEDED(hr)); } return hr; @@ -2527,6 +1842,119 @@ HRESULT GraphicsDevice_DX11::CreatePipelineState(const PipelineStateDesc* pDesc, return S_OK; } +int GraphicsDevice_DX11::CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, UINT firstSlice, UINT sliceCount, UINT firstMip, UINT mipCount) +{ + switch (type) + { + case wiGraphics::SRV: + { + D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc; + + // Try to resolve shader resource format: + switch (texture->desc.Format) + { + case FORMAT_R16_TYPELESS: + srv_desc.Format = DXGI_FORMAT_R16_UNORM; + break; + case FORMAT_R32_TYPELESS: + srv_desc.Format = DXGI_FORMAT_R32_FLOAT; + break; + case FORMAT_R24G8_TYPELESS: + srv_desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; + break; + case FORMAT_R32G8X24_TYPELESS: + srv_desc.Format = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS; + break; + default: + srv_desc.Format = _ConvertFormat(texture->desc.Format); + break; + } + + if (texture->type == GPUResource::TEXTURE_1D) + { + srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D; + srv_desc.Texture1D.MostDetailedMip = firstMip; + srv_desc.Texture1D.MipLevels = mipCount; + } + else if (texture->type == GPUResource::TEXTURE_2D) + { + if (texture->desc.ArraySize > 1) + { + if (texture->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) + { + if (sliceCount > 6) + { + srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY; + srv_desc.TextureCubeArray.First2DArrayFace = firstSlice; + srv_desc.TextureCubeArray.NumCubes = sliceCount / 6; + srv_desc.TextureCubeArray.MostDetailedMip = firstMip; + srv_desc.TextureCubeArray.MipLevels = mipCount; + } + else + { + srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; + srv_desc.TextureCube.MostDetailedMip = firstMip; + srv_desc.TextureCube.MipLevels = mipCount; + } + } + else + { + if (texture->desc.SampleDesc.Count > 1) + { + srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY; + srv_desc.Texture2DMSArray.FirstArraySlice = firstSlice; + srv_desc.Texture2DMSArray.ArraySize = sliceCount; + } + else + { + srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; + srv_desc.Texture2DArray.FirstArraySlice = firstSlice; + srv_desc.Texture2DArray.ArraySize = sliceCount; + srv_desc.Texture2DArray.MostDetailedMip = firstMip; + srv_desc.Texture2DArray.MipLevels = mipCount; + } + } + } + else + { + if (texture->desc.SampleDesc.Count > 1) + { + srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS; + } + else + { + srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + srv_desc.Texture2D.MostDetailedMip = firstMip; + srv_desc.Texture2D.MipLevels = mipCount; + } + } + } + else if (texture->type == GPUResource::TEXTURE_3D) + { + srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; + srv_desc.Texture3D.MostDetailedMip = firstMip; + srv_desc.Texture3D.MipLevels = mipCount; + } + ID3D11ShaderResourceView* SRV; + HRESULT hr = device->CreateShaderResourceView((ID3D11Resource*)texture->resource, &srv_desc, &SRV); + if (SUCCEEDED(hr)) + { + texture->subresourceSRVs.push_back((wiCPUHandle)SRV); + return int(texture->subresourceSRVs.size() - 1); + } + } + break; + case wiGraphics::UAV: + break; + case wiGraphics::RTV: + break; + case wiGraphics::DSV: + break; + default: + break; + } + return -1; +} void GraphicsDevice_DX11::DestroyResource(GPUResource* pResource) { @@ -2541,28 +1969,28 @@ void GraphicsDevice_DX11::DestroyResource(GPUResource* pResource) ((ID3D11ShaderResourceView*)pResource->SRV)->Release(); pResource->SRV = WI_NULL_HANDLE; } - for (auto& x : pResource->additionalSRVs) + for (auto& x : pResource->subresourceSRVs) { if (x != WI_NULL_HANDLE) { ((ID3D11ShaderResourceView*)x)->Release(); } } - pResource->additionalSRVs.clear(); + pResource->subresourceSRVs.clear(); if (pResource->UAV != WI_NULL_HANDLE) { ((ID3D11UnorderedAccessView*)pResource->UAV)->Release(); pResource->UAV = WI_NULL_HANDLE; } - for (auto& x : pResource->additionalUAVs) + for (auto& x : pResource->subresourceUAVs) { if (x != WI_NULL_HANDLE) { ((ID3D11UnorderedAccessView*)x)->Release(); } } - pResource->additionalUAVs.clear(); + pResource->subresourceUAVs.clear(); } void GraphicsDevice_DX11::DestroyBuffer(GPUBuffer *pBuffer) { @@ -2574,14 +2002,14 @@ void GraphicsDevice_DX11::DestroyTexture1D(Texture1D *pTexture1D) ((ID3D11RenderTargetView*)pTexture1D->RTV)->Release(); pTexture1D->RTV = WI_NULL_HANDLE; } - for (auto& x : pTexture1D->additionalRTVs) + for (auto& x : pTexture1D->subresourceRTVs) { if (x != WI_NULL_HANDLE) { ((ID3D11RenderTargetView*)x)->Release(); } } - pTexture1D->additionalRTVs.clear(); + pTexture1D->subresourceRTVs.clear(); } void GraphicsDevice_DX11::DestroyTexture2D(Texture2D *pTexture2D) { @@ -2590,28 +2018,28 @@ void GraphicsDevice_DX11::DestroyTexture2D(Texture2D *pTexture2D) ((ID3D11RenderTargetView*)pTexture2D->RTV)->Release(); pTexture2D->RTV = WI_NULL_HANDLE; } - for (auto& x : pTexture2D->additionalRTVs) + for (auto& x : pTexture2D->subresourceRTVs) { if (x != WI_NULL_HANDLE) { ((ID3D11RenderTargetView*)x)->Release(); } } - pTexture2D->additionalRTVs.clear(); + pTexture2D->subresourceRTVs.clear(); if (pTexture2D->DSV != WI_NULL_HANDLE) { ((ID3D11DepthStencilView*)pTexture2D->DSV)->Release(); pTexture2D->DSV = WI_NULL_HANDLE; } - for (auto& x : pTexture2D->additionalDSVs) + for (auto& x : pTexture2D->subresourceDSVs) { if (x != WI_NULL_HANDLE) { ((ID3D11DepthStencilView*)x)->Release(); } } - pTexture2D->additionalDSVs.clear(); + pTexture2D->subresourceDSVs.clear(); } void GraphicsDevice_DX11::DestroyTexture3D(Texture3D *pTexture3D) { @@ -2619,14 +2047,14 @@ void GraphicsDevice_DX11::DestroyTexture3D(Texture3D *pTexture3D) { ((ID3D11RenderTargetView*)pTexture3D->RTV)->Release(); } - for (auto& x : pTexture3D->additionalRTVs) + for (auto& x : pTexture3D->subresourceRTVs) { if (x != WI_NULL_HANDLE) { ((ID3D11RenderTargetView*)x)->Release(); } } - pTexture3D->additionalRTVs.clear(); + pTexture3D->subresourceRTVs.clear(); } void GraphicsDevice_DX11::DestroyInputLayout(VertexLayout *pInputLayout) { @@ -2972,14 +2400,14 @@ void GraphicsDevice_DX11::BindRenderTargets(UINT NumViews, const Texture2D* cons ID3D11RenderTargetView* renderTargetViews[8] = {}; for (UINT i = 0; i < std::min(NumViews, 8u); ++i) { - if (arrayIndex < 0 || ppRenderTargets[i]->additionalRTVs.empty()) + if (arrayIndex < 0 || ppRenderTargets[i]->subresourceRTVs.empty()) { renderTargetViews[i] = (ID3D11RenderTargetView*)ppRenderTargets[i]->RTV; } else { - assert(ppRenderTargets[i]->additionalRTVs.size() > static_cast(arrayIndex) && "Invalid rendertarget arrayIndex!"); - renderTargetViews[i] = (ID3D11RenderTargetView*)ppRenderTargets[i]->additionalRTVs[arrayIndex]; + assert(ppRenderTargets[i]->subresourceRTVs.size() > static_cast(arrayIndex) && "Invalid rendertarget arrayIndex!"); + renderTargetViews[i] = (ID3D11RenderTargetView*)ppRenderTargets[i]->subresourceRTVs[arrayIndex]; } } @@ -2987,14 +2415,14 @@ void GraphicsDevice_DX11::BindRenderTargets(UINT NumViews, const Texture2D* cons ID3D11DepthStencilView* depthStencilView = nullptr; if (depthStencilTexture != nullptr) { - if (arrayIndex < 0 || depthStencilTexture->additionalDSVs.empty()) + if (arrayIndex < 0 || depthStencilTexture->subresourceDSVs.empty()) { depthStencilView = (ID3D11DepthStencilView*)depthStencilTexture->DSV; } else { - assert(depthStencilTexture->additionalDSVs.size() > static_cast(arrayIndex) && "Invalid depthstencil arrayIndex!"); - depthStencilView = (ID3D11DepthStencilView*)depthStencilTexture->additionalDSVs[arrayIndex]; + assert(depthStencilTexture->subresourceDSVs.size() > static_cast(arrayIndex) && "Invalid depthstencil arrayIndex!"); + depthStencilView = (ID3D11DepthStencilView*)depthStencilTexture->subresourceDSVs[arrayIndex]; } } @@ -3022,8 +2450,8 @@ void GraphicsDevice_DX11::ClearRenderTarget(const Texture* pTexture, const FLOAT } else { - assert(pTexture->additionalRTVs.size() > static_cast(arrayIndex) && "Invalid rendertarget arrayIndex!"); - deviceContexts[cmd]->ClearRenderTargetView((ID3D11RenderTargetView*)pTexture->additionalRTVs[arrayIndex], ColorRGBA); + assert(pTexture->subresourceRTVs.size() > static_cast(arrayIndex) && "Invalid rendertarget arrayIndex!"); + deviceContexts[cmd]->ClearRenderTargetView((ID3D11RenderTargetView*)pTexture->subresourceRTVs[arrayIndex], ColorRGBA); } } void GraphicsDevice_DX11::ClearDepthStencil(const Texture2D* pTexture, UINT ClearFlags, FLOAT Depth, UINT8 Stencil, CommandList cmd, int arrayIndex) @@ -3040,8 +2468,8 @@ void GraphicsDevice_DX11::ClearDepthStencil(const Texture2D* pTexture, UINT Clea } else { - assert(pTexture->additionalDSVs.size() > static_cast(arrayIndex) && "Invalid depthstencil arrayIndex!"); - deviceContexts[cmd]->ClearDepthStencilView((ID3D11DepthStencilView*)pTexture->additionalDSVs[arrayIndex], _flags, Depth, Stencil); + assert(pTexture->subresourceDSVs.size() > static_cast(arrayIndex) && "Invalid depthstencil arrayIndex!"); + deviceContexts[cmd]->ClearDepthStencilView((ID3D11DepthStencilView*)pTexture->subresourceDSVs[arrayIndex], _flags, Depth, Stencil); } } void GraphicsDevice_DX11::BindResource(SHADERSTAGE stage, const GPUResource* resource, UINT slot, CommandList cmd, int arrayIndex) @@ -3056,8 +2484,8 @@ void GraphicsDevice_DX11::BindResource(SHADERSTAGE stage, const GPUResource* res } else { - assert(resource->additionalSRVs.size() > static_cast(arrayIndex) && "Invalid arrayIndex!"); - SRV = (ID3D11ShaderResourceView*)resource->additionalSRVs[arrayIndex]; + assert(resource->subresourceSRVs.size() > static_cast(arrayIndex) && "Invalid arrayIndex!"); + SRV = (ID3D11ShaderResourceView*)resource->subresourceSRVs[arrayIndex]; } switch (stage) @@ -3132,8 +2560,8 @@ void GraphicsDevice_DX11::BindUAV(SHADERSTAGE stage, const GPUResource* resource } else { - assert(resource->additionalUAVs.size() > static_cast(arrayIndex) && "Invalid arrayIndex!"); - UAV = (ID3D11UnorderedAccessView*)resource->additionalUAVs[arrayIndex]; + assert(resource->subresourceUAVs.size() > static_cast(arrayIndex) && "Invalid arrayIndex!"); + UAV = (ID3D11UnorderedAccessView*)resource->subresourceUAVs[arrayIndex]; } if (stage == CS) diff --git a/WickedEngine/wiGraphicsDevice_DX11.h b/WickedEngine/wiGraphicsDevice_DX11.h index 07492737a..3a110bdab 100644 --- a/WickedEngine/wiGraphicsDevice_DX11.h +++ b/WickedEngine/wiGraphicsDevice_DX11.h @@ -88,6 +88,7 @@ namespace wiGraphics HRESULT CreateQuery(const GPUQueryDesc *pDesc, GPUQuery *pQuery) override; HRESULT CreatePipelineState(const PipelineStateDesc* pDesc, PipelineState* pso) override; + int CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, UINT firstSlice, UINT sliceCount = 1, UINT firstMip = 0, UINT mipCount = 0) override; void DestroyResource(GPUResource* pResource) override; void DestroyBuffer(GPUBuffer *pBuffer) override; @@ -167,14 +168,6 @@ namespace wiGraphics void EventBegin(const std::string& name, CommandList cmd) override; void EventEnd(CommandList cmd) override; void SetMarker(const std::string& name, CommandList cmd) override; - - private: - HRESULT CreateShaderResourceView(Texture1D* pTexture); - HRESULT CreateShaderResourceView(Texture2D* pTexture); - HRESULT CreateShaderResourceView(Texture3D* pTexture); - HRESULT CreateRenderTargetView(Texture2D* pTexture); - HRESULT CreateRenderTargetView(Texture3D* pTexture); - HRESULT CreateDepthStencilView(Texture2D* pTexture); }; } diff --git a/WickedEngine/wiGraphicsDevice_DX12.cpp b/WickedEngine/wiGraphicsDevice_DX12.cpp index 82610b846..aa41d6801 100644 --- a/WickedEngine/wiGraphicsDevice_DX12.cpp +++ b/WickedEngine/wiGraphicsDevice_DX12.cpp @@ -1068,7 +1068,7 @@ namespace wiGraphics } else { - src = ToNativeHandle(resource->additionalSRVs[arrayIndex]); + src = ToNativeHandle(resource->subresourceSRVs[arrayIndex]); } if (src.ptr == 0) @@ -1097,7 +1097,7 @@ namespace wiGraphics } else { - src = ToNativeHandle(resource->additionalUAVs[arrayIndex]); + src = ToNativeHandle(resource->subresourceUAVs[arrayIndex]); } if (src.ptr == 0) @@ -2114,507 +2114,23 @@ namespace wiGraphics if (pTexture2D->desc.BindFlags & BIND_RENDER_TARGET) { - UINT arraySize = pTexture2D->desc.ArraySize; - UINT sampleCount = pTexture2D->desc.SampleDesc.Count; - bool multisampled = sampleCount > 1; - - D3D12_RENDER_TARGET_VIEW_DESC renderTargetViewDesc = {}; - renderTargetViewDesc.Format = _ConvertFormat(pTexture2D->desc.Format); - renderTargetViewDesc.Texture2DArray.MipSlice = 0; - - if (pTexture2D->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - // TextureCube, TextureCubeArray... - UINT slices = arraySize / 6; - - renderTargetViewDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY; - renderTargetViewDesc.Texture2DArray.MipSlice = 0; - - if (pTexture2D->independentRTVCubemapFaces) - { - // independent faces - for (UINT i = 0; i < arraySize; ++i) - { - renderTargetViewDesc.Texture2DArray.FirstArraySlice = i; - renderTargetViewDesc.Texture2DArray.ArraySize = 1; - - pTexture2D->additionalRTVs.push_back(RTAllocator->allocate()); - device->CreateRenderTargetView((ID3D12Resource*)pTexture2D->resource, &renderTargetViewDesc, ToNativeHandle(pTexture2D->additionalRTVs.back())); - } - } - else if (pTexture2D->independentRTVArraySlices) - { - // independent slices - for (UINT i = 0; i < slices; ++i) - { - renderTargetViewDesc.Texture2DArray.FirstArraySlice = i * 6; - renderTargetViewDesc.Texture2DArray.ArraySize = 6; - - pTexture2D->additionalRTVs.push_back(RTAllocator->allocate()); - device->CreateRenderTargetView((ID3D12Resource*)pTexture2D->resource, &renderTargetViewDesc, ToNativeHandle(pTexture2D->additionalRTVs.back())); - } - } - - { - // Create full-resource RTVs: - renderTargetViewDesc.Texture2DArray.FirstArraySlice = 0; - renderTargetViewDesc.Texture2DArray.ArraySize = arraySize; - - pTexture2D->RTV = RTAllocator->allocate(); - device->CreateRenderTargetView((ID3D12Resource*)pTexture2D->resource, &renderTargetViewDesc, ToNativeHandle(pTexture2D->RTV)); - } - } - else - { - // Texture2D, Texture2DArray... - if (arraySize > 1 && pTexture2D->independentRTVArraySlices) - { - // Create subresource RTVs: - for (UINT i = 0; i < arraySize; ++i) - { - if (multisampled) - { - renderTargetViewDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY; - renderTargetViewDesc.Texture2DMSArray.FirstArraySlice = i; - renderTargetViewDesc.Texture2DMSArray.ArraySize = 1; - } - else - { - renderTargetViewDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY; - renderTargetViewDesc.Texture2DArray.FirstArraySlice = i; - renderTargetViewDesc.Texture2DArray.ArraySize = 1; - renderTargetViewDesc.Texture2DArray.MipSlice = 0; - } - - pTexture2D->additionalRTVs.push_back(RTAllocator->allocate()); - device->CreateRenderTargetView((ID3D12Resource*)pTexture2D->resource, &renderTargetViewDesc, ToNativeHandle(pTexture2D->additionalRTVs.back())); - } - } - - { - // Create the full-resource RTV: - if (arraySize > 1) - { - if (multisampled) - { - renderTargetViewDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY; - renderTargetViewDesc.Texture2DMSArray.FirstArraySlice = 0; - renderTargetViewDesc.Texture2DMSArray.ArraySize = arraySize; - } - else - { - renderTargetViewDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY; - renderTargetViewDesc.Texture2DArray.FirstArraySlice = 0; - renderTargetViewDesc.Texture2DArray.ArraySize = arraySize; - renderTargetViewDesc.Texture2DArray.MipSlice = 0; - } - } - else - { - if (multisampled) - { - renderTargetViewDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DMS; - } - else - { - renderTargetViewDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D; - renderTargetViewDesc.Texture2D.MipSlice = 0; - } - } - - pTexture2D->RTV = RTAllocator->allocate(); - device->CreateRenderTargetView((ID3D12Resource*)pTexture2D->resource, &renderTargetViewDesc, ToNativeHandle(pTexture2D->RTV)); - } - } + pTexture2D->RTV = RTAllocator->allocate(); + device->CreateRenderTargetView((ID3D12Resource*)pTexture2D->resource, nullptr, ToNativeHandle(pTexture2D->RTV)); } - if (pTexture2D->desc.BindFlags & BIND_DEPTH_STENCIL) { - UINT arraySize = pTexture2D->desc.ArraySize; - UINT sampleCount = pTexture2D->desc.SampleDesc.Count; - bool multisampled = sampleCount > 1; - - D3D12_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc = {}; - depthStencilViewDesc.Texture2DArray.MipSlice = 0; - depthStencilViewDesc.Flags = D3D12_DSV_FLAG_NONE; - - // Try to resolve depth stencil format: - switch (pTexture2D->desc.Format) - { - case FORMAT_R16_TYPELESS: - depthStencilViewDesc.Format = DXGI_FORMAT_D16_UNORM; - break; - case FORMAT_R32_TYPELESS: - depthStencilViewDesc.Format = DXGI_FORMAT_D32_FLOAT; - break; - case FORMAT_R24G8_TYPELESS: - depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; - break; - case FORMAT_R32G8X24_TYPELESS: - depthStencilViewDesc.Format = DXGI_FORMAT_D32_FLOAT_S8X24_UINT; - break; - default: - depthStencilViewDesc.Format = _ConvertFormat(pTexture2D->desc.Format); - break; - } - - if (pTexture2D->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - // TextureCube, TextureCubeArray... - UINT slices = arraySize / 6; - - depthStencilViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DARRAY; - depthStencilViewDesc.Texture2DArray.MipSlice = 0; - - if (pTexture2D->independentRTVCubemapFaces) - { - // independent faces - for (UINT i = 0; i < arraySize; ++i) - { - depthStencilViewDesc.Texture2DArray.FirstArraySlice = i; - depthStencilViewDesc.Texture2DArray.ArraySize = 1; - - pTexture2D->additionalDSVs.push_back(DSAllocator->allocate()); - device->CreateDepthStencilView((ID3D12Resource*)pTexture2D->resource, &depthStencilViewDesc, ToNativeHandle(pTexture2D->additionalDSVs.back())); - } - } - else if (pTexture2D->independentRTVArraySlices) - { - // independent slices - for (UINT i = 0; i < slices; ++i) - { - depthStencilViewDesc.Texture2DArray.FirstArraySlice = i * 6; - depthStencilViewDesc.Texture2DArray.ArraySize = 6; - - pTexture2D->additionalDSVs.push_back(DSAllocator->allocate()); - device->CreateDepthStencilView((ID3D12Resource*)pTexture2D->resource, &depthStencilViewDesc, ToNativeHandle(pTexture2D->additionalDSVs.back())); - } - } - - { - // Create full-resource DSV: - depthStencilViewDesc.Texture2DArray.FirstArraySlice = 0; - depthStencilViewDesc.Texture2DArray.ArraySize = arraySize; - - pTexture2D->DSV = DSAllocator->allocate(); - device->CreateDepthStencilView((ID3D12Resource*)pTexture2D->resource, &depthStencilViewDesc, ToNativeHandle(pTexture2D->DSV)); - } - } - else - { - // Texture2D, Texture2DArray... - if (arraySize > 1 && pTexture2D->independentRTVArraySlices) - { - // Create subresource DSVs: - for (UINT i = 0; i < arraySize; ++i) - { - if (multisampled) - { - depthStencilViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY; - depthStencilViewDesc.Texture2DMSArray.FirstArraySlice = i; - depthStencilViewDesc.Texture2DMSArray.ArraySize = 1; - } - else - { - depthStencilViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DARRAY; - depthStencilViewDesc.Texture2DArray.MipSlice = 0; - depthStencilViewDesc.Texture2DArray.FirstArraySlice = i; - depthStencilViewDesc.Texture2DArray.ArraySize = 1; - } - - pTexture2D->additionalDSVs.push_back(DSAllocator->allocate()); - device->CreateDepthStencilView((ID3D12Resource*)pTexture2D->resource, &depthStencilViewDesc, ToNativeHandle(pTexture2D->additionalDSVs.back())); - } - } - else - { - // Create full-resource DSV: - if (arraySize > 1) - { - if (multisampled) - { - depthStencilViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY; - depthStencilViewDesc.Texture2DMSArray.FirstArraySlice = 0; - depthStencilViewDesc.Texture2DMSArray.ArraySize = arraySize; - } - else - { - depthStencilViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DARRAY; - depthStencilViewDesc.Texture2DArray.FirstArraySlice = 0; - depthStencilViewDesc.Texture2DArray.ArraySize = arraySize; - depthStencilViewDesc.Texture2DArray.MipSlice = 0; - } - } - else - { - if (multisampled) - { - depthStencilViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DMS; - } - else - { - depthStencilViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D; - depthStencilViewDesc.Texture2D.MipSlice = 0; - } - } - - pTexture2D->DSV = DSAllocator->allocate(); - device->CreateDepthStencilView((ID3D12Resource*)pTexture2D->resource, &depthStencilViewDesc, ToNativeHandle(pTexture2D->DSV)); - } - } + pTexture2D->DSV = DSAllocator->allocate(); + device->CreateDepthStencilView((ID3D12Resource*)pTexture2D->resource, nullptr, ToNativeHandle(pTexture2D->DSV)); } - if (pTexture2D->desc.BindFlags & BIND_SHADER_RESOURCE) { - UINT arraySize = pTexture2D->desc.ArraySize; - UINT sampleCount = pTexture2D->desc.SampleDesc.Count; - bool multisampled = sampleCount > 1; - - D3D12_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc = {}; - shaderResourceViewDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; - // Try to resolve shader resource format: - switch (pTexture2D->desc.Format) - { - case FORMAT_R16_TYPELESS: - shaderResourceViewDesc.Format = DXGI_FORMAT_R16_UNORM; - break; - case FORMAT_R32_TYPELESS: - shaderResourceViewDesc.Format = DXGI_FORMAT_R32_FLOAT; - break; - case FORMAT_R24G8_TYPELESS: - shaderResourceViewDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; - break; - case FORMAT_R32G8X24_TYPELESS: - shaderResourceViewDesc.Format = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS; - break; - default: - shaderResourceViewDesc.Format = _ConvertFormat(pTexture2D->desc.Format); - break; - } - - if (arraySize > 1) - { - if (pTexture2D->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - if (arraySize > 6) - { - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY; - shaderResourceViewDesc.TextureCubeArray.First2DArrayFace = 0; - shaderResourceViewDesc.TextureCubeArray.NumCubes = arraySize / 6; - shaderResourceViewDesc.TextureCubeArray.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.TextureCubeArray.MipLevels = -1; //...to least detailed - } - else - { - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE; - shaderResourceViewDesc.TextureCube.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.TextureCube.MipLevels = -1; //...to least detailed - } - } - else - { - if (multisampled) - { - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY; - shaderResourceViewDesc.Texture2DMSArray.FirstArraySlice = 0; - shaderResourceViewDesc.Texture2DMSArray.ArraySize = arraySize; - } - else - { - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY; - shaderResourceViewDesc.Texture2DArray.FirstArraySlice = 0; - shaderResourceViewDesc.Texture2DArray.ArraySize = arraySize; - shaderResourceViewDesc.Texture2DArray.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.Texture2DArray.MipLevels = -1; //...to least detailed - } - } - pTexture2D->SRV = ResourceAllocator->allocate(); - device->CreateShaderResourceView((ID3D12Resource*)pTexture2D->resource, &shaderResourceViewDesc, ToNativeHandle(pTexture2D->SRV)); - - - if (pTexture2D->independentSRVMIPs) - { - if (pTexture2D->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - // independent MIPs - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY; - shaderResourceViewDesc.TextureCubeArray.First2DArrayFace = 0; - shaderResourceViewDesc.TextureCubeArray.NumCubes = arraySize / 6; - - for (UINT j = 0; j < pTexture2D->desc.MipLevels; ++j) - { - shaderResourceViewDesc.TextureCubeArray.MostDetailedMip = j; - shaderResourceViewDesc.TextureCubeArray.MipLevels = 1; - - pTexture2D->additionalSRVs.push_back(ResourceAllocator->allocate()); - device->CreateShaderResourceView((ID3D12Resource*)pTexture2D->resource, &shaderResourceViewDesc, ToNativeHandle(pTexture2D->additionalSRVs.back())); - } - } - else - { - UINT slices = arraySize; - - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY; - shaderResourceViewDesc.Texture2DArray.FirstArraySlice = 0; - shaderResourceViewDesc.Texture2DArray.ArraySize = pTexture2D->desc.ArraySize; - - for (UINT j = 0; j < pTexture2D->desc.MipLevels; ++j) - { - shaderResourceViewDesc.Texture2DArray.MostDetailedMip = j; - shaderResourceViewDesc.Texture2DArray.MipLevels = 1; - - pTexture2D->additionalSRVs.push_back(ResourceAllocator->allocate()); - device->CreateShaderResourceView((ID3D12Resource*)pTexture2D->resource, &shaderResourceViewDesc, ToNativeHandle(pTexture2D->additionalSRVs.back())); - } - } - } - - if (pTexture2D->independentSRVArraySlices) - { - if (pTexture2D->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - UINT slices = arraySize / 6; - - // independent cubemaps - for (UINT i = 0; i < slices; ++i) - { - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY; - shaderResourceViewDesc.TextureCubeArray.First2DArrayFace = i * 6; - shaderResourceViewDesc.TextureCubeArray.NumCubes = 1; - shaderResourceViewDesc.TextureCubeArray.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.TextureCubeArray.MipLevels = -1; //...to least detailed - - pTexture2D->additionalSRVs.push_back(ResourceAllocator->allocate()); - device->CreateShaderResourceView((ID3D12Resource*)pTexture2D->resource, &shaderResourceViewDesc, ToNativeHandle(pTexture2D->additionalSRVs.back())); - } - } - else - { - UINT slices = arraySize; - - // independent slices - for (UINT i = 0; i < slices; ++i) - { - if (multisampled) - { - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY; - shaderResourceViewDesc.Texture2DMSArray.FirstArraySlice = i; - shaderResourceViewDesc.Texture2DMSArray.ArraySize = 1; - } - else - { - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY; - shaderResourceViewDesc.Texture2DArray.FirstArraySlice = i; - shaderResourceViewDesc.Texture2DArray.ArraySize = 1; - shaderResourceViewDesc.Texture2DArray.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.Texture2DArray.MipLevels = -1; //...to least detailed - } - - pTexture2D->additionalSRVs.push_back(ResourceAllocator->allocate()); - device->CreateShaderResourceView((ID3D12Resource*)pTexture2D->resource, &shaderResourceViewDesc, ToNativeHandle(pTexture2D->additionalSRVs.back())); - } - } - } - } - else - { - if (multisampled) - { - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMS; - - pTexture2D->SRV = ResourceAllocator->allocate(); - device->CreateShaderResourceView((ID3D12Resource*)pTexture2D->resource, &shaderResourceViewDesc, ToNativeHandle(pTexture2D->SRV)); - } - else - { - shaderResourceViewDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; - - if (pTexture2D->independentSRVMIPs) - { - // Create subresource SRVs: - UINT miplevels = pTexture2D->desc.MipLevels; - for (UINT i = 0; i < miplevels; ++i) - { - shaderResourceViewDesc.Texture2D.MostDetailedMip = i; - shaderResourceViewDesc.Texture2D.MipLevels = 1; - - pTexture2D->additionalSRVs.push_back(ResourceAllocator->allocate()); - device->CreateShaderResourceView((ID3D12Resource*)pTexture2D->resource, &shaderResourceViewDesc, ToNativeHandle(pTexture2D->additionalSRVs.back())); - } - } - - { - // Create full-resource SRV: - shaderResourceViewDesc.Texture2D.MostDetailedMip = 0; //from most detailed... - shaderResourceViewDesc.Texture2D.MipLevels = -1; //...to least detailed - - pTexture2D->SRV = ResourceAllocator->allocate(); - device->CreateShaderResourceView((ID3D12Resource*)pTexture2D->resource, &shaderResourceViewDesc, ToNativeHandle(pTexture2D->SRV)); - } - } - } + pTexture2D->SRV = ResourceAllocator->allocate(); + device->CreateShaderResourceView((ID3D12Resource*)pTexture2D->resource, nullptr, ToNativeHandle(pTexture2D->SRV)); } - - if (pTexture2D->desc.BindFlags & BIND_UNORDERED_ACCESS) { - if (pTexture2D->desc.ArraySize > 1) - { - D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc; - ZeroMemory(&uav_desc, sizeof(uav_desc)); - uav_desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY; - uav_desc.Texture2DArray.FirstArraySlice = 0; - uav_desc.Texture2DArray.ArraySize = pTexture2D->desc.ArraySize; - uav_desc.Texture2DArray.MipSlice = 0; - - if (pTexture2D->independentUAVMIPs) - { - // Create subresource UAVs: - UINT miplevels = pTexture2D->desc.MipLevels; - for (UINT i = 0; i < miplevels; ++i) - { - uav_desc.Texture2DArray.MipSlice = i; - - pTexture2D->additionalUAVs.push_back(ResourceAllocator->allocate()); - device->CreateUnorderedAccessView((ID3D12Resource*)pTexture2D->resource, nullptr, &uav_desc, ToNativeHandle(pTexture2D->additionalUAVs.back())); - } - } - - { - // Create main resource UAV: - uav_desc.Texture2D.MipSlice = 0; - - pTexture2D->UAV = ResourceAllocator->allocate(); - device->CreateUnorderedAccessView((ID3D12Resource*)pTexture2D->resource, nullptr, &uav_desc, ToNativeHandle(pTexture2D->UAV)); - } - } - else - { - D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc = {}; - uav_desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D; - - if (pTexture2D->independentUAVMIPs) - { - // Create subresource UAVs: - UINT miplevels = pTexture2D->desc.MipLevels; - for (UINT i = 0; i < miplevels; ++i) - { - uav_desc.Texture2D.MipSlice = i; - - - pTexture2D->additionalUAVs.push_back(ResourceAllocator->allocate()); - device->CreateUnorderedAccessView((ID3D12Resource*)pTexture2D->resource, nullptr, &uav_desc, ToNativeHandle(pTexture2D->additionalUAVs.back())); - } - } - - { - // Create main resource UAV: - uav_desc.Texture2D.MipSlice = 0; - - pTexture2D->UAV = ResourceAllocator->allocate(); - device->CreateUnorderedAccessView((ID3D12Resource*)pTexture2D->resource, nullptr, &uav_desc, ToNativeHandle(pTexture2D->UAV)); - } - } + pTexture2D->UAV = ResourceAllocator->allocate(); + device->CreateUnorderedAccessView((ID3D12Resource*)pTexture2D->resource, nullptr, nullptr, ToNativeHandle(pTexture2D->UAV)); } return hr; @@ -2927,6 +2443,23 @@ namespace wiGraphics return hr; } + int GraphicsDevice_DX12::CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, UINT firstSlice, UINT sliceCount, UINT firstMip, UINT mipCount) + { + switch (type) + { + case wiGraphics::SRV: + break; + case wiGraphics::UAV: + break; + case wiGraphics::RTV: + break; + case wiGraphics::DSV: + break; + default: + break; + } + return -1; + } void GraphicsDevice_DX12::DestroyResource(GPUResource* pResource) { @@ -2938,19 +2471,19 @@ namespace wiGraphics DeferredDestroy({ DestroyItem::RESOURCEVIEW, FRAMECOUNT, pResource->SRV }); pResource->SRV = WI_NULL_HANDLE; - for (auto& x : pResource->additionalSRVs) + for (auto& x : pResource->subresourceSRVs) { DeferredDestroy({ DestroyItem::RESOURCEVIEW, FRAMECOUNT, x }); } - pResource->additionalSRVs.clear(); + pResource->subresourceSRVs.clear(); DeferredDestroy({ DestroyItem::RESOURCEVIEW, FRAMECOUNT, pResource->UAV }); pResource->UAV = WI_NULL_HANDLE; - for (auto& x : pResource->additionalUAVs) + for (auto& x : pResource->subresourceUAVs) { DeferredDestroy({ DestroyItem::RESOURCEVIEW, FRAMECOUNT, x }); } - pResource->additionalUAVs.clear(); + pResource->subresourceUAVs.clear(); } void GraphicsDevice_DX12::DestroyBuffer(GPUBuffer *pBuffer) { @@ -2961,39 +2494,39 @@ namespace wiGraphics { DeferredDestroy({ DestroyItem::RENDERTARGETVIEW, FRAMECOUNT, pTexture1D->RTV }); pTexture1D->RTV = WI_NULL_HANDLE; - for (auto& x : pTexture1D->additionalRTVs) + for (auto& x : pTexture1D->subresourceRTVs) { DeferredDestroy({ DestroyItem::RENDERTARGETVIEW, FRAMECOUNT, x }); } - pTexture1D->additionalRTVs.clear(); + pTexture1D->subresourceRTVs.clear(); } void GraphicsDevice_DX12::DestroyTexture2D(Texture2D *pTexture2D) { DeferredDestroy({ DestroyItem::RENDERTARGETVIEW, FRAMECOUNT, pTexture2D->RTV }); pTexture2D->RTV = WI_NULL_HANDLE; - for (auto& x : pTexture2D->additionalRTVs) + for (auto& x : pTexture2D->subresourceRTVs) { DeferredDestroy({ DestroyItem::RENDERTARGETVIEW, FRAMECOUNT, x }); } - pTexture2D->additionalRTVs.clear(); + pTexture2D->subresourceRTVs.clear(); DeferredDestroy({ DestroyItem::DEPTHSTENCILVIEW, FRAMECOUNT, pTexture2D->DSV }); pTexture2D->DSV = WI_NULL_HANDLE; - for (auto& x : pTexture2D->additionalDSVs) + for (auto& x : pTexture2D->subresourceDSVs) { DeferredDestroy({ DestroyItem::DEPTHSTENCILVIEW, FRAMECOUNT, x }); } - pTexture2D->additionalDSVs.clear(); + pTexture2D->subresourceDSVs.clear(); } void GraphicsDevice_DX12::DestroyTexture3D(Texture3D *pTexture3D) { DeferredDestroy({ DestroyItem::RENDERTARGETVIEW, FRAMECOUNT, pTexture3D->RTV }); pTexture3D->RTV = WI_NULL_HANDLE; - for (auto& x : pTexture3D->additionalRTVs) + for (auto& x : pTexture3D->subresourceRTVs) { DeferredDestroy({ DestroyItem::RENDERTARGETVIEW, FRAMECOUNT, x }); } - pTexture3D->additionalRTVs.clear(); + pTexture3D->subresourceRTVs.clear(); } void GraphicsDevice_DX12::DestroyInputLayout(VertexLayout *pInputLayout) { @@ -3331,14 +2864,14 @@ namespace wiGraphics { if (ppRenderTargets[i] != nullptr) { - if (arrayIndex < 0 || ppRenderTargets[i]->additionalRTVs.empty()) + if (arrayIndex < 0 || ppRenderTargets[i]->subresourceRTVs.empty()) { descriptors[i] = ToNativeHandle(ppRenderTargets[i]->RTV); } else { - assert(ppRenderTargets[i]->additionalRTVs.size() > static_cast(arrayIndex) && "Invalid rendertarget arrayIndex!"); - descriptors[i] = ToNativeHandle(ppRenderTargets[i]->additionalRTVs[arrayIndex]); + assert(ppRenderTargets[i]->subresourceRTVs.size() > static_cast(arrayIndex) && "Invalid rendertarget arrayIndex!"); + descriptors[i] = ToNativeHandle(ppRenderTargets[i]->subresourceRTVs[arrayIndex]); } } } @@ -3346,14 +2879,14 @@ namespace wiGraphics D3D12_CPU_DESCRIPTOR_HANDLE* DSV = nullptr; if (depthStencilTexture != nullptr) { - if (arrayIndex < 0 || depthStencilTexture->additionalDSVs.empty()) + if (arrayIndex < 0 || depthStencilTexture->subresourceDSVs.empty()) { DSV = &ToNativeHandle(depthStencilTexture->DSV); } else { - assert(depthStencilTexture->additionalDSVs.size() > static_cast(arrayIndex) && "Invalid depthstencil arrayIndex!"); - DSV = &ToNativeHandle(depthStencilTexture->additionalDSVs[arrayIndex]); + assert(depthStencilTexture->subresourceDSVs.size() > static_cast(arrayIndex) && "Invalid depthstencil arrayIndex!"); + DSV = &ToNativeHandle(depthStencilTexture->subresourceDSVs[arrayIndex]); } } @@ -3369,7 +2902,7 @@ namespace wiGraphics } else { - GetDirectCommandList(cmd)->ClearRenderTargetView(ToNativeHandle(pTexture->additionalRTVs[arrayIndex]), ColorRGBA, 0, nullptr); + GetDirectCommandList(cmd)->ClearRenderTargetView(ToNativeHandle(pTexture->subresourceRTVs[arrayIndex]), ColorRGBA, 0, nullptr); } } } @@ -3389,7 +2922,7 @@ namespace wiGraphics } else { - GetDirectCommandList(cmd)->ClearDepthStencilView(ToNativeHandle(pTexture->additionalDSVs[arrayIndex]), (D3D12_CLEAR_FLAGS)_flags, Depth, Stencil, 0, nullptr); + GetDirectCommandList(cmd)->ClearDepthStencilView(ToNativeHandle(pTexture->subresourceDSVs[arrayIndex]), (D3D12_CLEAR_FLAGS)_flags, Depth, Stencil, 0, nullptr); } } } diff --git a/WickedEngine/wiGraphicsDevice_DX12.h b/WickedEngine/wiGraphicsDevice_DX12.h index 79860b872..f91608bc8 100644 --- a/WickedEngine/wiGraphicsDevice_DX12.h +++ b/WickedEngine/wiGraphicsDevice_DX12.h @@ -224,6 +224,7 @@ namespace wiGraphics HRESULT CreateQuery(const GPUQueryDesc *pDesc, GPUQuery *pQuery) override; HRESULT CreatePipelineState(const PipelineStateDesc* pDesc, PipelineState* pso) override; + int CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, UINT firstSlice, UINT sliceCount = 1, UINT firstMip = 0, UINT mipCount = 0) override; void DestroyResource(GPUResource* pResource) override; void DestroyBuffer(GPUBuffer *pBuffer) override; diff --git a/WickedEngine/wiGraphicsDevice_Vulkan.cpp b/WickedEngine/wiGraphicsDevice_Vulkan.cpp index 0d3d052cf..9b0d143a4 100644 --- a/WickedEngine/wiGraphicsDevice_Vulkan.cpp +++ b/WickedEngine/wiGraphicsDevice_Vulkan.cpp @@ -1065,7 +1065,7 @@ namespace wiGraphics continue; } - wiCPUHandle SRV = arrayIndex < 0 ? resource->SRV : resource->additionalSRVs[arrayIndex]; + wiCPUHandle SRV = arrayIndex < 0 ? resource->SRV : resource->subresourceSRVs[arrayIndex]; if (resource->IsTexture() && resource->SRV != VK_NULL_HANDLE) { @@ -1153,7 +1153,7 @@ namespace wiGraphics continue; } - wiCPUHandle UAV = arrayIndex < 0 ? resource->UAV : resource->additionalUAVs[arrayIndex]; + wiCPUHandle UAV = arrayIndex < 0 ? resource->UAV : resource->subresourceUAVs[arrayIndex]; if (resource->IsTexture() && resource->UAV != VK_NULL_HANDLE) { @@ -2755,128 +2755,59 @@ namespace wiGraphics if (pTexture2D->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) { - // TextureCube, TextureCubeArray... - UINT slices = arraySize / 6; - + // Create full-resource RTVs: + if (arraySize > 6) + { + rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; + } + else + { + rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE; + } + rtv_desc.subresourceRange.baseArrayLayer = 0; + rtv_desc.subresourceRange.layerCount = pTexture2D->desc.ArraySize; rtv_desc.subresourceRange.baseMipLevel = 0; rtv_desc.subresourceRange.levelCount = 1; // RTV so only 1 MIP! - if (pTexture2D->independentRTVCubemapFaces) - { - // independent faces - rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; - - for (UINT i = 0; i < arraySize; ++i) - { - rtv_desc.subresourceRange.baseArrayLayer = i; - rtv_desc.subresourceRange.layerCount = 1; - - pTexture2D->additionalRTVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &rtv_desc, nullptr, reinterpret_cast(&pTexture2D->additionalRTVs.back())); - assert(res == VK_SUCCESS); - } - } - else if (pTexture2D->independentRTVArraySlices) - { - // independent cubemaps - rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE; - - for (UINT i = 0; i < slices; ++i) - { - rtv_desc.subresourceRange.baseArrayLayer = i * 6; - rtv_desc.subresourceRange.layerCount = 6; - - pTexture2D->additionalRTVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &rtv_desc, nullptr, reinterpret_cast(&pTexture2D->additionalRTVs.back())); - assert(res == VK_SUCCESS); - } - } - - { - // Create full-resource RTVs: - if (arraySize > 6) - { - rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; - } - else - { - rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE; - } - rtv_desc.subresourceRange.baseArrayLayer = 0; - rtv_desc.subresourceRange.layerCount = pTexture2D->desc.ArraySize; - rtv_desc.subresourceRange.baseMipLevel = 0; - rtv_desc.subresourceRange.levelCount = 1; // RTV so only 1 MIP! - - res = vkCreateImageView(device, &rtv_desc, nullptr, reinterpret_cast(&pTexture2D->RTV)); - hr = res == VK_SUCCESS; - assert(SUCCEEDED(hr)); - } + res = vkCreateImageView(device, &rtv_desc, nullptr, reinterpret_cast(&pTexture2D->RTV)); + hr = res == VK_SUCCESS; + assert(SUCCEEDED(hr)); } else { - if (arraySize > 1 && pTexture2D->independentRTVArraySlices) + // Create full-resource RTV: + + if (arraySize > 1) { if (multisampled) { - rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; // MS? + rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; // MSArray? + } + else + { + rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; + } + } + else + { + if (multisampled) + { + rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; // MSAA? } else { rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; } - rtv_desc.subresourceRange.baseMipLevel = 0; - rtv_desc.subresourceRange.levelCount = 1; // RTV so only 1 MIP! - - UINT slices = arraySize; - - // independent slices - for (UINT i = 0; i < slices; ++i) - { - rtv_desc.subresourceRange.baseArrayLayer = i; - rtv_desc.subresourceRange.layerCount = 1; - - pTexture2D->additionalRTVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &rtv_desc, nullptr, reinterpret_cast(&pTexture2D->additionalRTVs.back())); - assert(res == VK_SUCCESS); - } } - { - // Create full-resource RTV: - - if (arraySize > 1) - { - if (multisampled) - { - rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; // MSArray? - } - else - { - rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; - } - } - else - { - if (multisampled) - { - rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; // MSAA? - } - else - { - rtv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; - } - } - - rtv_desc.subresourceRange.baseArrayLayer = 0; - rtv_desc.subresourceRange.layerCount = pTexture2D->desc.ArraySize; - rtv_desc.subresourceRange.baseMipLevel = 0; - rtv_desc.subresourceRange.levelCount = 1; // RTV so only 1 MIP! - - res = vkCreateImageView(device, &rtv_desc, nullptr, reinterpret_cast(&pTexture2D->RTV)); - hr = res == VK_SUCCESS; - assert(SUCCEEDED(hr)); - } + rtv_desc.subresourceRange.baseArrayLayer = 0; + rtv_desc.subresourceRange.layerCount = pTexture2D->desc.ArraySize; + rtv_desc.subresourceRange.baseMipLevel = 0; + rtv_desc.subresourceRange.levelCount = 1; // RTV so only 1 MIP! + res = vkCreateImageView(device, &rtv_desc, nullptr, reinterpret_cast(&pTexture2D->RTV)); + hr = res == VK_SUCCESS; + assert(SUCCEEDED(hr)); } } @@ -2917,128 +2848,56 @@ namespace wiGraphics if (pTexture2D->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) { - // TextureCube, TextureCubeArray... - UINT slices = arraySize / 6; - + if (arraySize > 6) + { + dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; + } + else + { + dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE; + } + dsv_desc.subresourceRange.baseArrayLayer = 0; + dsv_desc.subresourceRange.layerCount = pTexture2D->desc.ArraySize; dsv_desc.subresourceRange.baseMipLevel = 0; dsv_desc.subresourceRange.levelCount = 1; // DSV so only 1 MIP! - if (pTexture2D->independentRTVCubemapFaces) - { - // independent faces - dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; - - for (UINT i = 0; i < arraySize; ++i) - { - dsv_desc.subresourceRange.baseArrayLayer = i; - dsv_desc.subresourceRange.layerCount = 1; - - pTexture2D->additionalDSVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &dsv_desc, nullptr, reinterpret_cast(&pTexture2D->additionalDSVs.back())); - assert(res == VK_SUCCESS); - } - } - else if (pTexture2D->independentRTVArraySlices) - { - // independent cubemaps - dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE; - - for (UINT i = 0; i < slices; ++i) - { - dsv_desc.subresourceRange.baseArrayLayer = i * 6; - dsv_desc.subresourceRange.layerCount = 6; - - pTexture2D->additionalDSVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &dsv_desc, nullptr, reinterpret_cast(&pTexture2D->additionalDSVs.back())); - assert(res == VK_SUCCESS); - } - } - - { - // Create full-resource RTVs: - if (arraySize > 6) - { - dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; - } - else - { - dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE; - } - dsv_desc.subresourceRange.baseArrayLayer = 0; - dsv_desc.subresourceRange.layerCount = pTexture2D->desc.ArraySize; - dsv_desc.subresourceRange.baseMipLevel = 0; - dsv_desc.subresourceRange.levelCount = 1; // DSV so only 1 MIP! - - res = vkCreateImageView(device, &dsv_desc, nullptr, reinterpret_cast(&pTexture2D->DSV)); - hr = res == VK_SUCCESS; - assert(SUCCEEDED(hr)); - } + res = vkCreateImageView(device, &dsv_desc, nullptr, reinterpret_cast(&pTexture2D->DSV)); + hr = res == VK_SUCCESS; + assert(SUCCEEDED(hr)); } else { - if (arraySize > 1 && pTexture2D->independentRTVArraySlices) + if (arraySize > 1) { if (multisampled) { - dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; // MS? + dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; // MSArray? + } + else + { + dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; + } + } + else + { + if (multisampled) + { + dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; // MSAA? } else { dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; } - dsv_desc.subresourceRange.baseMipLevel = 0; - dsv_desc.subresourceRange.levelCount = 1; // DSV so only 1 MIP! - - UINT slices = arraySize; - - // independent slices - for (UINT i = 0; i < slices; ++i) - { - dsv_desc.subresourceRange.baseArrayLayer = i; - dsv_desc.subresourceRange.layerCount = 1; - - pTexture2D->additionalDSVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &dsv_desc, nullptr, reinterpret_cast(&pTexture2D->additionalDSVs.back())); - assert(res == VK_SUCCESS); - } } - { - // Create full-resource RTV: - - if (arraySize > 1) - { - if (multisampled) - { - dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; // MSArray? - } - else - { - dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; - } - } - else - { - if (multisampled) - { - dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; // MSAA? - } - else - { - dsv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; - } - } - - dsv_desc.subresourceRange.baseArrayLayer = 0; - dsv_desc.subresourceRange.layerCount = pTexture2D->desc.ArraySize; - dsv_desc.subresourceRange.baseMipLevel = 0; - dsv_desc.subresourceRange.levelCount = 1; // DSV so only 1 MIP! - - res = vkCreateImageView(device, &dsv_desc, nullptr, reinterpret_cast(&pTexture2D->DSV)); - hr = res == VK_SUCCESS; - assert(SUCCEEDED(hr)); - } + dsv_desc.subresourceRange.baseArrayLayer = 0; + dsv_desc.subresourceRange.layerCount = pTexture2D->desc.ArraySize; + dsv_desc.subresourceRange.baseMipLevel = 0; + dsv_desc.subresourceRange.levelCount = 1; // DSV so only 1 MIP! + res = vkCreateImageView(device, &dsv_desc, nullptr, reinterpret_cast(&pTexture2D->DSV)); + hr = res == VK_SUCCESS; + assert(SUCCEEDED(hr)); } } @@ -3084,75 +2943,6 @@ namespace wiGraphics break; } - - if (arraySize > 1) - { - if (pTexture2D->independentSRVArraySlices) - { - if (pTexture2D->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - UINT slices = arraySize / 6; - - // independent cubemaps - srv_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE; - - for (UINT i = 0; i < slices; ++i) - { - srv_desc.subresourceRange.baseArrayLayer = i * 6; - srv_desc.subresourceRange.layerCount = 6; - - pTexture2D->additionalSRVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &srv_desc, nullptr, reinterpret_cast(&pTexture2D->additionalSRVs.back())); - assert(res == VK_SUCCESS); - } - } - else - { - UINT slices = arraySize; - - // independent slices - srv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; - - for (UINT i = 0; i < slices; ++i) - { - srv_desc.subresourceRange.baseArrayLayer = i; - srv_desc.subresourceRange.layerCount = 1; - - pTexture2D->additionalSRVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &srv_desc, nullptr, reinterpret_cast(&pTexture2D->additionalSRVs.back())); - assert(res == VK_SUCCESS); - } - } - } - } - else - { - if (multisampled) - { - srv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; // MSAA? - } - else - { - srv_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; - - if (pTexture2D->independentSRVMIPs) - { - // Create subresource SRVs: - UINT miplevels = pTexture2D->desc.MipLevels; - for (UINT i = 0; i < miplevels; ++i) - { - srv_desc.subresourceRange.baseMipLevel = i; - srv_desc.subresourceRange.levelCount = 1; - - pTexture2D->additionalSRVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &srv_desc, nullptr, reinterpret_cast(&pTexture2D->additionalSRVs.back())); - assert(res == VK_SUCCESS); - } - } - } - } - - // Create full-resource SRV: if (pTexture2D->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) { if (arraySize > 6) @@ -3213,51 +3003,6 @@ namespace wiGraphics uav_desc.format = _ConvertFormat(pTexture2D->desc.Format); - - if (arraySize > 1) - { - uav_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY; - uav_desc.subresourceRange.baseArrayLayer = 0; - uav_desc.subresourceRange.layerCount = arraySize; - uav_desc.subresourceRange.levelCount = 1; - - if (pTexture2D->independentUAVMIPs) - { - // Create subresource SRVs: - UINT miplevels = pTexture2D->desc.MipLevels; - for (UINT i = 0; i < miplevels; ++i) - { - uav_desc.subresourceRange.baseMipLevel = i; - - pTexture2D->additionalUAVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &uav_desc, nullptr, reinterpret_cast(&pTexture2D->additionalUAVs.back())); - assert(res == VK_SUCCESS); - } - } - } - else - { - uav_desc.viewType = VK_IMAGE_VIEW_TYPE_2D; - uav_desc.subresourceRange.baseArrayLayer = 0; - uav_desc.subresourceRange.layerCount = 1; - uav_desc.subresourceRange.levelCount = 1; - - if (pTexture2D->independentUAVMIPs) - { - // Create subresource SRVs: - UINT miplevels = pTexture2D->desc.MipLevels; - for (UINT i = 0; i < miplevels; ++i) - { - uav_desc.subresourceRange.baseMipLevel = i; - - pTexture2D->additionalUAVs.push_back(VK_NULL_HANDLE); - res = vkCreateImageView(device, &uav_desc, nullptr, reinterpret_cast(&pTexture2D->additionalUAVs.back())); - assert(res == VK_SUCCESS); - } - } - } - - // Create full-resource UAV: uav_desc.subresourceRange.baseArrayLayer = 0; uav_desc.subresourceRange.layerCount = pTexture2D->desc.ArraySize; uav_desc.subresourceRange.baseMipLevel = 0; @@ -4100,6 +3845,23 @@ namespace wiGraphics return hr; } + int GraphicsDevice_Vulkan::CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, UINT firstSlice, UINT sliceCount, UINT firstMip, UINT mipCount) + { + switch (type) + { + case wiGraphics::SRV: + break; + case wiGraphics::UAV: + break; + case wiGraphics::RTV: + break; + case wiGraphics::DSV: + break; + default: + break; + } + return -1; + } void GraphicsDevice_Vulkan::DestroyResource(GPUResource* pResource) { @@ -4113,19 +3875,19 @@ namespace wiGraphics DeferredDestroy({ DestroyItem::BUFFERVIEW, FRAMECOUNT, pBuffer->SRV }); pBuffer->SRV = WI_NULL_HANDLE; - for (auto& x : pBuffer->additionalSRVs) + for (auto& x : pBuffer->subresourceSRVs) { DeferredDestroy({ DestroyItem::BUFFERVIEW, FRAMECOUNT, x }); } - pBuffer->additionalSRVs.clear(); + pBuffer->subresourceSRVs.clear(); DeferredDestroy({ DestroyItem::BUFFERVIEW, FRAMECOUNT, pBuffer->UAV }); pBuffer->UAV = WI_NULL_HANDLE; - for (auto& x : pBuffer->additionalUAVs) + for (auto& x : pBuffer->subresourceUAVs) { DeferredDestroy({ DestroyItem::BUFFERVIEW, FRAMECOUNT, x }); } - pBuffer->additionalUAVs.clear(); + pBuffer->subresourceUAVs.clear(); } void GraphicsDevice_Vulkan::DestroyTexture1D(Texture1D *pTexture1D) { @@ -4134,27 +3896,27 @@ namespace wiGraphics DeferredDestroy({ DestroyItem::IMAGEVIEW, pTexture1D->RTV }); pTexture1D->RTV = WI_NULL_HANDLE; - for (auto& x : pTexture1D->additionalRTVs) + for (auto& x : pTexture1D->subresourceRTVs) { DeferredDestroy({ DestroyItem::IMAGEVIEW, x }); } - pTexture1D->additionalRTVs.clear(); + pTexture1D->subresourceRTVs.clear(); DeferredDestroy({ DestroyItem::IMAGEVIEW, pTexture1D->SRV }); pTexture1D->SRV = WI_NULL_HANDLE; - for (auto& x : pTexture1D->additionalSRVs) + for (auto& x : pTexture1D->subresourceSRVs) { DeferredDestroy({ DestroyItem::IMAGEVIEW, x }); } - pTexture1D->additionalSRVs.clear(); + pTexture1D->subresourceSRVs.clear(); DeferredDestroy({ DestroyItem::IMAGEVIEW, pTexture1D->UAV }); pTexture1D->UAV = WI_NULL_HANDLE; - for (auto& x : pTexture1D->additionalUAVs) + for (auto& x : pTexture1D->subresourceUAVs) { DeferredDestroy({ DestroyItem::IMAGEVIEW, x }); } - pTexture1D->additionalUAVs.clear(); + pTexture1D->subresourceUAVs.clear(); } void GraphicsDevice_Vulkan::DestroyTexture2D(Texture2D *pTexture2D) { @@ -4163,35 +3925,35 @@ namespace wiGraphics DeferredDestroy({ DestroyItem::IMAGEVIEW, pTexture2D->RTV }); pTexture2D->RTV = WI_NULL_HANDLE; - for (auto& x : pTexture2D->additionalRTVs) + for (auto& x : pTexture2D->subresourceRTVs) { DeferredDestroy({ DestroyItem::IMAGEVIEW, x }); } - pTexture2D->additionalRTVs.clear(); + pTexture2D->subresourceRTVs.clear(); DeferredDestroy({ DestroyItem::IMAGEVIEW, pTexture2D->DSV }); pTexture2D->DSV = WI_NULL_HANDLE; - for (auto& x : pTexture2D->additionalDSVs) + for (auto& x : pTexture2D->subresourceDSVs) { DeferredDestroy({ DestroyItem::IMAGEVIEW, x }); } - pTexture2D->additionalDSVs.clear(); + pTexture2D->subresourceDSVs.clear(); DeferredDestroy({ DestroyItem::IMAGEVIEW, pTexture2D->SRV }); pTexture2D->SRV = WI_NULL_HANDLE; - for (auto& x : pTexture2D->additionalSRVs) + for (auto& x : pTexture2D->subresourceSRVs) { DeferredDestroy({ DestroyItem::IMAGEVIEW, x }); } - pTexture2D->additionalSRVs.clear(); + pTexture2D->subresourceSRVs.clear(); DeferredDestroy({ DestroyItem::IMAGEVIEW, pTexture2D->UAV }); pTexture2D->UAV = WI_NULL_HANDLE; - for (auto& x : pTexture2D->additionalUAVs) + for (auto& x : pTexture2D->subresourceUAVs) { DeferredDestroy({ DestroyItem::IMAGEVIEW, x }); } - pTexture2D->additionalUAVs.clear(); + pTexture2D->subresourceUAVs.clear(); } void GraphicsDevice_Vulkan::DestroyTexture3D(Texture3D *pTexture3D) { @@ -4200,27 +3962,27 @@ namespace wiGraphics DeferredDestroy({ DestroyItem::IMAGEVIEW, pTexture3D->RTV }); pTexture3D->RTV = WI_NULL_HANDLE; - for (auto& x : pTexture3D->additionalRTVs) + for (auto& x : pTexture3D->subresourceRTVs) { DeferredDestroy({ DestroyItem::IMAGEVIEW, x }); } - pTexture3D->additionalRTVs.clear(); + pTexture3D->subresourceRTVs.clear(); DeferredDestroy({ DestroyItem::IMAGEVIEW, pTexture3D->SRV }); pTexture3D->SRV = WI_NULL_HANDLE; - for (auto& x : pTexture3D->additionalSRVs) + for (auto& x : pTexture3D->subresourceSRVs) { DeferredDestroy({ DestroyItem::IMAGEVIEW, x }); } - pTexture3D->additionalSRVs.clear(); + pTexture3D->subresourceSRVs.clear(); DeferredDestroy({ DestroyItem::IMAGEVIEW, pTexture3D->UAV }); pTexture3D->UAV = WI_NULL_HANDLE; - for (auto& x : pTexture3D->additionalUAVs) + for (auto& x : pTexture3D->subresourceUAVs) { DeferredDestroy({ DestroyItem::IMAGEVIEW, x }); } - pTexture3D->additionalUAVs.clear(); + pTexture3D->subresourceUAVs.clear(); } void GraphicsDevice_Vulkan::DestroyInputLayout(VertexLayout *pInputLayout) { @@ -4640,14 +4402,14 @@ namespace wiGraphics assert(NumViews <= 8); for (UINT i = 0; i < NumViews; ++i) { - if (arrayIndex < 0 || ppRenderTargets[i]->additionalRTVs.empty()) + if (arrayIndex < 0 || ppRenderTargets[i]->subresourceRTVs.empty()) { renderPass[cmd].attachments[i] = (VkImageView)ppRenderTargets[i]->RTV; } else { - assert(ppRenderTargets[i]->additionalRTVs.size() > static_cast(arrayIndex) && "Invalid rendertarget arrayIndex!"); - renderPass[cmd].attachments[i] = (VkImageView)ppRenderTargets[i]->additionalRTVs[arrayIndex]; + assert(ppRenderTargets[i]->subresourceRTVs.size() > static_cast(arrayIndex) && "Invalid rendertarget arrayIndex!"); + renderPass[cmd].attachments[i] = (VkImageView)ppRenderTargets[i]->subresourceRTVs[arrayIndex]; } renderPass[cmd].attachmentsExtents.width = ppRenderTargets[i]->desc.Width; @@ -4658,14 +4420,14 @@ namespace wiGraphics if (depthStencilTexture != nullptr) { - if (arrayIndex < 0 || depthStencilTexture->additionalDSVs.empty()) + if (arrayIndex < 0 || depthStencilTexture->subresourceDSVs.empty()) { renderPass[cmd].attachments[renderPass[cmd].attachmentCount] = (VkImageView)depthStencilTexture->DSV; } else { - assert(depthStencilTexture->additionalDSVs.size() > static_cast(arrayIndex) && "Invalid depthstencil arrayIndex!"); - renderPass[cmd].attachments[renderPass[cmd].attachmentCount] = (VkImageView)depthStencilTexture->additionalDSVs[arrayIndex]; + assert(depthStencilTexture->subresourceDSVs.size() > static_cast(arrayIndex) && "Invalid depthstencil arrayIndex!"); + renderPass[cmd].attachments[renderPass[cmd].attachmentCount] = (VkImageView)depthStencilTexture->subresourceDSVs[arrayIndex]; } renderPass[cmd].attachmentCount++; @@ -4681,14 +4443,14 @@ namespace wiGraphics { RenderPassManager::ClearRequest clear; - if (arrayIndex < 0 || pTexture->additionalRTVs.empty()) + if (arrayIndex < 0 || pTexture->subresourceRTVs.empty()) { clear.attachment = (VkImageView)pTexture->RTV; } else { - assert(pTexture->additionalRTVs.size() > static_cast(arrayIndex) && "Invalid rendertarget arrayIndex!"); - clear.attachment = (VkImageView)pTexture->additionalRTVs[arrayIndex]; + assert(pTexture->subresourceRTVs.size() > static_cast(arrayIndex) && "Invalid rendertarget arrayIndex!"); + clear.attachment = (VkImageView)pTexture->subresourceRTVs[arrayIndex]; } clear.clearValue = { ColorRGBA[0], ColorRGBA[1], ColorRGBA[2], ColorRGBA[3] }; @@ -4698,14 +4460,14 @@ namespace wiGraphics { RenderPassManager::ClearRequest clear; - if (arrayIndex < 0 || pTexture->additionalDSVs.empty()) + if (arrayIndex < 0 || pTexture->subresourceDSVs.empty()) { clear.attachment = (VkImageView)pTexture->DSV; } else { - assert(pTexture->additionalDSVs.size() > static_cast(arrayIndex) && "Invalid depthstencil arrayIndex!"); - clear.attachment = (VkImageView)pTexture->additionalDSVs[arrayIndex]; + assert(pTexture->subresourceDSVs.size() > static_cast(arrayIndex) && "Invalid depthstencil arrayIndex!"); + clear.attachment = (VkImageView)pTexture->subresourceDSVs[arrayIndex]; } clear.clearValue.depthStencil.depth = Depth; clear.clearValue.depthStencil.stencil = Stencil; diff --git a/WickedEngine/wiGraphicsDevice_Vulkan.h b/WickedEngine/wiGraphicsDevice_Vulkan.h index 318ad6edf..a37c3face 100644 --- a/WickedEngine/wiGraphicsDevice_Vulkan.h +++ b/WickedEngine/wiGraphicsDevice_Vulkan.h @@ -290,6 +290,7 @@ namespace wiGraphics HRESULT CreateQuery(const GPUQueryDesc *pDesc, GPUQuery *pQuery) override; HRESULT CreatePipelineState(const PipelineStateDesc* pDesc, PipelineState* pso) override; + int CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, UINT firstSlice, UINT sliceCount = 1, UINT firstMip = 0, UINT mipCount = 0) override; void DestroyResource(GPUResource* pResource) override; void DestroyBuffer(GPUBuffer *pBuffer) override; diff --git a/WickedEngine/wiGraphicsResource.cpp b/WickedEngine/wiGraphicsResource.cpp index f6f4de153..b592d6125 100644 --- a/WickedEngine/wiGraphicsResource.cpp +++ b/WickedEngine/wiGraphicsResource.cpp @@ -107,27 +107,6 @@ namespace wiGraphics } } - void Texture::RequestIndependentRenderTargetArraySlices(bool value) - { - independentRTVArraySlices = value; - } - void Texture::RequestIndependentRenderTargetCubemapFaces(bool value) - { - independentRTVCubemapFaces = value; - } - void Texture::RequestIndependentShaderResourceArraySlices(bool value) - { - independentSRVArraySlices = value; - } - void Texture::RequestIndependentShaderResourcesForMIPs(bool value) - { - independentSRVMIPs = value; - } - void Texture::RequestIndependentUnorderedAccessResourcesForMIPs(bool value) - { - independentUAVMIPs = value; - } - Texture1D::~Texture1D() { if (device != nullptr) diff --git a/WickedEngine/wiGraphicsResource.h b/WickedEngine/wiGraphicsResource.h index 7bb418e04..eeb73b1f5 100644 --- a/WickedEngine/wiGraphicsResource.h +++ b/WickedEngine/wiGraphicsResource.h @@ -98,11 +98,11 @@ namespace wiGraphics inline bool IsTexture() const { return type == TEXTURE_1D || type == TEXTURE_2D || type == TEXTURE_3D; } inline bool IsBuffer() const { return type == BUFFER; } - wiCPUHandle SRV = WI_NULL_HANDLE; // main resource SRV - std::vector additionalSRVs; // can be used for sub-resources if requested + wiCPUHandle SRV = WI_NULL_HANDLE; + std::vector subresourceSRVs; - wiCPUHandle UAV = WI_NULL_HANDLE; // main resource UAV - std::vector additionalUAVs; // can be used for sub-resources if requested + wiCPUHandle UAV = WI_NULL_HANDLE; + std::vector subresourceUAVs; wiCPUHandle resource = WI_NULL_HANDLE; wiCPUHandle resourceMemory = WI_NULL_HANDLE; @@ -163,25 +163,9 @@ namespace wiGraphics { TextureDesc desc; wiCPUHandle RTV = WI_NULL_HANDLE; - std::vector additionalRTVs; - bool independentRTVArraySlices = false; - bool independentRTVCubemapFaces = false; - bool independentSRVArraySlices = false; - bool independentSRVMIPs = false; - bool independentUAVMIPs = false; + std::vector subresourceRTVs; const TextureDesc& GetDesc() const { return desc; } - - // if true, then each array slice will get a unique rendertarget - void RequestIndependentRenderTargetArraySlices(bool value); - // if true, then each face of the cubemap will get a unique rendertarget - void RequestIndependentRenderTargetCubemapFaces(bool value); - // if true, then each array slice will get a unique shader resource - void RequestIndependentShaderResourceArraySlices(bool value); - // if true, then each miplevel will get unique shader resource - void RequestIndependentShaderResourcesForMIPs(bool value); - // if true, then each miplevel will get unique unordered access resource - void RequestIndependentUnorderedAccessResourcesForMIPs(bool value); }; struct Texture1D : public Texture @@ -192,7 +176,7 @@ namespace wiGraphics struct Texture2D : public Texture { wiCPUHandle DSV = WI_NULL_HANDLE; - std::vector additionalDSVs; + std::vector subresourceDSVs; virtual ~Texture2D(); }; diff --git a/WickedEngine/wiOcean.cpp b/WickedEngine/wiOcean.cpp index d350e2fce..1405c4ed7 100644 --- a/WickedEngine/wiOcean.cpp +++ b/WickedEngine/wiOcean.cpp @@ -87,7 +87,8 @@ void createBufferAndUAV(void* data, UINT byte_width, UINT byte_stride, GPUBuffer void createTextureAndViews(UINT width, UINT height, FORMAT format, Texture2D* pTex) { - // Create 2D texture + GraphicsDevice* device = wiRenderer::GetDevice(); + TextureDesc tex_desc; tex_desc.Width = width; tex_desc.Height = height; @@ -100,10 +101,16 @@ void createTextureAndViews(UINT width, UINT height, FORMAT format, Texture2D* pT tex_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS | BIND_RENDER_TARGET; tex_desc.CPUAccessFlags = 0; - pTex->RequestIndependentShaderResourcesForMIPs(true); - pTex->RequestIndependentUnorderedAccessResourcesForMIPs(true); - wiRenderer::GetDevice()->CreateTexture2D(&tex_desc, nullptr, pTex); + device->CreateTexture2D(&tex_desc, nullptr, pTex); + for (UINT i = 0; i < pTex->GetDesc().MipLevels; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(pTex, SRV, 0, 1, i, 1); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(pTex, SRV, 0, 1, i, 1); + assert(subresource_index == i); + } } diff --git a/WickedEngine/wiRenderer.cpp b/WickedEngine/wiRenderer.cpp index 005e6ee73..73cf31386 100644 --- a/WickedEngine/wiRenderer.cpp +++ b/WickedEngine/wiRenderer.cpp @@ -4936,8 +4936,7 @@ void SetShadowProps2D(int resolution, int count, int softShadowQuality) if (SHADOWCOUNT_2D > 0 && SHADOWRES_2D > 0) { - shadowMapArray_2D.RequestIndependentRenderTargetArraySlices(true); - shadowMapArray_Transparent.RequestIndependentRenderTargetArraySlices(true); + GraphicsDevice* device = GetDevice(); TextureDesc desc; desc.Width = SHADOWRES_2D; @@ -4952,11 +4951,20 @@ void SetShadowProps2D(int resolution, int count, int softShadowQuality) desc.BindFlags = BIND_DEPTH_STENCIL | BIND_SHADER_RESOURCE; desc.Format = DSFormat_small_alias; - GetDevice()->CreateTexture2D(&desc, nullptr, &shadowMapArray_2D); + device->CreateTexture2D(&desc, nullptr, &shadowMapArray_2D); desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; desc.Format = RTFormat_ldr; - GetDevice()->CreateTexture2D(&desc, nullptr, &shadowMapArray_Transparent); + device->CreateTexture2D(&desc, nullptr, &shadowMapArray_Transparent); + + for (UINT i = 0; i < desc.ArraySize; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(&shadowMapArray_2D, DSV, i, 1); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(&shadowMapArray_Transparent, RTV, i, 1); + assert(subresource_index == i); + } } } @@ -4973,8 +4981,7 @@ void SetShadowPropsCube(int resolution, int count) if (SHADOWCOUNT_CUBE > 0 && SHADOWRES_CUBE > 0) { - shadowMapArray_Cube.RequestIndependentRenderTargetArraySlices(true); - shadowMapArray_Cube.RequestIndependentRenderTargetCubemapFaces(false); + GraphicsDevice* device = GetDevice(); TextureDesc desc; desc.Width = SHADOWRES_CUBE; @@ -4988,7 +4995,14 @@ void SetShadowPropsCube(int resolution, int count) desc.BindFlags = BIND_DEPTH_STENCIL | BIND_SHADER_RESOURCE; desc.CPUAccessFlags = 0; desc.MiscFlags = RESOURCE_MISC_TEXTURECUBE; - GetDevice()->CreateTexture2D(&desc, nullptr, &shadowMapArray_Cube); + device->CreateTexture2D(&desc, nullptr, &shadowMapArray_Cube); + + for (UINT i = 0; i < desc.ArraySize; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(&shadowMapArray_Cube, DSV, i, 1); + assert(subresource_index == i); + } } } @@ -6236,16 +6250,29 @@ void RefreshEnvProbes(CommandList cmd) desc.Height = envmapRes; desc.Width = envmapRes; desc.MipLevels = envmapMIPs; - desc.MiscFlags = RESOURCE_MISC_TEXTURECUBE /*| RESOURCE_MISC_GENERATE_MIPS*/; + desc.MiscFlags = RESOURCE_MISC_TEXTURECUBE; desc.Usage = USAGE_DEFAULT; textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY] = new Texture2D; - textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY]->RequestIndependentRenderTargetArraySlices(true); - textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY]->RequestIndependentShaderResourceArraySlices(true); - textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY]->RequestIndependentShaderResourcesForMIPs(true); - textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY]->RequestIndependentUnorderedAccessResourcesForMIPs(true); HRESULT hr = device->CreateTexture2D(&desc, nullptr, (Texture2D*)textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY]); assert(SUCCEEDED(hr)); + + for (UINT i = 0; i < envmapCount; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY], RTV, i, 6); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY], SRV, i, 6); + assert(subresource_index == i); + } + for (UINT i = 0; i < textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY]->GetDesc().MipLevels; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY], SRV, 0, desc.ArraySize, i, 1); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(textures[TEXTYPE_CUBEARRAY_ENVMAPARRAY], UAV, 0, desc.ArraySize, i, 1); + assert(subresource_index == i); + } } static std::unique_ptr envrenderingDepthBuffer; @@ -6473,11 +6500,17 @@ void RefreshImpostors(CommandList cmd) desc.MiscFlags = 0; textures[TEXTYPE_2D_IMPOSTORARRAY] = new Texture2D; - textures[TEXTYPE_2D_IMPOSTORARRAY]->RequestIndependentRenderTargetArraySlices(true); HRESULT hr = device->CreateTexture2D(&desc, nullptr, (Texture2D*)textures[TEXTYPE_2D_IMPOSTORARRAY]); assert(SUCCEEDED(hr)); device->SetName(textures[TEXTYPE_2D_IMPOSTORARRAY], "ImpostorTarget"); + for (UINT i = 0; i < desc.ArraySize; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(textures[TEXTYPE_2D_IMPOSTORARRAY], RTV, i, 1); + assert(subresource_index == i); + } + desc.BindFlags = BIND_DEPTH_STENCIL; desc.ArraySize = 1; desc.Format = DSFormat_small; @@ -6647,19 +6680,33 @@ void VoxelRadiance(CommandList cmd) desc.MiscFlags = 0; textures[TEXTYPE_3D_VOXELRADIANCE] = new Texture3D; - textures[TEXTYPE_3D_VOXELRADIANCE]->RequestIndependentShaderResourcesForMIPs(true); - textures[TEXTYPE_3D_VOXELRADIANCE]->RequestIndependentUnorderedAccessResourcesForMIPs(true); HRESULT hr = device->CreateTexture3D(&desc, nullptr, (Texture3D*)textures[TEXTYPE_3D_VOXELRADIANCE]); assert(SUCCEEDED(hr)); + + for (UINT i = 0; i < decalAtlas.GetDesc().MipLevels; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(textures[TEXTYPE_3D_VOXELRADIANCE], SRV, 0, 1, i, 1); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(textures[TEXTYPE_3D_VOXELRADIANCE], UAV, 0, 1, i, 1); + assert(subresource_index == i); + } } if (voxelSceneData.secondaryBounceEnabled && textures[TEXTYPE_3D_VOXELRADIANCE_HELPER] == nullptr) { TextureDesc desc = ((Texture3D*)textures[TEXTYPE_3D_VOXELRADIANCE])->GetDesc(); textures[TEXTYPE_3D_VOXELRADIANCE_HELPER] = new Texture3D; - textures[TEXTYPE_3D_VOXELRADIANCE_HELPER]->RequestIndependentShaderResourcesForMIPs(true); - textures[TEXTYPE_3D_VOXELRADIANCE_HELPER]->RequestIndependentUnorderedAccessResourcesForMIPs(true); HRESULT hr = device->CreateTexture3D(&desc, nullptr, (Texture3D*)textures[TEXTYPE_3D_VOXELRADIANCE_HELPER]); assert(SUCCEEDED(hr)); + + for (UINT i = 0; i < decalAtlas.GetDesc().MipLevels; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(textures[TEXTYPE_3D_VOXELRADIANCE_HELPER], SRV, 0, 1, i, 1); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(textures[TEXTYPE_3D_VOXELRADIANCE_HELPER], UAV, 0, 1, i, 1); + assert(subresource_index == i); + } } if (!resourceBuffers[RBTYPE_VOXELSCENE].IsValid()) { @@ -7692,10 +7739,15 @@ void ManageDecalAtlas() desc.CPUAccessFlags = 0; desc.MiscFlags = 0; - decalAtlas.RequestIndependentUnorderedAccessResourcesForMIPs(true); - device->CreateTexture2D(&desc, nullptr, &decalAtlas); device->SetName(&decalAtlas, "decalAtlas"); + + for (UINT i = 0; i < decalAtlas.GetDesc().MipLevels; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(&decalAtlas, UAV, 0, 1, i, 1); + assert(subresource_index == i); + } } else { diff --git a/WickedEngine/wiResourceManager.cpp b/WickedEngine/wiResourceManager.cpp index bfd92016b..5f50b809f 100644 --- a/WickedEngine/wiResourceManager.cpp +++ b/WickedEngine/wiResourceManager.cpp @@ -237,6 +237,8 @@ const void* wiResourceManager::add(const wiHashString& name, Data_Type newType) if (rgb != nullptr) { + GraphicsDevice* device = wiRenderer::GetDevice(); + TextureDesc desc; desc.ArraySize = 1; desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; @@ -258,11 +260,18 @@ const void* wiResourceManager::add(const wiHashString& name, Data_Type newType) } Texture2D* image = new Texture2D; - image->RequestIndependentShaderResourcesForMIPs(true); - image->RequestIndependentUnorderedAccessResourcesForMIPs(true); - HRESULT hr = wiRenderer::GetDevice()->CreateTexture2D(&desc, InitData.data(), image); + HRESULT hr = device->CreateTexture2D(&desc, InitData.data(), image); assert(SUCCEEDED(hr)); - wiRenderer::GetDevice()->SetName(image, nameStr); + device->SetName(image, nameStr); + + for (UINT i = 0; i < image->GetDesc().MipLevels; ++i) + { + int subresource_index; + subresource_index = device->CreateSubresource(image, SRV, 0, 1, i, 1); + assert(subresource_index == i); + subresource_index = device->CreateSubresource(image, SRV, 0, 1, i, 1); + assert(subresource_index == i); + } if (image != nullptr && image->GetDesc().MipLevels > 1) { diff --git a/WickedEngine/wiVersion.cpp b/WickedEngine/wiVersion.cpp index 7306e3483..27ee36a35 100644 --- a/WickedEngine/wiVersion.cpp +++ b/WickedEngine/wiVersion.cpp @@ -9,7 +9,7 @@ namespace wiVersion // minor features, major updates const int minor = 28; // minor bug fixes, alterations, refactors, updates - const int revision = 23; + const int revision = 24; long GetVersion()