diff --git a/WickedEngine/MainComponent.cpp b/WickedEngine/MainComponent.cpp index 5e8fa232b..6627dbf8d 100644 --- a/WickedEngine/MainComponent.cpp +++ b/WickedEngine/MainComponent.cpp @@ -120,11 +120,7 @@ void MainComponent::run() } wiProfiler::GetInstance().EndRange(); // Fixed Update - // Rendering: - wiProfiler::GetInstance().BeginRange("GPU Frame", wiProfiler::DOMAIN_GPU, GRAPHICSTHREAD_IMMEDIATE); Render(); - wiProfiler::GetInstance().EndRange(GRAPHICSTHREAD_IMMEDIATE); // GPU Frame - wiProfiler::GetInstance().EndRange(); // CPU Frame @@ -157,7 +153,9 @@ void MainComponent::Render() wiLua::GetGlobal()->Render(); wiRenderer::GetDevice()->LOCK(); + wiProfiler::GetInstance().BeginRange("GPU Frame", wiProfiler::DOMAIN_GPU, GRAPHICSTHREAD_IMMEDIATE); getActiveComponent()->Render(); + wiProfiler::GetInstance().EndRange(GRAPHICSTHREAD_IMMEDIATE); // GPU Frame wiRenderer::GetDevice()->UNLOCK(); } diff --git a/WickedEngine/RendererWindow.cpp b/WickedEngine/RendererWindow.cpp index 546b8654d..eb4fb018a 100644 --- a/WickedEngine/RendererWindow.cpp +++ b/WickedEngine/RendererWindow.cpp @@ -16,7 +16,7 @@ RendererWindow::RendererWindow(Renderable3DComponent* component) wiRenderer::SetToDrawGridHelper(true); rendererWindow = new wiWindow(GUI, "Renderer Window"); - rendererWindow->SetSize(XMFLOAT2(400, 550)); + rendererWindow->SetSize(XMFLOAT2(400, 580)); rendererWindow->SetEnabled(true); GUI->AddWidget(rendererWindow); @@ -40,6 +40,15 @@ RendererWindow::RendererWindow(Renderable3DComponent* component) occlusionCullingCheckBox->SetCheck(wiRenderer::GetOcclusionCullingEnabled()); rendererWindow->AddWidget(occlusionCullingCheckBox); + voxelRadianceCheckBox = new wiCheckBox("Voxel Radiance: "); + voxelRadianceCheckBox->SetTooltip("Toggle voxel radiance computation (EXPERIMENTAL)."); + voxelRadianceCheckBox->SetPos(XMFLOAT2(x, y += step)); + voxelRadianceCheckBox->OnClick([](wiEventArgs args) { + wiRenderer::SetVoxelRadianceEnabled(args.bValue); + }); + voxelRadianceCheckBox->SetCheck(wiRenderer::GetVoxelRadianceEnabled()); + rendererWindow->AddWidget(voxelRadianceCheckBox); + partitionBoxesCheckBox = new wiCheckBox("SPTree visualizer: "); partitionBoxesCheckBox->SetTooltip("Visualize the world space partitioning tree as boxes"); partitionBoxesCheckBox->SetPos(XMFLOAT2(x, y += step)); @@ -259,6 +268,8 @@ RendererWindow::~RendererWindow() SAFE_DELETE(rendererWindow); SAFE_DELETE(vsyncCheckBox); SAFE_DELETE(vsyncCheckBox); + SAFE_DELETE(occlusionCullingCheckBox); + SAFE_DELETE(voxelRadianceCheckBox); SAFE_DELETE(partitionBoxesCheckBox); SAFE_DELETE(boneLinesCheckBox); SAFE_DELETE(wireFrameCheckBox); diff --git a/WickedEngine/RendererWindow.h b/WickedEngine/RendererWindow.h index bafe9379a..d849b43c3 100644 --- a/WickedEngine/RendererWindow.h +++ b/WickedEngine/RendererWindow.h @@ -19,6 +19,7 @@ public: wiWindow* rendererWindow; wiCheckBox* vsyncCheckBox; wiCheckBox* occlusionCullingCheckBox; + wiCheckBox* voxelRadianceCheckBox; wiCheckBox* partitionBoxesCheckBox; wiCheckBox* boneLinesCheckBox; wiCheckBox* wireFrameCheckBox; diff --git a/WickedEngine/ResourceMapping.h b/WickedEngine/ResourceMapping.h index 6f9b3f458..bc1692730 100644 --- a/WickedEngine/ResourceMapping.h +++ b/WickedEngine/ResourceMapping.h @@ -36,26 +36,28 @@ #define TEXSLOT_SHADOWARRAY_2D 12 #define TEXSLOT_SHADOWARRAY_CUBE 13 -#define TEXSLOT_ONDEMAND0 14 -#define TEXSLOT_ONDEMAND1 15 -#define TEXSLOT_ONDEMAND2 16 -#define TEXSLOT_ONDEMAND3 17 -#define TEXSLOT_ONDEMAND4 18 -#define TEXSLOT_ONDEMAND5 19 -#define TEXSLOT_ONDEMAND6 20 -#define TEXSLOT_ONDEMAND7 21 -#define TEXSLOT_ONDEMAND8 22 -#define TEXSLOT_ONDEMAND9 23 +#define TEXSLOT_VOXELRADIANCE 14 + +#define TEXSLOT_ONDEMAND0 15 +#define TEXSLOT_ONDEMAND1 16 +#define TEXSLOT_ONDEMAND2 17 +#define TEXSLOT_ONDEMAND3 18 +#define TEXSLOT_ONDEMAND4 19 +#define TEXSLOT_ONDEMAND5 20 +#define TEXSLOT_ONDEMAND6 21 +#define TEXSLOT_ONDEMAND7 22 +#define TEXSLOT_ONDEMAND8 23 +#define TEXSLOT_ONDEMAND9 24 #define TEXSLOT_ONDEMAND_COUNT (TEXSLOT_ONDEMAND9 - TEXSLOT_ONDEMAND0 + 1) -#define TEXSLOT_LIGHTGRID 24 +#define TEXSLOT_LIGHTGRID 25 #define TEXSLOT_COUNT TEXSLOT_LIGHTGRID #define SBSLOT_BONE 0 -#define SBSLOT_TILEFRUSTUMS 24 -#define SBSLOT_LIGHTINDEXLIST 25 -#define SBSLOT_LIGHTARRAY 26 +#define SBSLOT_TILEFRUSTUMS 25 +#define SBSLOT_LIGHTINDEXLIST 26 +#define SBSLOT_LIGHTARRAY 27 /////////////////////////// @@ -83,6 +85,14 @@ #define RWSTRUCTUREDBUFFER_X(name, type, slot) RWStructuredBuffer< type > name : register(u ## slot) #define RWSTRUCTUREDBUFFER(name, type, slot) RWSTRUCTUREDBUFFER_X(name, type, slot) + +#define TEXTURE1D_X(name, type, slot) Texture1D< type > name : register(t ## slot); +#define TEXTURE1D(name, type, slot) TEXTURE1D_X(name, type, slot) +#define TEXTURE1DARRAY_X(name, type, slot) Texture1DArray< type > name : register(t ## slot); +#define TEXTURE1DARRAY(name, type, slot) TEXTURE1DARRAY_X(name, type, slot) +#define RWTEXTURE1D_X(name, type, slot) RWTexture1D< type > name : register(u ## slot); +#define RWTEXTURE1D(name, type, slot) RWTEXTURE1D_X(name, type, slot) + #define TEXTURE2D_X(name, type, slot) Texture2D< type > name : register(t ## slot); #define TEXTURE2D(name, type, slot) TEXTURE2D_X(name, type, slot) #define TEXTURE2DMS_X(name, type, slot) Texture2DMS< type > name : register(t ## slot); @@ -91,10 +101,16 @@ #define TEXTURE2DARRAY(name, type, slot) TEXTURE2DARRAY_X(name, type, slot) #define RWTEXTURE2D_X(name, type, slot) RWTexture2D< type > name : register(u ## slot); #define RWTEXTURE2D(name, type, slot) RWTEXTURE2D_X(name, type, slot) + #define TEXTURECUBE_X(name, type, slot) TextureCube< type > name : register(t ## slot); #define TEXTURECUBE(name, type, slot) TEXTURECUBE_X(name, type, slot) #define TEXTURECUBEARRAY_X(name, type, slot) TextureCubeArray< type > name : register(t ## slot); #define TEXTURECUBEARRAY(name, type, slot) TEXTURECUBEARRAY_X(name, type, slot) +#define TEXTURE3D_X(name, type, slot) Texture3D< type > name : register(t ## slot); +#define TEXTURE3D(name, type, slot) TEXTURE3D_X(name, type, slot) +#define RWTEXTURE3D_X(name, type, slot) RWTexture3D< type > name : register(u ## slot); +#define RWTEXTURE3D(name, type, slot) RWTEXTURE3D_X(name, type, slot) + #endif // _RESOURCEBUFFER_MAPPING_H_ diff --git a/WickedEngine/WickedEngine_SHADERS.vcxproj b/WickedEngine/WickedEngine_SHADERS.vcxproj index f9882f1b9..6e032f310 100644 --- a/WickedEngine/WickedEngine_SHADERS.vcxproj +++ b/WickedEngine/WickedEngine_SHADERS.vcxproj @@ -839,6 +839,16 @@ Pixel Pixel + + Compute + 4.0 + Compute + 4.0 + Compute + 5.0 + Compute + 4.0 + Vertex Vertex diff --git a/WickedEngine/WickedEngine_SHADERS.vcxproj.filters b/WickedEngine/WickedEngine_SHADERS.vcxproj.filters index e3fdbcd5e..b0e8010ee 100644 --- a/WickedEngine/WickedEngine_SHADERS.vcxproj.filters +++ b/WickedEngine/WickedEngine_SHADERS.vcxproj.filters @@ -510,6 +510,9 @@ PS + + CS + diff --git a/WickedEngine/globals.hlsli b/WickedEngine/globals.hlsli index 0f0937dd5..cc364feeb 100644 --- a/WickedEngine/globals.hlsli +++ b/WickedEngine/globals.hlsli @@ -15,9 +15,11 @@ TEXTURECUBE(texture_env_global, float4, TEXSLOT_ENV_GLOBAL) TEXTURECUBE(texture_env0, float4, TEXSLOT_ENV0) TEXTURECUBE(texture_env1, float4, TEXSLOT_ENV1) TEXTURECUBE(texture_env2, float4, TEXSLOT_ENV2) +TEXTURE2D(texture_decalatlas, float4, TEXSLOT_DECALATLAS) TEXTURE2DARRAY(texture_shadowarray_2d, float, TEXSLOT_SHADOWARRAY_2D) TEXTURECUBEARRAY(texture_shadowarray_cube, float, TEXSLOT_SHADOWARRAY_CUBE) -TEXTURE2D(texture_decalatlas, float4, TEXSLOT_DECALATLAS) +TEXTURE3D(texture_voxelradiance, float4, TEXSLOT_VOXELRADIANCE) + TEXTURE2D(texture_0, float4, TEXSLOT_ONDEMAND0) TEXTURE2D(texture_1, float4, TEXSLOT_ONDEMAND1) TEXTURE2D(texture_2, float4, TEXSLOT_ONDEMAND2) @@ -48,7 +50,7 @@ CBUFFER(WorldCB, CBSLOT_RENDERER_WORLD) float3 g_xWorld_Ambient; float xPadding2_WorldCB; float3 g_xWorld_Fog; float xPadding3_WorldCB; float2 g_xWorld_ScreenWidthHeight; - float xPadding4_WorldCB; + float g_xWorld_VoxelRadianceScale; float xPadding5_WorldCB; }; CBUFFER(FrameCB, CBSLOT_RENDERER_FRAME) diff --git a/WickedEngine/models/Sponza/sponza.wimf b/WickedEngine/models/Sponza/sponza.wimf index 96c544fd0..79a7e545e 100644 Binary files a/WickedEngine/models/Sponza/sponza.wimf and b/WickedEngine/models/Sponza/sponza.wimf differ diff --git a/WickedEngine/objectHF.hlsli b/WickedEngine/objectHF.hlsli index 967094d7d..934487255 100644 --- a/WickedEngine/objectHF.hlsli +++ b/WickedEngine/objectHF.hlsli @@ -110,6 +110,24 @@ inline void Refraction(in float2 ScreenCoord, in float2 normal2D, in float3 bump color.a = 1; } +inline void VoxelRadiance(in float3 P, inout float ao) +{ + [branch] + if (g_xWorld_VoxelRadianceScale > 0) + { + float3 dim; + float mips; + texture_voxelradiance.GetDimensions(0, dim.x, dim.y, dim.z, mips); + float3 diff = (P - floor(g_xCamera_CamPos)) * g_xWorld_VoxelRadianceScale; + float3 uvw = diff * float3(0.5f, -0.5f, 0.5f) + 0.5f; + float4 radiance = texture_voxelradiance.SampleLevel(sampler_linear_clamp, uvw, 0); + diff = abs(diff); + float blend = pow(saturate(max(diff.x, max(diff.y, diff.z))), 4); + + ao *= lerp(radiance.a, 1, blend); + } +} + inline void DirectionalLight(in float3 N, in float3 V, in float3 P, in float3 f0, in float3 albedo, in float roughness, inout float3 diffuse, out float3 specular) { @@ -266,6 +284,9 @@ inline void TiledLighting(in float2 pixel, in float3 N, in float3 V, in float3 P #define OBJECT_PS_LIGHT_TILED \ TiledLighting(pixel, N, V, P, f0, albedo, roughness, diffuse, specular); +#define OBJECT_PS_VOXELRADIANCE \ + VoxelRadiance(P, ao); + #define OBJECT_PS_LIGHT_END \ color.rgb = lerp(1, GetAmbientColor() * ao + diffuse, opacity) * albedo + specular; diff --git a/WickedEngine/objectPS_tiledforward.hlsl b/WickedEngine/objectPS_tiledforward.hlsl index 6d163d24a..4ce85e8e4 100644 --- a/WickedEngine/objectPS_tiledforward.hlsl +++ b/WickedEngine/objectPS_tiledforward.hlsl @@ -17,6 +17,8 @@ float4 main(PixelInputType input) : SV_TARGET OBJECT_PS_ENVIRONMENTREFLECTIONS + OBJECT_PS_VOXELRADIANCE + OBJECT_PS_LIGHT_END OBJECT_PS_EMISSIVE diff --git a/WickedEngine/objectPS_tiledforward_normalmap.hlsl b/WickedEngine/objectPS_tiledforward_normalmap.hlsl index 241da2d18..687111a8d 100644 --- a/WickedEngine/objectPS_tiledforward_normalmap.hlsl +++ b/WickedEngine/objectPS_tiledforward_normalmap.hlsl @@ -21,6 +21,8 @@ float4 main(PixelInputType input) : SV_TARGET OBJECT_PS_ENVIRONMENTREFLECTIONS + OBJECT_PS_VOXELRADIANCE + OBJECT_PS_LIGHT_END OBJECT_PS_EMISSIVE diff --git a/WickedEngine/objectPS_tiledforward_normalmap_planarreflection.hlsl b/WickedEngine/objectPS_tiledforward_normalmap_planarreflection.hlsl index c5a8ef39f..06e745d50 100644 --- a/WickedEngine/objectPS_tiledforward_normalmap_planarreflection.hlsl +++ b/WickedEngine/objectPS_tiledforward_normalmap_planarreflection.hlsl @@ -21,6 +21,8 @@ float4 main(PixelInputType input) : SV_TARGET OBJECT_PS_PLANARREFLECTIONS + OBJECT_PS_VOXELRADIANCE + OBJECT_PS_LIGHT_END OBJECT_PS_EMISSIVE diff --git a/WickedEngine/objectPS_tiledforward_normalmap_pom.hlsl b/WickedEngine/objectPS_tiledforward_normalmap_pom.hlsl index 624186b29..57c1e1902 100644 --- a/WickedEngine/objectPS_tiledforward_normalmap_pom.hlsl +++ b/WickedEngine/objectPS_tiledforward_normalmap_pom.hlsl @@ -23,6 +23,8 @@ float4 main(PixelInputType input) : SV_TARGET OBJECT_PS_ENVIRONMENTREFLECTIONS + OBJECT_PS_VOXELRADIANCE + OBJECT_PS_LIGHT_END OBJECT_PS_EMISSIVE diff --git a/WickedEngine/objectPS_tiledforward_planarreflection.hlsl b/WickedEngine/objectPS_tiledforward_planarreflection.hlsl index 1587b3a29..37f5ebbb6 100644 --- a/WickedEngine/objectPS_tiledforward_planarreflection.hlsl +++ b/WickedEngine/objectPS_tiledforward_planarreflection.hlsl @@ -17,6 +17,8 @@ float4 main(PixelInputType input) : SV_TARGET OBJECT_PS_PLANARREFLECTIONS + OBJECT_PS_VOXELRADIANCE + OBJECT_PS_LIGHT_END OBJECT_PS_EMISSIVE diff --git a/WickedEngine/objectPS_tiledforward_pom.hlsl b/WickedEngine/objectPS_tiledforward_pom.hlsl index cec64ae4a..4c6af1621 100644 --- a/WickedEngine/objectPS_tiledforward_pom.hlsl +++ b/WickedEngine/objectPS_tiledforward_pom.hlsl @@ -21,6 +21,8 @@ float4 main(PixelInputType input) : SV_TARGET OBJECT_PS_ENVIRONMENTREFLECTIONS + OBJECT_PS_VOXELRADIANCE + OBJECT_PS_LIGHT_END OBJECT_PS_EMISSIVE diff --git a/WickedEngine/voxelRadianceCS.hlsl b/WickedEngine/voxelRadianceCS.hlsl new file mode 100644 index 000000000..32d1ce54b --- /dev/null +++ b/WickedEngine/voxelRadianceCS.hlsl @@ -0,0 +1,29 @@ +#include "globals.hlsli" + +TEXTURE3D(input, float4, 0); +RWTEXTURE3D(output, float4, 0); + +groupshared float4 accumulation[4 * 4 * 4]; + +[numthreads(4, 4, 4)] +void main( uint3 DTid : SV_DispatchThreadID, uint GroupIndex : SV_GroupIndex ) +{ + // TODO! + + float4 current = input[DTid]; + + //output[DTid] = 1 - current.aaaa; + + accumulation[GroupIndex] = current; + + GroupMemoryBarrierWithGroupSync(); + + float4 avg = 0; + for (uint i = 0; i < 4 * 4 * 4; ++i) + { + avg += accumulation[i]; + } + avg /= 4 * 4 * 4; + + output[DTid] = 1 - avg.aaaa; +} \ No newline at end of file diff --git a/WickedEngine/wiEnums.h b/WickedEngine/wiEnums.h index e9712815e..9de00fd00 100644 --- a/WickedEngine/wiEnums.h +++ b/WickedEngine/wiEnums.h @@ -92,6 +92,8 @@ enum TEXTYPES TEXTYPE_2D_LIGHTGRID_OPAQUE, TEXTYPE_2D_LIGHTGRID_TRANSPARENT, TEXTYPE_2D_DEBUGUAV, + TEXTYPE_3D_VOXELSCENE, + TEXTYPE_3D_VOXELRADIANCE, TEXTYPE_LAST }; @@ -216,6 +218,7 @@ enum CSTYPES CSTYPE_TILEDLIGHTCULLING, CSTYPE_TILEDLIGHTCULLING_DEBUG, CSTYPE_RESOLVEMSAADEPTHSTENCIL, + CSTYPE_VOXELRADIANCE, CSTYPE_LAST }; diff --git a/WickedEngine/wiGraphicsDescriptors.h b/WickedEngine/wiGraphicsDescriptors.h index b92b0a845..1a2c0c409 100644 --- a/WickedEngine/wiGraphicsDescriptors.h +++ b/WickedEngine/wiGraphicsDescriptors.h @@ -355,6 +355,17 @@ namespace wiGraphicsTypes UINT Count; UINT Quality; }; + struct Texture1DDesc + { + UINT Width; + UINT MipLevels; + UINT ArraySize; + FORMAT Format; + USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; + }; struct Texture2DDesc { UINT Width; @@ -368,6 +379,18 @@ namespace wiGraphicsTypes UINT CPUAccessFlags; UINT MiscFlags; }; + struct Texture3DDesc + { + UINT Width; + UINT Height; + UINT Depth; + UINT MipLevels; + FORMAT Format; + USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; + }; struct SamplerDesc { FILTER Filter; diff --git a/WickedEngine/wiGraphicsDevice.h b/WickedEngine/wiGraphicsDevice.h index 1eada192b..49c1d61c4 100644 --- a/WickedEngine/wiGraphicsDevice.h +++ b/WickedEngine/wiGraphicsDevice.h @@ -23,12 +23,9 @@ namespace wiGraphicsTypes GraphicsDevice() :FRAMECOUNT(0), VSYNC(true), SCREENWIDTH(0), SCREENHEIGHT(0), FULLSCREEN(false) {} virtual HRESULT CreateBuffer(const GPUBufferDesc *pDesc, const SubresourceData* pInitialData, GPUBuffer *ppBuffer) = 0; - virtual HRESULT CreateTexture1D() = 0; + virtual HRESULT CreateTexture1D(const Texture1DDesc* pDesc, const SubresourceData *pInitialData, Texture1D **ppTexture1D) = 0; virtual HRESULT CreateTexture2D(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, Texture2D **ppTexture2D) = 0; - virtual HRESULT CreateTexture3D() = 0; - virtual HRESULT CreateShaderResourceView(Texture2D* pTexture) = 0; - virtual HRESULT CreateRenderTargetView(Texture2D* pTexture) = 0; - virtual HRESULT CreateDepthStencilView(Texture2D* pTexture) = 0; + virtual HRESULT CreateTexture3D(const Texture3DDesc* pDesc, const SubresourceData *pInitialData, Texture3D **ppTexture3D) = 0; virtual HRESULT CreateInputLayout(const VertexLayoutDesc *pInputElementDescs, UINT NumElements, const void *pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, VertexLayout *pInputLayout) = 0; virtual HRESULT CreateVertexShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage* pClassLinkage, VertexShader *pVertexShader) = 0; @@ -82,8 +79,8 @@ namespace wiGraphicsTypes ///////////////Thread-sensitive//////////////////////// virtual void BindViewports(UINT NumViewports, const ViewPort *pViewports, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; - virtual void BindRenderTargets(UINT NumViews, Texture2D* const *ppRenderTargetViews, Texture2D* depthStencilTexture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, UINT arrayIndex = 0) = 0; - virtual void ClearRenderTarget(Texture2D* pTexture, const FLOAT ColorRGBA[4], GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, UINT arrayIndex = 0) = 0; + virtual void BindRenderTargets(UINT NumViews, Texture* const *ppRenderTargets, Texture2D* depthStencilTexture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, UINT arrayIndex = 0) = 0; + virtual void ClearRenderTarget(Texture* pTexture, const FLOAT ColorRGBA[4], GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, UINT arrayIndex = 0) = 0; virtual void ClearDepthStencil(Texture2D* pTexture, UINT ClearFlags, FLOAT Depth, UINT8 Stencil, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, UINT arrayIndex = 0) = 0; virtual void BindResourcePS(const GPUResource* resource, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; virtual void BindResourceVS(const GPUResource* resource, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) = 0; diff --git a/WickedEngine/wiGraphicsDevice_DX11.cpp b/WickedEngine/wiGraphicsDevice_DX11.cpp index 7e6a4a119..8b1d665aa 100644 --- a/WickedEngine/wiGraphicsDevice_DX11.cpp +++ b/WickedEngine/wiGraphicsDevice_DX11.cpp @@ -820,6 +820,20 @@ inline DXGI_FORMAT _ConvertFormat(FORMAT value) return DXGI_FORMAT_UNKNOWN; } +inline D3D11_TEXTURE1D_DESC _ConvertTexture1DDesc(const Texture1DDesc* pDesc) +{ + D3D11_TEXTURE1D_DESC desc; + desc.Width = pDesc->Width; + desc.MipLevels = pDesc->MipLevels; + desc.ArraySize = pDesc->ArraySize; + desc.Format = _ConvertFormat(pDesc->Format); + desc.Usage = _ConvertUsage(pDesc->Usage); + desc.BindFlags = _ParseBindFlags(pDesc->BindFlags); + desc.CPUAccessFlags = _ParseCPUAccessFlags(pDesc->CPUAccessFlags); + desc.MiscFlags = _ParseResourceMiscFlags(pDesc->MiscFlags); + + return desc; +} inline D3D11_TEXTURE2D_DESC _ConvertTexture2DDesc(const Texture2DDesc* pDesc) { D3D11_TEXTURE2D_DESC desc; @@ -837,6 +851,21 @@ inline D3D11_TEXTURE2D_DESC _ConvertTexture2DDesc(const Texture2DDesc* pDesc) return desc; } +inline D3D11_TEXTURE3D_DESC _ConvertTexture3DDesc(const Texture3DDesc* pDesc) +{ + D3D11_TEXTURE3D_DESC desc; + desc.Width = pDesc->Width; + desc.Height = pDesc->Height; + desc.Depth = pDesc->Depth; + desc.MipLevels = pDesc->MipLevels; + desc.Format = _ConvertFormat(pDesc->Format); + desc.Usage = _ConvertUsage(pDesc->Usage); + desc.BindFlags = _ParseBindFlags(pDesc->BindFlags); + desc.CPUAccessFlags = _ParseCPUAccessFlags(pDesc->CPUAccessFlags); + desc.MiscFlags = _ParseResourceMiscFlags(pDesc->MiscFlags); + + return desc; +} inline D3D11_SUBRESOURCE_DATA* _ConvertSubresourceData(const SubresourceData* pInitialData) { if (pInitialData == nullptr) @@ -1289,23 +1318,52 @@ inline USAGE _ConvertUsage_Inv(D3D11_USAGE value) return USAGE_DEFAULT; } -inline Texture2DDesc _ConvertTexture2DDesc_Inv(const D3D11_TEXTURE2D_DESC* pDesc) - { - Texture2DDesc desc; - desc.Width = pDesc->Width; - desc.Height = pDesc->Height; - desc.MipLevels = pDesc->MipLevels; - desc.ArraySize = pDesc->ArraySize; - desc.Format = _ConvertFormat_Inv(pDesc->Format); - desc.SampleDesc.Count = pDesc->SampleDesc.Count; - desc.SampleDesc.Quality = pDesc->SampleDesc.Quality; - desc.Usage = _ConvertUsage_Inv(pDesc->Usage); - desc.BindFlags = _ParseBindFlags_Inv(pDesc->BindFlags); - desc.CPUAccessFlags = _ParseCPUAccessFlags_Inv(pDesc->CPUAccessFlags); - desc.MiscFlags = _ParseResourceMiscFlags_Inv(pDesc->MiscFlags); +inline Texture1DDesc _ConvertTexture1DDesc_Inv(const D3D11_TEXTURE1D_DESC* pDesc) +{ + Texture1DDesc desc; + desc.Width = pDesc->Width; + desc.MipLevels = pDesc->MipLevels; + desc.ArraySize = pDesc->ArraySize; + desc.Format = _ConvertFormat_Inv(pDesc->Format); + desc.Usage = _ConvertUsage_Inv(pDesc->Usage); + desc.BindFlags = _ParseBindFlags_Inv(pDesc->BindFlags); + desc.CPUAccessFlags = _ParseCPUAccessFlags_Inv(pDesc->CPUAccessFlags); + desc.MiscFlags = _ParseResourceMiscFlags_Inv(pDesc->MiscFlags); - return desc; - } + return desc; +} +inline Texture2DDesc _ConvertTexture2DDesc_Inv(const D3D11_TEXTURE2D_DESC* pDesc) +{ + Texture2DDesc desc; + desc.Width = pDesc->Width; + desc.Height = pDesc->Height; + desc.MipLevels = pDesc->MipLevels; + desc.ArraySize = pDesc->ArraySize; + desc.Format = _ConvertFormat_Inv(pDesc->Format); + desc.SampleDesc.Count = pDesc->SampleDesc.Count; + desc.SampleDesc.Quality = pDesc->SampleDesc.Quality; + desc.Usage = _ConvertUsage_Inv(pDesc->Usage); + desc.BindFlags = _ParseBindFlags_Inv(pDesc->BindFlags); + desc.CPUAccessFlags = _ParseCPUAccessFlags_Inv(pDesc->CPUAccessFlags); + desc.MiscFlags = _ParseResourceMiscFlags_Inv(pDesc->MiscFlags); + + return desc; +} +inline Texture3DDesc _ConvertTexture3DDesc_Inv(const D3D11_TEXTURE3D_DESC* pDesc) +{ + Texture3DDesc desc; + desc.Width = pDesc->Width; + desc.Height = pDesc->Height; + desc.Depth = pDesc->Depth; + desc.MipLevels = pDesc->MipLevels; + desc.Format = _ConvertFormat_Inv(pDesc->Format); + desc.Usage = _ConvertUsage_Inv(pDesc->Usage); + desc.BindFlags = _ParseBindFlags_Inv(pDesc->BindFlags); + desc.CPUAccessFlags = _ParseCPUAccessFlags_Inv(pDesc->CPUAccessFlags); + desc.MiscFlags = _ParseResourceMiscFlags_Inv(pDesc->MiscFlags); + + return desc; +} // Local Helpers: @@ -1595,10 +1653,41 @@ HRESULT GraphicsDevice_DX11::CreateBuffer(const GPUBufferDesc *pDesc, const Subr return hr; } -HRESULT GraphicsDevice_DX11::CreateTexture1D() +HRESULT GraphicsDevice_DX11::CreateTexture1D(const Texture1DDesc* pDesc, const SubresourceData *pInitialData, Texture1D **ppTexture1D) { - // TODO - return E_FAIL; + if ((*ppTexture1D) == nullptr) + { + (*ppTexture1D) = new Texture1D; + } + (*ppTexture1D)->desc = *pDesc; + + D3D11_TEXTURE1D_DESC desc = _ConvertTexture1DDesc(&(*ppTexture1D)->desc); + D3D11_SUBRESOURCE_DATA* data = _ConvertSubresourceData(pInitialData); + + HRESULT hr = S_OK; + + hr = device->CreateTexture1D(&desc, data, &((*ppTexture1D)->texture1D_DX11)); + assert(SUCCEEDED(hr) && "Texture1D creation failed!"); + if (FAILED(hr)) + return hr; + + CreateShaderResourceView(*ppTexture1D); + + if (desc.BindFlags & D3D11_BIND_UNORDERED_ACCESS) + { + assert((*ppTexture1D)->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((*ppTexture1D)->texture1D_DX11, &uav_desc, &(*ppTexture1D)->unorderedAccessView_DX11); + + assert(SUCCEEDED(hr) && "UnorderedAccessView of the Texture1D could not be created!"); + } + + return hr; } HRESULT GraphicsDevice_DX11::CreateTexture2D(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, Texture2D **ppTexture2D) { @@ -1637,6 +1726,8 @@ HRESULT GraphicsDevice_DX11::CreateTexture2D(const Texture2DDesc* pDesc, const S if (desc.BindFlags & D3D11_BIND_UNORDERED_ACCESS) { + assert((*ppTexture2D)->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_TEXTURE2D; @@ -1649,10 +1740,81 @@ HRESULT GraphicsDevice_DX11::CreateTexture2D(const Texture2DDesc* pDesc, const S return hr; } -HRESULT GraphicsDevice_DX11::CreateTexture3D() +HRESULT GraphicsDevice_DX11::CreateTexture3D(const Texture3DDesc* pDesc, const SubresourceData *pInitialData, Texture3D **ppTexture3D) { - // TODO - return E_FAIL; + if ((*ppTexture3D) == nullptr) + { + (*ppTexture3D) = new Texture3D; + } + (*ppTexture3D)->desc = *pDesc; + + D3D11_TEXTURE3D_DESC desc = _ConvertTexture3DDesc(&(*ppTexture3D)->desc); + D3D11_SUBRESOURCE_DATA* data = _ConvertSubresourceData(pInitialData); + + HRESULT hr = S_OK; + + hr = device->CreateTexture3D(&desc, data, &((*ppTexture3D)->texture3D_DX11)); + assert(SUCCEEDED(hr) && "Texture3D creation failed!"); + if (FAILED(hr)) + return hr; + + CreateShaderResourceView(*ppTexture3D); + CreateRenderTargetView(*ppTexture3D); + + + 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.MipSlice = 0; + uav_desc.Texture3D.FirstWSlice = 0; + uav_desc.Texture3D.WSize = desc.Depth; + + hr = device->CreateUnorderedAccessView((*ppTexture3D)->texture3D_DX11, &uav_desc, &(*ppTexture3D)->unorderedAccessView_DX11); + + assert(SUCCEEDED(hr) && "UnorderedAccessView of the Texture2D could not be created!"); + } + + return hr; +} +HRESULT GraphicsDevice_DX11::CreateShaderResourceView(Texture1D* pTexture) +{ + if (pTexture->shaderResourceView_DX11 != nullptr) + { + return E_FAIL; + } + + HRESULT hr = E_FAIL; + if (pTexture->desc.BindFlags & D3D11_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(pTexture->texture1D_DX11, &shaderResourceViewDesc, &pTexture->shaderResourceView_DX11); + + assert(SUCCEEDED(hr) && "ShaderResourceView Creation failed!"); + } + + return hr; } HRESULT GraphicsDevice_DX11::CreateShaderResourceView(Texture2D* pTexture) { @@ -1745,6 +1907,31 @@ HRESULT GraphicsDevice_DX11::CreateShaderResourceView(Texture2D* pTexture) return hr; } +HRESULT GraphicsDevice_DX11::CreateShaderResourceView(Texture3D* pTexture) +{ + if (pTexture->shaderResourceView_DX11 != nullptr) + { + return E_FAIL; + } + + HRESULT hr = E_FAIL; + if (pTexture->desc.BindFlags & D3D11_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; + shaderResourceViewDesc.Texture3D.MostDetailedMip = 0; //from most detailed... + shaderResourceViewDesc.Texture3D.MipLevels = -1; //...to least detailed + + hr = device->CreateShaderResourceView(pTexture->texture3D_DX11, &shaderResourceViewDesc, &pTexture->shaderResourceView_DX11); + + assert(SUCCEEDED(hr) && "ShaderResourceView Creation failed!"); + } + + return hr; +} HRESULT GraphicsDevice_DX11::CreateRenderTargetView(Texture2D* pTexture) { if (!pTexture->renderTargetViews_DX11.empty()) @@ -1876,6 +2063,50 @@ HRESULT GraphicsDevice_DX11::CreateRenderTargetView(Texture2D* pTexture) return hr; } +HRESULT GraphicsDevice_DX11::CreateRenderTargetView(Texture3D* pTexture) +{ + if (!pTexture->renderTargetViews_DX11.empty()) + { + return E_FAIL; + } + + HRESULT hr = E_FAIL; + if (pTexture->desc.BindFlags & D3D11_BIND_RENDER_TARGET) + { + + D3D11_RENDER_TARGET_VIEW_DESC renderTargetViewDesc; + ZeroMemory(&renderTargetViewDesc, sizeof(renderTargetViewDesc)); + renderTargetViewDesc.Format = _ConvertFormat(pTexture->desc.Format); + + if (pTexture->independentRTVArraySlices) + { + 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->renderTargetViews_DX11.push_back(nullptr); + hr = device->CreateRenderTargetView(pTexture->texture3D_DX11, &renderTargetViewDesc, &pTexture->renderTargetViews_DX11[i]); + } + } + else + { + renderTargetViewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; + renderTargetViewDesc.Texture3D.MipSlice = 0; + renderTargetViewDesc.Texture3D.FirstWSlice = 0; + renderTargetViewDesc.Texture3D.WSize = pTexture->GetDesc().Depth; + + pTexture->renderTargetViews_DX11.push_back(nullptr); + hr = device->CreateRenderTargetView(pTexture->texture3D_DX11, &renderTargetViewDesc, &pTexture->renderTargetViews_DX11[0]); + } + + assert(SUCCEEDED(hr) && "RenderTargetView Creation failed!"); + } + + return hr; +} HRESULT GraphicsDevice_DX11::CreateDepthStencilView(Texture2D* pTexture) { if (!pTexture->depthStencilViews_DX11.empty()) @@ -2279,20 +2510,20 @@ void GraphicsDevice_DX11::BindViewports(UINT NumViewports, const ViewPort *pView deviceContexts[threadID]->RSSetViewports(NumViewports, pd3dViewPorts); SAFE_DELETE_ARRAY(pd3dViewPorts); } -void GraphicsDevice_DX11::BindRenderTargets(UINT NumViews, Texture2D* const *ppRenderTargetViews, Texture2D* depthStencilTexture, GRAPHICSTHREAD threadID, UINT arrayIndex) +void GraphicsDevice_DX11::BindRenderTargets(UINT NumViews, Texture* const *ppRenderTargets, Texture2D* depthStencilTexture, GRAPHICSTHREAD threadID, UINT arrayIndex) { ID3D11RenderTargetView* renderTargetViews[8]; ZeroMemory(renderTargetViews, sizeof(renderTargetViews)); for (UINT i = 0; i < min(NumViews, 8); ++i) { - assert(ppRenderTargetViews[i]->renderTargetViews_DX11.size() > arrayIndex && "Invalid rendertarget arrayIndex!"); - renderTargetViews[i] = ppRenderTargetViews[i]->renderTargetViews_DX11[arrayIndex]; + assert(ppRenderTargets[i]->renderTargetViews_DX11.size() > arrayIndex && "Invalid rendertarget arrayIndex!"); + renderTargetViews[i] = ppRenderTargets[i]->renderTargetViews_DX11[arrayIndex]; } assert(depthStencilTexture == nullptr || depthStencilTexture->depthStencilViews_DX11.size() > arrayIndex && "Invalid depthstencil arrayIndex!"); ID3D11DepthStencilView* depthStencilView = (depthStencilTexture == nullptr ? nullptr : depthStencilTexture->depthStencilViews_DX11[arrayIndex]); deviceContexts[threadID]->OMSetRenderTargets(NumViews, renderTargetViews, depthStencilView); } -void GraphicsDevice_DX11::ClearRenderTarget(Texture2D* pTexture, const FLOAT ColorRGBA[4], GRAPHICSTHREAD threadID, UINT arrayIndex) +void GraphicsDevice_DX11::ClearRenderTarget(Texture* pTexture, const FLOAT ColorRGBA[4], GRAPHICSTHREAD threadID, UINT arrayIndex) { assert(pTexture->renderTargetViews_DX11.size() > arrayIndex && "Invalid rendertarget arrayIndex!"); deviceContexts[threadID]->ClearRenderTargetView(pTexture->renderTargetViews_DX11[arrayIndex], ColorRGBA); diff --git a/WickedEngine/wiGraphicsDevice_DX11.h b/WickedEngine/wiGraphicsDevice_DX11.h index c5030e650..672cf0ee2 100644 --- a/WickedEngine/wiGraphicsDevice_DX11.h +++ b/WickedEngine/wiGraphicsDevice_DX11.h @@ -38,12 +38,9 @@ namespace wiGraphicsTypes ~GraphicsDevice_DX11(); virtual HRESULT CreateBuffer(const GPUBufferDesc *pDesc, const SubresourceData* pInitialData, GPUBuffer *ppBuffer) override; - virtual HRESULT CreateTexture1D() override; + virtual HRESULT CreateTexture1D(const Texture1DDesc* pDesc, const SubresourceData *pInitialData, Texture1D **ppTexture1D) override; virtual HRESULT CreateTexture2D(const Texture2DDesc* pDesc, const SubresourceData *pInitialData, Texture2D **ppTexture2D) override; - virtual HRESULT CreateTexture3D() override; - virtual HRESULT CreateShaderResourceView(Texture2D* pTexture) override; - virtual HRESULT CreateRenderTargetView(Texture2D* pTexture) override; - virtual HRESULT CreateDepthStencilView(Texture2D* pTexture) override; + virtual HRESULT CreateTexture3D(const Texture3DDesc* pDesc, const SubresourceData *pInitialData, Texture3D **ppTexture3D) override; virtual HRESULT CreateInputLayout(const VertexLayoutDesc *pInputElementDescs, UINT NumElements, const void *pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, VertexLayout *pInputLayout) override; virtual HRESULT CreateVertexShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ClassLinkage* pClassLinkage, VertexShader *pVertexShader) override; @@ -75,8 +72,8 @@ namespace wiGraphicsTypes ///////////////Thread-sensitive//////////////////////// virtual void BindViewports(UINT NumViewports, const ViewPort *pViewports, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) override; - virtual void BindRenderTargets(UINT NumViews, Texture2D* const *ppRenderTargetViews, Texture2D* depthStencilTexture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, UINT arrayIndex = 0) override; - virtual void ClearRenderTarget(Texture2D* pTexture, const FLOAT ColorRGBA[4], GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, UINT arrayIndex = 0) override; + virtual void BindRenderTargets(UINT NumViews, Texture* const *ppRenderTargets, Texture2D* depthStencilTexture, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, UINT arrayIndex = 0) override; + virtual void ClearRenderTarget(Texture* pTexture, const FLOAT ColorRGBA[4], GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, UINT arrayIndex = 0) override; virtual void ClearDepthStencil(Texture2D* pTexture, UINT ClearFlags, FLOAT Depth, UINT8 Stencil, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE, UINT arrayIndex = 0) override; virtual void BindResourcePS(const GPUResource* resource, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) override; virtual void BindResourceVS(const GPUResource* resource, int slot, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) override; @@ -139,6 +136,14 @@ namespace wiGraphicsTypes virtual void EventBegin(const string& name, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) override; virtual void EventEnd(GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) override; virtual void SetMarker(const string& name, GRAPHICSTHREAD threadID = GRAPHICSTHREAD_IMMEDIATE) 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/wiGraphicsResource.cpp b/WickedEngine/wiGraphicsResource.cpp index 3a0e52795..b25fbed87 100644 --- a/WickedEngine/wiGraphicsResource.cpp +++ b/WickedEngine/wiGraphicsResource.cpp @@ -160,10 +160,6 @@ namespace wiGraphicsTypes { SAFE_RELEASE(x); } - for (auto& x : depthStencilViews_DX11) - { - SAFE_RELEASE(x); - } } void Texture::RequestIndepententRenderTargetArraySlices(bool value) { @@ -182,6 +178,15 @@ namespace wiGraphicsTypes return independentRTVCubemapFaces; } + Texture1D::Texture1D() :Texture() + { + SAFE_INIT(texture1D_DX11); + } + Texture1D::~Texture1D() + { + SAFE_RELEASE(texture1D_DX11); + } + Texture2D::Texture2D() :Texture() { SAFE_INIT(texture2D_DX11); @@ -189,6 +194,19 @@ namespace wiGraphicsTypes Texture2D::~Texture2D() { SAFE_RELEASE(texture2D_DX11); + for (auto& x : depthStencilViews_DX11) + { + SAFE_RELEASE(x); + } + } + + Texture3D::Texture3D() :Texture() + { + SAFE_INIT(texture3D_DX11); + } + Texture3D::~Texture3D() + { + SAFE_RELEASE(texture3D_DX11); } GPUQuery::GPUQuery() diff --git a/WickedEngine/wiGraphicsResource.h b/WickedEngine/wiGraphicsResource.h index 1eb1cc78a..353a0a755 100644 --- a/WickedEngine/wiGraphicsResource.h +++ b/WickedEngine/wiGraphicsResource.h @@ -21,7 +21,9 @@ interface ID3D11RasterizerState; interface ID3D11ClassLinkage; interface ID3D11RenderTargetView; interface ID3D11DepthStencilView; +interface ID3D11Texture1D; interface ID3D11Texture2D; +interface ID3D11Texture3D; interface ID3D11Query; interface ID3D11Predicate; @@ -230,7 +232,6 @@ namespace wiGraphicsTypes friend class GraphicsDevice_DX11; private: vector renderTargetViews_DX11; - vector depthStencilViews_DX11; bool independentRTVArraySlices; bool independentRTVCubemapFaces; public: @@ -245,10 +246,24 @@ namespace wiGraphicsTypes bool IsIndepententRenderTargetCubemapFaces(); }; + class Texture1D : public Texture + { + friend class GraphicsDevice_DX11; + private: + ID3D11Texture1D* texture1D_DX11; + Texture1DDesc desc; + public: + Texture1D(); + virtual ~Texture1D(); + + Texture1DDesc GetDesc() const { return desc; } + }; + class Texture2D : public Texture { friend class GraphicsDevice_DX11; private: + vector depthStencilViews_DX11; ID3D11Texture2D* texture2D_DX11; Texture2DDesc desc; public: @@ -258,6 +273,19 @@ namespace wiGraphicsTypes Texture2DDesc GetDesc() const { return desc; } }; + class Texture3D : public Texture + { + friend class GraphicsDevice_DX11; + private: + ID3D11Texture3D* texture3D_DX11; + Texture3DDesc desc; + public: + Texture3D(); + virtual ~Texture3D(); + + Texture3DDesc GetDesc() const { return desc; } + }; + @@ -266,7 +294,7 @@ namespace wiGraphicsTypes friend class GraphicsDevice_DX11; private: vector resource_DX11; - vector active; + vector active; GPUQueryDesc desc; int async_frameshift; public: diff --git a/WickedEngine/wiProfiler.cpp b/WickedEngine/wiProfiler.cpp index e48d597f5..6c212b1df 100644 --- a/WickedEngine/wiProfiler.cpp +++ b/WickedEngine/wiProfiler.cpp @@ -10,13 +10,16 @@ void wiProfiler::BeginFrame() if (!ENABLED) return; + wiRenderer::GetDevice()->LOCK(); wiRenderer::GetDevice()->QueryBegin(&disjoint, GRAPHICSTHREAD_IMMEDIATE); + wiRenderer::GetDevice()->UNLOCK(); } void wiProfiler::EndFrame() { if (!ENABLED) return; + wiRenderer::GetDevice()->LOCK(); wiRenderer::GetDevice()->QueryEnd(&disjoint, GRAPHICSTHREAD_IMMEDIATE); while(!wiRenderer::GetDevice()->QueryRead(&disjoint, GRAPHICSTHREAD_IMMEDIATE)); @@ -43,6 +46,7 @@ void wiProfiler::EndFrame() } } } + wiRenderer::GetDevice()->UNLOCK(); } void wiProfiler::BeginRange(const std::string& name, PROFILER_DOMAIN domain, GRAPHICSTHREAD threadID) diff --git a/WickedEngine/wiRenderTarget.cpp b/WickedEngine/wiRenderTarget.cpp index 48c9f9c1e..cef7077bf 100644 --- a/WickedEngine/wiRenderTarget.cpp +++ b/WickedEngine/wiRenderTarget.cpp @@ -183,13 +183,13 @@ void wiRenderTarget::Deactivate(GRAPHICSTHREAD threadID) void wiRenderTarget::Set(GRAPHICSTHREAD threadID, bool disableColor) { wiRenderer::GetDevice()->BindViewports(1, &viewPort, threadID); - wiRenderer::GetDevice()->BindRenderTargets(disableColor ? 0 : numViews, disableColor ? nullptr : renderTargets.data(), (depth ? depth->GetTexture() : nullptr), threadID); + wiRenderer::GetDevice()->BindRenderTargets(disableColor ? 0 : numViews, disableColor ? nullptr : (Texture**)renderTargets.data(), (depth ? depth->GetTexture() : nullptr), threadID); resolvedMSAAUptodate = false; } void wiRenderTarget::Set(GRAPHICSTHREAD threadID, wiDepthTarget* getDepth, bool disableColor) { wiRenderer::GetDevice()->BindViewports(1, &viewPort, threadID); - wiRenderer::GetDevice()->BindRenderTargets(disableColor ? 0 : numViews, disableColor ? nullptr : renderTargets.data(), (getDepth ? getDepth->GetTexture() : nullptr), threadID); + wiRenderer::GetDevice()->BindRenderTargets(disableColor ? 0 : numViews, disableColor ? nullptr : (Texture**)renderTargets.data(), (getDepth ? getDepth->GetTexture() : nullptr), threadID); resolvedMSAAUptodate = false; } diff --git a/WickedEngine/wiRenderer.cpp b/WickedEngine/wiRenderer.cpp index 906c85a56..b1486ede2 100644 --- a/WickedEngine/wiRenderer.cpp +++ b/WickedEngine/wiRenderer.cpp @@ -55,6 +55,7 @@ Texture2D* wiRenderer::enviroMap,*wiRenderer::colorGrading; float wiRenderer::GameSpeed=1,wiRenderer::overrideGameSpeed=1; bool wiRenderer::debugLightCulling = false; bool wiRenderer::occlusionCulling = true; +bool wiRenderer::voxelRadiance = false; int wiRenderer::visibleCount; wiRenderTarget wiRenderer::normalMapRT, wiRenderer::imagesRT, wiRenderer::imagesRTAdd; Camera *wiRenderer::cam = nullptr, *wiRenderer::refCam = nullptr, *wiRenderer::prevFrameCam = nullptr; @@ -770,6 +771,7 @@ void wiRenderer::LoadShaders() computeShaders[CSTYPE_TILEDLIGHTCULLING] = static_cast(wiResourceManager::GetShaderManager()->add(SHADERPATH + "lightCullingCS.cso", wiResourceManager::COMPUTESHADER)); computeShaders[CSTYPE_TILEDLIGHTCULLING_DEBUG] = static_cast(wiResourceManager::GetShaderManager()->add(SHADERPATH + "lightCullingCS_DEBUG.cso", wiResourceManager::COMPUTESHADER)); computeShaders[CSTYPE_RESOLVEMSAADEPTHSTENCIL] = static_cast(wiResourceManager::GetShaderManager()->add(SHADERPATH + "resolveMSAADepthStencilCS.cso", wiResourceManager::COMPUTESHADER)); + computeShaders[CSTYPE_VOXELRADIANCE] = static_cast(wiResourceManager::GetShaderManager()->add(SHADERPATH + "voxelRadianceCS.cso", wiResourceManager::COMPUTESHADER)); hullShaders[HSTYPE_OBJECT] = static_cast(wiResourceManager::GetShaderManager()->add(SHADERPATH + "objectHS.cso", wiResourceManager::HULLSHADER)); @@ -1015,7 +1017,6 @@ void wiRenderer::SetUpStates() dsd.BackFace.StencilPassOp = STENCIL_OP_REPLACE; dsd.BackFace.StencilFailOp = STENCIL_OP_KEEP; dsd.BackFace.StencilDepthFailOp = STENCIL_OP_KEEP; - // Create the depth stencil state. GetDevice()->CreateDepthStencilState(&dsd, depthStencils[DSSTYPE_DEFAULT]); @@ -1033,7 +1034,6 @@ void wiRenderer::SetUpStates() dsd.BackFace.StencilPassOp = STENCIL_OP_KEEP; dsd.BackFace.StencilFailOp = STENCIL_OP_KEEP; dsd.BackFace.StencilDepthFailOp = STENCIL_OP_KEEP; - // Create the depth stencil state. GetDevice()->CreateDepthStencilState(&dsd, depthStencils[DSSTYPE_DIRLIGHT]); @@ -1051,12 +1051,12 @@ void wiRenderer::SetUpStates() dsd.BackFace.StencilPassOp = STENCIL_OP_KEEP; dsd.BackFace.StencilFailOp = STENCIL_OP_KEEP; dsd.BackFace.StencilDepthFailOp = STENCIL_OP_KEEP; - // Create the depth stencil state. GetDevice()->CreateDepthStencilState(&dsd, depthStencils[DSSTYPE_LIGHT]); dsd.DepthEnable = false; dsd.StencilEnable = true; + dsd.DepthFunc = COMPARISON_LESS_EQUAL; dsd.StencilReadMask = 0xFF; dsd.StencilWriteMask = 0xFF; dsd.FrontFace.StencilFunc = COMPARISON_EQUAL; @@ -1551,6 +1551,12 @@ void wiRenderer::UpdatePerFrameData() } void wiRenderer::UpdateRenderData(GRAPHICSTHREAD threadID) { + //if(GetDevice()->GetFrameCount() % 30 == 0) + { + VoxelizeScene(threadID); + ComputeVoxelRadiance(threadID); + } + UpdateWorldCB(threadID); // only commits when parameters are changed UpdateFrameCB(threadID); @@ -1747,7 +1753,7 @@ void wiRenderer::UpdateRenderData(GRAPHICSTHREAD threadID) lightArray[lightCounter].coneAngleCos = cosf(lightArray[lightCounter].coneAngle); lightArray[lightCounter].directionWS = l->GetDirection(); XMStoreFloat3(&lightArray[lightCounter].directionVS, XMVector3TransformNormal(XMLoadFloat3(&lightArray[lightCounter].directionWS), viewMatrix)); - if (l->shadow && l->shadowMap_index >= 0) + if (l->shadow && l->shadowMap_index >= 0 && !l->shadowCam_spotLight.empty()) { lightArray[lightCounter].shadowMatrix[0] = l->shadowCam_spotLight[0].getVP(); } @@ -1783,7 +1789,6 @@ void wiRenderer::UpdateRenderData(GRAPHICSTHREAD threadID) { x->UpdateRenderData(threadID); } - } void wiRenderer::OcclusionCulling_Render(GRAPHICSTHREAD threadID) { @@ -3834,6 +3839,100 @@ void wiRenderer::RefreshEnvProbes(GRAPHICSTHREAD threadID) GetDevice()->EventEnd(); } +static float voxelRadianceScale = 0; // 0 is disabled +void wiRenderer::VoxelizeScene(GRAPHICSTHREAD threadID) +{ + if (!GetVoxelRadianceEnabled()) + { + voxelRadianceScale = 0; + return; + } + + GetDevice()->EventBegin("Voxelize Scene", threadID); + wiProfiler::GetInstance().BeginRange("Voxelize Scene", wiProfiler::DOMAIN_GPU, threadID); + + static const int res = 32; + static const float scale = 2.0f; + voxelRadianceScale = 1.0f / (res * scale); + if (textures[TEXTYPE_3D_VOXELSCENE] == nullptr) + { + Texture3DDesc desc; + ZeroMemory(&desc, sizeof(desc)); + desc.Width = res; + desc.Height = res; + desc.Depth = res; + desc.MipLevels = 1; + desc.Format = FORMAT_R8G8B8A8_UNORM; + desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; + desc.Usage = USAGE_DEFAULT; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + + textures[TEXTYPE_3D_VOXELSCENE] = new Texture3D; + textures[TEXTYPE_3D_VOXELSCENE]->RequestIndepententRenderTargetArraySlices(true); + HRESULT hr = GetDevice()->CreateTexture3D(&desc, nullptr, (Texture3D**)&textures[TEXTYPE_3D_VOXELSCENE]); + assert(SUCCEEDED(hr)); + } + + CulledList culledObjects; + CulledCollection culledRenderer; + + AABB bbox; + XMFLOAT3 extents = XMFLOAT3(res * scale, res * scale, res * scale); + XMFLOAT3 center = XMFLOAT3(floorf(cam->translation.x), floorf(cam->translation.y), floorf(cam->translation.z)); + bbox.createFromHalfWidth(center, extents); + if (spTree != nullptr) + { + spTree->getVisible(bbox, culledObjects); + + for (Cullable* object : culledObjects) + { + culledRenderer[((Object*)object)->mesh].push_front((Object*)object); + } + + ViewPort VP; + VP.TopLeftX = 0; + VP.TopLeftY = 0; + VP.Width = (float)res; + VP.Height = (float)res; + VP.MinDepth = 0.0f; + VP.MaxDepth = 1.0f; + GetDevice()->BindViewports(1, &VP, threadID); + + GetDevice()->BindBlendState(blendStates[BSTYPE_OPAQUE], threadID); + + Camera savedCam = *cam; + + + for (int i = 0; i < res; ++i) + { + GetDevice()->BindRenderTargets(1, &textures[TEXTYPE_3D_VOXELSCENE], nullptr, threadID, i); + static const float color[] = { 0,0,0,0 }; + GetDevice()->ClearRenderTarget(textures[TEXTYPE_3D_VOXELSCENE], color, threadID, i); + + cam->Clear(); + cam->Translate(bbox.getCenter()); + + XMMATRIX view = XMMatrixLookToLH(XMLoadFloat3(¢er), XMVectorSet(0, 0, 1, 0), XMVectorSet(0, 1, 0, 0)); + XMStoreFloat4x4(&cam->View, view); + XMMATRIX projection = XMMatrixOrthographicOffCenterLH(-extents.x, extents.x, -extents.y, extents.y, -extents.z + i * scale * 2, -extents.z + (i + 1) * scale * 2); + XMStoreFloat4x4(&cam->Projection, projection); + XMStoreFloat4x4(&cam->VP, XMMatrixMultiply(view, projection)); + + UpdateCameraCB(cam, threadID); + + RenderMeshes(cam->translation, culledRenderer, SHADERTYPE_TEXTURE, RENDERTYPE_OPAQUE, threadID); + } + + + *cam = savedCam; + UpdateCameraCB(cam, threadID); + } + + wiProfiler::GetInstance().EndRange(threadID); + GetDevice()->EventEnd(); +} + void wiRenderer::ComputeTiledLightCulling(GRAPHICSTHREAD threadID) { wiProfiler::GetInstance().BeginRange("Tiled Light Culling", wiProfiler::DOMAIN_GPU, threadID); @@ -4028,6 +4127,61 @@ void wiRenderer::ResolveMSAADepthBuffer(Texture2D* dst, Texture2D* src, GRAPHICS GetDevice()->EventEnd(); } +void wiRenderer::ComputeVoxelRadiance(GRAPHICSTHREAD threadID) +{ + if (!GetVoxelRadianceEnabled()) + { + return; + } + + if (textures[TEXTYPE_3D_VOXELSCENE] == nullptr) + { + assert(0); + return; + } + + GetDevice()->EventBegin("Compute Voxel Radiance", threadID); + wiProfiler::GetInstance().BeginRange("Compute Voxel Radiance", wiProfiler::DOMAIN_GPU, threadID); + + + if (textures[TEXTYPE_3D_VOXELRADIANCE] == nullptr) + { + Texture3DDesc desc; + ZeroMemory(&desc, sizeof(desc)); + desc.Width = ((Texture3D*)textures[TEXTYPE_3D_VOXELSCENE])->GetDesc().Width; + desc.Height = ((Texture3D*)textures[TEXTYPE_3D_VOXELSCENE])->GetDesc().Height; + desc.Depth = ((Texture3D*)textures[TEXTYPE_3D_VOXELSCENE])->GetDesc().Depth; + desc.MipLevels = 1; + desc.Format = FORMAT_R8G8B8A8_UNORM; + desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE; + desc.Usage = USAGE_DEFAULT; + desc.CPUAccessFlags = 0; + desc.MiscFlags = 0; + + textures[TEXTYPE_3D_VOXELRADIANCE] = new Texture3D; + HRESULT hr = GetDevice()->CreateTexture3D(&desc, nullptr, (Texture3D**)&textures[TEXTYPE_3D_VOXELRADIANCE]); + assert(SUCCEEDED(hr)); + } + + GetDevice()->BindRenderTargets(0, nullptr, nullptr, threadID); + GetDevice()->BindResourceCS(textures[TEXTYPE_3D_VOXELSCENE], 0, threadID); + GetDevice()->BindUnorderedAccessResourceCS(textures[TEXTYPE_3D_VOXELRADIANCE], 0, threadID); + + Texture3DDesc desc = ((Texture3D*)textures[TEXTYPE_3D_VOXELRADIANCE])->GetDesc(); + + GetDevice()->BindCS(computeShaders[CSTYPE_VOXELRADIANCE], threadID); + GetDevice()->Dispatch((UINT)ceilf(desc.Width / 4.f), (UINT)ceilf(desc.Height / 4.f), (UINT)ceilf(desc.Depth / 4.f), threadID); + GetDevice()->BindCS(nullptr, threadID); + + + GetDevice()->UnBindResources(0, 1, threadID); + GetDevice()->UnBindUnorderedAccessResources(0, 1, threadID); + + GetDevice()->BindResourcePS(textures[TEXTYPE_3D_VOXELRADIANCE], TEXSLOT_VOXELRADIANCE, threadID); + + wiProfiler::GetInstance().EndRange(threadID); + GetDevice()->EventEnd(); +} void wiRenderer::ManageDecalAtlas(GRAPHICSTHREAD threadID) { @@ -4117,6 +4271,7 @@ void wiRenderer::UpdateWorldCB(GRAPHICSTHREAD threadID) value.mHorizon = world.horizon; value.mZenith = world.zenith; value.mScreenWidthHeight = XMFLOAT2((float)GetDevice()->GetScreenWidth(), (float)GetDevice()->GetScreenHeight()); + value.mVoxelRadianceScale = voxelRadianceScale; if (memcmp(&prevcb[threadID], &value, sizeof(WorldCB)) != 0) { @@ -4132,7 +4287,7 @@ void wiRenderer::UpdateFrameCB(GRAPHICSTHREAD threadID) cb.mWindTime = wind.time; cb.mWindRandomness = wind.randomness; cb.mWindWaveSize = wind.waveSize; - cb.mWindDirection = wind.direction; + cb.mWindDirection = wind.direction; cb.mSunLightArrayIndex = GetSunArrayIndex(); auto camera = getCamera(); @@ -4764,7 +4919,6 @@ void wiRenderer::CreateImpostor(Mesh* mesh) const XMFLOAT3 extents = bbox.getHalfWidth(); if (!mesh->impostorTarget.IsInitialized()) { - // TODO: Validate MRT format mismatch??? (Seems to work on Nvidia GT525M) mesh->impostorTarget.Initialize(res * 6, res, true, FORMAT_R8G8B8A8_UNORM, 0); mesh->impostorTarget.Add(FORMAT_R8G8B8A8_UNORM); // normal mesh->impostorTarget.Add(FORMAT_R8_UNORM); // roughness diff --git a/WickedEngine/wiRenderer.h b/WickedEngine/wiRenderer.h index eadbf5086..a05434f28 100644 --- a/WickedEngine/wiRenderer.h +++ b/WickedEngine/wiRenderer.h @@ -91,7 +91,7 @@ public: XMFLOAT3 mAmbient; float pad2; XMFLOAT3 mFog; float pad3; XMFLOAT2 mScreenWidthHeight; - float pad4; + float mVoxelRadianceScale; float pad5; CB_SETBINDSLOT(CBSLOT_RENDERER_WORLD) @@ -293,6 +293,7 @@ protected: static bool debugLightCulling; static bool occlusionCulling; + static bool voxelRadiance; public: static string SHADERPATH; @@ -333,6 +334,8 @@ public: static bool GetDebugLightCulling() { return debugLightCulling; } static void SetOcclusionCullingEnabled(bool enabled) { occlusionCulling = enabled; } static bool GetOcclusionCullingEnabled() { return occlusionCulling; } + static void SetVoxelRadianceEnabled(bool enabled) { voxelRadiance = enabled; } + static bool GetVoxelRadianceEnabled() { return voxelRadiance; } static bool IsRequestedReflectionRendering() { return requestReflectionRendering; } static wiGraphicsTypes::Texture2D* GetColorGrading(){return colorGrading;}; static void SetColorGrading(wiGraphicsTypes::Texture2D* tex){colorGrading=tex;}; @@ -411,9 +414,11 @@ public: static void DrawLensFlares(GRAPHICSTHREAD threadID); static void DrawDecals(Camera* camera, GRAPHICSTHREAD threadID); static void RefreshEnvProbes(GRAPHICSTHREAD threadID); + static void VoxelizeScene(GRAPHICSTHREAD threadID); static void ComputeTiledLightCulling(GRAPHICSTHREAD threadID); static void ResolveMSAADepthBuffer(wiGraphicsTypes::Texture2D* dst, wiGraphicsTypes::Texture2D* src, GRAPHICSTHREAD threadID); + static void ComputeVoxelRadiance(GRAPHICSTHREAD threadID); static void ManageDecalAtlas(GRAPHICSTHREAD threadID); diff --git a/WickedEngine/wiVersion.cpp b/WickedEngine/wiVersion.cpp index b767e075a..b00fcaed9 100644 --- a/WickedEngine/wiVersion.cpp +++ b/WickedEngine/wiVersion.cpp @@ -5,9 +5,9 @@ namespace wiVersion // main engine core const int major = 0; // minor features, major updates - const int minor = 9; + const int minor = 10; // minor bug fixes, alterations, refactors, updates - const int revision = 70; + const int revision = 0; long GetVersion()