diff --git a/WickedEngine/RenderPath3D.cpp b/WickedEngine/RenderPath3D.cpp index 5317a48ed..4907b3096 100644 --- a/WickedEngine/RenderPath3D.cpp +++ b/WickedEngine/RenderPath3D.cpp @@ -26,15 +26,6 @@ void RenderPath3D::ResizeBuffers() desc.Width = wiRenderer::GetInternalResolution().x; desc.Height = wiRenderer::GetInternalResolution().y; device->CreateTexture2D(&desc, nullptr, &rtSSR); - device->CreateTexture2D(&desc, nullptr, &rtMotionBlur); - } - { - TextureDesc desc; - desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; - desc.Format = wiRenderer::RTFormat_lineardepth; - desc.Width = wiRenderer::GetInternalResolution().x; - desc.Height = wiRenderer::GetInternalResolution().y; - device->CreateTexture2D(&desc, nullptr, &rtLinearDepth); } { TextureDesc desc; @@ -82,24 +73,11 @@ void RenderPath3D::ResizeBuffers() { TextureDesc desc; desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; - desc.Format = defaultTextureFormat; - desc.Width = wiRenderer::GetInternalResolution().x; - desc.Height = wiRenderer::GetInternalResolution().y; - device->CreateTexture2D(&desc, nullptr, &rtFinal[0]); - device->CreateTexture2D(&desc, nullptr, &rtFinal[1]); - } - { - TextureDesc desc; - desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; - desc.Format = defaultTextureFormat; - desc.Width = (UINT)(wiRenderer::GetInternalResolution().x*0.5f); - desc.Height = (UINT)(wiRenderer::GetInternalResolution().y*0.5f); + desc.Format = wiRenderer::RTFormat_hdr; + desc.Width = (UINT)(wiRenderer::GetInternalResolution().x / 2); + desc.Height = (UINT)(wiRenderer::GetInternalResolution().y / 2); device->CreateTexture2D(&desc, nullptr, &rtDof[0]); device->CreateTexture2D(&desc, nullptr, &rtDof[1]); - - desc.Width = wiRenderer::GetInternalResolution().x; - desc.Height = wiRenderer::GetInternalResolution().y; - device->CreateTexture2D(&desc, nullptr, &rtDof[2]); } { TextureDesc desc; @@ -152,6 +130,23 @@ void RenderPath3D::ResizeBuffers() device->CreateTexture2D(&desc, nullptr, &rtTemporalAA[0]); device->CreateTexture2D(&desc, nullptr, &rtTemporalAA[1]); } + { + TextureDesc desc; + desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; + desc.Format = wiRenderer::RTFormat_hdr; + desc.Width = wiRenderer::GetInternalResolution().x; + desc.Height = wiRenderer::GetInternalResolution().y; + device->CreateTexture2D(&desc, nullptr, &rtPostprocess_HDR); + } + { + TextureDesc desc; + desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; + desc.Format = defaultTextureFormat; + desc.Width = wiRenderer::GetInternalResolution().x; + desc.Height = wiRenderer::GetInternalResolution().y; + device->CreateTexture2D(&desc, nullptr, &rtPostprocess_LDR[0]); + device->CreateTexture2D(&desc, nullptr, &rtPostprocess_LDR[1]); + } // Depth buffers: { @@ -175,7 +170,15 @@ void RenderPath3D::ResizeBuffers() desc.BindFlags = BIND_SHADER_RESOURCE; } desc.SampleDesc.Count = 1; - device->CreateTexture2D(&desc, nullptr, &depthCopy); + device->CreateTexture2D(&desc, nullptr, &depthBuffer_Copy); + } + { + TextureDesc desc; + desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; + desc.Format = wiRenderer::RTFormat_lineardepth; + desc.Width = wiRenderer::GetInternalResolution().x; + desc.Height = wiRenderer::GetInternalResolution().y; + device->CreateTexture2D(&desc, nullptr, &rtLinearDepth); } { TextureDesc desc; @@ -207,36 +210,12 @@ void RenderPath3D::Compose() const GraphicsDevice* device = wiRenderer::GetDevice(); wiImageParams fx((float)device->GetScreenWidth(), (float)device->GetScreenHeight()); - fx.blendFlag = BLENDMODE_PREMULTIPLIED; + fx.blendFlag = BLENDMODE_OPAQUE; fx.quality = QUALITY_LINEAR; + fx.enableFullScreen(); - if (getColorGradingEnabled()) - { - device->EventBegin("Color Graded Composition", GRAPHICSTHREAD_IMMEDIATE); - if (colorGradingTex != nullptr) { - fx.process.setColorGrade(); - fx.setMaskMap(colorGradingTex); - } - else - { - fx.process.setColorGrade(); - fx.setMaskMap(wiTextureHelper::getColorGradeDefault()); - } - } - else - { - device->EventBegin("Composition", GRAPHICSTHREAD_IMMEDIATE); - fx.enableFullScreen(); - } - - if (getSharpenFilterEnabled()) - { - wiImage::Draw(&rtFinal[0], fx, GRAPHICSTHREAD_IMMEDIATE); - } - else - { - wiImage::Draw(&rtFinal[1], fx, GRAPHICSTHREAD_IMMEDIATE); - } + device->EventBegin("Composition", GRAPHICSTHREAD_IMMEDIATE); + wiImage::Draw(GetLastPostprocessRT(), fx, GRAPHICSTHREAD_IMMEDIATE); device->EventEnd(GRAPHICSTHREAD_IMMEDIATE); if (wiRenderer::GetDebugLightCulling()) @@ -251,7 +230,7 @@ void RenderPath3D::RenderFrameSetUp(GRAPHICSTHREAD threadID) const { GraphicsDevice* device = wiRenderer::GetDevice(); - device->BindResource(CS, &depthCopy, TEXSLOT_DEPTH, threadID); + device->BindResource(CS, &depthBuffer_Copy, TEXSLOT_DEPTH, threadID); wiRenderer::UpdateRenderData(threadID); ViewPort viewPort; @@ -335,7 +314,7 @@ void RenderPath3D::RenderLinearDepth(GRAPHICSTHREAD threadID) const fx.sampleFlag = SAMPLEMODE_CLAMP; fx.quality = QUALITY_NEAREST; fx.process.setLinDepth(); - wiImage::Draw(&depthCopy, fx, threadID); + wiImage::Draw(&depthBuffer_Copy, fx, threadID); fx.process.clear(); device->BindRenderTargets(0, nullptr, nullptr, threadID); @@ -448,7 +427,7 @@ void RenderPath3D::DownsampleDepthBuffer(GRAPHICSTHREAD threadID) const device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_DEPTH_READ, RESOURCE_STATE_DEPTH_WRITE, threadID); fx.process.setDepthBufferDownsampling(); - wiImage::Draw(&depthCopy, fx, threadID); + wiImage::Draw(&depthBuffer_Copy, fx, threadID); fx.process.clear(); } device->EventEnd(threadID); @@ -578,23 +557,6 @@ void RenderPath3D::RenderParticles(bool isDistrortionPass, GRAPHICSTHREAD thread wiRenderer::DrawSoftParticles(wiRenderer::GetCamera(), isDistrortionPass, threadID); } } -void RenderPath3D::RenderWaterRipples(GRAPHICSTHREAD threadID) const -{ - GraphicsDevice* device = wiRenderer::GetDevice(); - - // todo: refactor water ripples and avoid clear if there is none! - const Texture2D* rts[] = { &rtWaterRipple }; - device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); - float clear[] = { 0,0,0,0 }; - device->ClearRenderTarget(rts[0], clear, threadID); - - ViewPort vp; - vp.Width = (float)rts[0]->GetDesc().Width; - vp.Height = (float)rts[0]->GetDesc().Height; - device->BindViewports(1, &vp, threadID); - - wiRenderer::DrawWaterRipples(threadID); -} void RenderPath3D::RenderRefractionSource(const Texture2D& srcSceneRT, GRAPHICSTHREAD threadID) const { GraphicsDevice* device = wiRenderer::GetDevice(); @@ -627,6 +589,22 @@ void RenderPath3D::RenderTransparents(const Texture2D& dstSceneRT, RENDERPASS re { GraphicsDevice* device = wiRenderer::GetDevice(); + // Water ripple rendering: + { + // todo: refactor water ripples and avoid clear if there is none! + const Texture2D* rts[] = { &rtWaterRipple }; + device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); + float clear[] = { 0,0,0,0 }; + device->ClearRenderTarget(rts[0], clear, threadID); + + ViewPort vp; + vp.Width = (float)rts[0]->GetDesc().Width; + vp.Height = (float)rts[0]->GetDesc().Height; + device->BindViewports(1, &vp, threadID); + + wiRenderer::DrawWaterRipples(threadID); + } + wiImageParams fx((float)wiRenderer::GetInternalResolution().x, (float)wiRenderer::GetInternalResolution().y); fx.enableHDR(); @@ -688,6 +666,10 @@ void RenderPath3D::RenderTransparents(const Texture2D& dstSceneRT, RENDERPASS re wiRenderer::DrawDebugWorld(wiRenderer::GetCamera(), threadID); device->BindRenderTargets(0, nullptr, nullptr, threadID); + + + + RenderParticles(true, GRAPHICSTHREAD_IMMEDIATE); } void RenderPath3D::TemporalAAResolve(const Texture2D& srcdstSceneRT, const Texture2D& srcGbuffer1, GRAPHICSTHREAD threadID) const { @@ -800,79 +782,112 @@ void RenderPath3D::RenderBloom(const Texture2D& srcdstSceneRT, GRAPHICSTHREAD th device->EventEnd(threadID); } } -void RenderPath3D::RenderMotionBlur(const Texture2D& srcSceneRT, const Texture2D& srcGbuffer1, GRAPHICSTHREAD threadID) const -{ - if (getMotionBlurEnabled()) - { - GraphicsDevice* device = wiRenderer::GetDevice(); - wiImageParams fx((float)wiRenderer::GetInternalResolution().x, (float)wiRenderer::GetInternalResolution().y); - - wiRenderer::BindGBufferTextures(nullptr, &srcGbuffer1, nullptr, GRAPHICSTHREAD_IMMEDIATE); - - device->EventBegin("Motion Blur", threadID); - - const Texture2D* rts[] = { &rtMotionBlur }; - device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); - - ViewPort vp; - vp.Width = (float)rts[0]->GetDesc().Width; - vp.Height = (float)rts[0]->GetDesc().Height; - device->BindViewports(1, &vp, threadID); - - fx.process.setMotionBlur(); - fx.blendFlag = BLENDMODE_OPAQUE; - fx.disableFullScreen(); - wiImage::Draw(&srcSceneRT, fx, threadID); - fx.process.clear(); - device->EventEnd(threadID); - } -} -void RenderPath3D::ToneMapping(const Texture2D& srcSceneRT, GRAPHICSTHREAD threadID) const +void RenderPath3D::RenderPostprocessChain(const Texture2D& srcSceneRT, const Texture2D& srcGbuffer1, GRAPHICSTHREAD threadID) const { GraphicsDevice* device = wiRenderer::GetDevice(); wiImageParams fx((float)wiRenderer::GetInternalResolution().x, (float)wiRenderer::GetInternalResolution().y); - device->EventBegin("Tone Mapping", threadID); - fx.disableHDR(); - fx.blendFlag = BLENDMODE_OPAQUE; + const Texture2D* rt_read = &srcSceneRT; + const Texture2D* rt_write = &rtPostprocess_HDR; - const Texture2D* rts[] = { &rtFinal[0] }; - device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); + // 1.) HDR post process chain + { + fx.enableHDR(); - ViewPort vp; - vp.Width = (float)rts[0]->GetDesc().Width; - vp.Height = (float)rts[0]->GetDesc().Height; - device->BindViewports(1, &vp, threadID); + if (getMotionBlurEnabled()) + { + wiRenderer::BindGBufferTextures(nullptr, &srcGbuffer1, nullptr, GRAPHICSTHREAD_IMMEDIATE); - fx.process.setToneMap(getExposure()); - fx.setDistortionMap(&rtParticle); - if (getEyeAdaptionEnabled()) - { - fx.setMaskMap(wiRenderer::GetLuminance(&srcSceneRT, threadID)); - } - else - { - fx.setMaskMap(wiTextureHelper::getColor(wiColor::Gray())); - } - if (getMotionBlurEnabled()) - { - wiImage::Draw(&rtMotionBlur, fx, threadID); - } - else - { - wiImage::Draw(&srcSceneRT, fx, threadID); - } - fx.process.clear(); - device->EventEnd(threadID); -} -void RenderPath3D::SharpenFilter(const Texture2D& dstSceneRT, const Texture2D& srcSceneRT, GRAPHICSTHREAD threadID) const -{ - if (getSharpenFilterEnabled()) - { - GraphicsDevice* device = wiRenderer::GetDevice(); - wiImageParams fx((float)wiRenderer::GetInternalResolution().x, (float)wiRenderer::GetInternalResolution().y); + device->EventBegin("Motion Blur", threadID); - const Texture2D* rts[] = { &dstSceneRT }; + const Texture2D* rts[] = { rt_write }; + device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); + + ViewPort vp; + vp.Width = (float)rts[0]->GetDesc().Width; + vp.Height = (float)rts[0]->GetDesc().Height; + device->BindViewports(1, &vp, threadID); + + fx.process.setMotionBlur(); + fx.blendFlag = BLENDMODE_OPAQUE; + fx.disableFullScreen(); + wiImage::Draw(rt_read, fx, threadID); + fx.process.clear(); + device->EventEnd(threadID); + + SwapPtr(rt_read, rt_write); + device->UnbindResources(TEXSLOT_ONDEMAND0, 1, threadID); + } + + if (getDepthOfFieldEnabled()) + { + device->EventBegin("Depth Of Field", threadID); + // downsample + blur + { + const Texture2D* rts[] = { &rtDof[0] }; + device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); + + ViewPort vp; + vp.Width = (float)rts[0]->GetDesc().Width; + vp.Height = (float)rts[0]->GetDesc().Height; + device->BindViewports(1, &vp, threadID); + + fx.process.setBlur(XMFLOAT2(getDepthOfFieldStrength(), 0), fx.isHDREnabled()); + wiImage::Draw(rt_read, fx, threadID); + + device->UnbindResources(TEXSLOT_ONDEMAND0, 1, threadID); + } + + { + const Texture2D* rts[] = { &rtDof[1] }; + device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); + + ViewPort vp; + vp.Width = (float)rts[0]->GetDesc().Width; + vp.Height = (float)rts[0]->GetDesc().Height; + device->BindViewports(1, &vp, threadID); + + fx.process.setBlur(XMFLOAT2(0, getDepthOfFieldStrength()), fx.isHDREnabled()); + wiImage::Draw(&rtDof[0], fx, threadID); + fx.process.clear(); + + device->UnbindResources(TEXSLOT_ONDEMAND0, 1, threadID); + } + + // depth of field compose pass + { + const Texture2D* rts[] = { rt_write }; + device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); + + ViewPort vp; + vp.Width = (float)rts[0]->GetDesc().Width; + vp.Height = (float)rts[0]->GetDesc().Height; + device->BindViewports(1, &vp, threadID); + + fx.process.setDOF(getDepthOfFieldFocus()); + fx.setMaskMap(&rtDof[1]); + wiImage::Draw(rt_read, fx, threadID); + fx.setMaskMap(nullptr); + fx.process.clear(); + + SwapPtr(rt_read, rt_write); + device->UnbindResources(TEXSLOT_ONDEMAND0, 1, threadID); + } + device->EventEnd(threadID); + } + + fx.disableHDR(); + } + + // 2.) Tone mapping HDR -> LDR + { + rt_write = &rtPostprocess_LDR[0]; + + device->EventBegin("Tone Mapping", threadID); + fx.disableHDR(); + fx.blendFlag = BLENDMODE_OPAQUE; + + const Texture2D* rts[] = { rt_write }; device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); ViewPort vp; @@ -880,24 +895,35 @@ void RenderPath3D::SharpenFilter(const Texture2D& dstSceneRT, const Texture2D& s vp.Height = (float)rts[0]->GetDesc().Height; device->BindViewports(1, &vp, threadID); - fx.blendFlag = BLENDMODE_OPAQUE; - fx.process.setSharpen(getSharpenFilterAmount()); - wiImage::Draw(&srcSceneRT, fx, threadID); + fx.process.setToneMap(getExposure()); + fx.setDistortionMap(&rtParticle); + if (getEyeAdaptionEnabled()) + { + fx.setMaskMap(wiRenderer::ComputeLuminance(&srcSceneRT, threadID)); + } + else + { + fx.setMaskMap(wiTextureHelper::getColor(wiColor::Gray())); + } + + wiImage::Draw(rt_read, fx, threadID); fx.process.clear(); + device->EventEnd(threadID); + + rt_read = rt_write; + rt_write = &rtPostprocess_LDR[1]; device->UnbindResources(TEXSLOT_ONDEMAND0, 1, threadID); } -} -void RenderPath3D::RenderDepthOfField(const Texture2D& srcSceneRT, GRAPHICSTHREAD threadID) const -{ - if (getDepthOfFieldEnabled()) - { - GraphicsDevice* device = wiRenderer::GetDevice(); - wiImageParams fx((float)wiRenderer::GetInternalResolution().x, (float)wiRenderer::GetInternalResolution().y); - device->EventBegin("Depth Of Field", threadID); - // downsample + blur + // 3.) LDR post process chain + { + fx.disableHDR(); + + if (getSharpenFilterEnabled()) { - const Texture2D* rts[] = { &rtDof[0] }; + device->EventBegin("Sharpen Filter", GRAPHICSTHREAD_IMMEDIATE); + + const Texture2D* rts[] = { rt_write }; device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); ViewPort vp; @@ -906,12 +932,22 @@ void RenderPath3D::RenderDepthOfField(const Texture2D& srcSceneRT, GRAPHICSTHREA device->BindViewports(1, &vp, threadID); fx.blendFlag = BLENDMODE_OPAQUE; - fx.process.setBlur(XMFLOAT2(getDepthOfFieldStrength(), 0)); - wiImage::Draw(&srcSceneRT, fx, threadID); + fx.process.setSharpen(getSharpenFilterAmount()); + wiImage::Draw(rt_read, fx, threadID); + fx.process.clear(); + device->UnbindResources(TEXSLOT_ONDEMAND0, 1, threadID); + + device->EventEnd(threadID); + + SwapPtr(rt_read, rt_write); + device->UnbindResources(TEXSLOT_ONDEMAND0, 1, threadID); } + if (getColorGradingEnabled()) { - const Texture2D* rts[] = { &rtDof[1] }; + device->EventBegin("Color Grading", GRAPHICSTHREAD_IMMEDIATE); + + const Texture2D* rts[] = { rt_write }; device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); ViewPort vp; @@ -919,14 +955,29 @@ void RenderPath3D::RenderDepthOfField(const Texture2D& srcSceneRT, GRAPHICSTHREA vp.Height = (float)rts[0]->GetDesc().Height; device->BindViewports(1, &vp, threadID); - fx.process.setBlur(XMFLOAT2(0, getDepthOfFieldStrength())); - wiImage::Draw(&rtDof[0], fx, threadID); - fx.process.clear(); + if (colorGradingTex != nullptr) + { + fx.process.setColorGrade(); + fx.setMaskMap(colorGradingTex); + } + else + { + fx.process.setColorGrade(); + fx.setMaskMap(wiTextureHelper::getColorGradeDefault()); + } + wiImage::Draw(rt_read, fx, threadID); + + device->EventEnd(threadID); + + SwapPtr(rt_read, rt_write); + device->UnbindResources(TEXSLOT_ONDEMAND0, 1, threadID); } - // depth of field compose pass + if (getFXAAEnabled()) { - const Texture2D* rts[] = { &rtDof[2] }; + device->EventBegin("FXAA", GRAPHICSTHREAD_IMMEDIATE); + + const Texture2D* rts[] = { rt_write }; device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); ViewPort vp; @@ -934,43 +985,13 @@ void RenderPath3D::RenderDepthOfField(const Texture2D& srcSceneRT, GRAPHICSTHREA vp.Height = (float)rts[0]->GetDesc().Height; device->BindViewports(1, &vp, threadID); - fx.process.setDOF(getDepthOfFieldFocus()); - fx.setMaskMap(&rtDof[1]); - wiImage::Draw(&srcSceneRT, fx, threadID); - fx.setMaskMap(nullptr); - fx.process.clear(); + fx.process.setFXAA(); + wiImage::Draw(rt_read, fx, threadID); + + device->EventEnd(threadID); + + SwapPtr(rt_read, rt_write); + device->UnbindResources(TEXSLOT_ONDEMAND0, 1, threadID); } - device->EventEnd(threadID); } } -void RenderPath3D::RenderFXAA(const Texture2D& dstSceneRT, const Texture2D& srcSceneRT, GRAPHICSTHREAD threadID) const -{ - GraphicsDevice* device = wiRenderer::GetDevice(); - wiImageParams fx((float)wiRenderer::GetInternalResolution().x, (float)wiRenderer::GetInternalResolution().y); - - device->EventBegin("FXAA", threadID); - - const Texture2D* rts[] = { &dstSceneRT }; - device->BindRenderTargets(ARRAYSIZE(rts), rts, nullptr, threadID); - - ViewPort vp; - vp.Width = (float)rts[0]->GetDesc().Width; - vp.Height = (float)rts[0]->GetDesc().Height; - device->BindViewports(1, &vp, threadID); - - if (getFXAAEnabled()) - { - fx.process.setFXAA(); - } - else - { - fx.enableFullScreen(); - } - if (getDepthOfFieldEnabled()) - wiImage::Draw(&rtDof[2], fx, threadID); - else - wiImage::Draw(&srcSceneRT, fx, threadID); - fx.process.clear(); - device->EventEnd(threadID); -} - diff --git a/WickedEngine/RenderPath3D.h b/WickedEngine/RenderPath3D.h index b6a9e7c3b..753a58750 100644 --- a/WickedEngine/RenderPath3D.h +++ b/WickedEngine/RenderPath3D.h @@ -49,26 +49,38 @@ private: UINT msaaSampleCount = 1; protected: - wiGraphics::Texture2D rtReflection; - wiGraphics::Texture2D rtSSR; - wiGraphics::Texture2D rtMotionBlur; - wiGraphics::Texture2D rtSceneCopy; - wiGraphics::Texture2D rtWaterRipple; - wiGraphics::Texture2D rtLinearDepth; - wiGraphics::Texture2D rtParticle; - wiGraphics::Texture2D rtVolumetricLights; - wiGraphics::Texture2D rtFinal[2]; - wiGraphics::Texture2D rtDof[3]; - wiGraphics::Texture2D rtTemporalAA[2]; - wiGraphics::Texture2D rtBloom; - wiGraphics::Texture2D rtSSAO[2]; - wiGraphics::Texture2D rtSun[2]; - wiGraphics::Texture2D rtSun_resolved; + wiGraphics::Texture2D rtReflection; // conains the scene rendered for planar reflections + wiGraphics::Texture2D rtSSR; // screen-space reflection results + wiGraphics::Texture2D rtSceneCopy; // contains the rendered scene that can be fed into transparent pass for distortion effect + wiGraphics::Texture2D rtWaterRipple; // water ripple sprite normal maps are rendered into this + wiGraphics::Texture2D rtParticle; // contains off-screen particles + wiGraphics::Texture2D rtVolumetricLights; // contains the volumetric light results + wiGraphics::Texture2D rtDof[2]; // depth of field blurred out-of focus part + wiGraphics::Texture2D rtTemporalAA[2]; // temporal AA history buffer + wiGraphics::Texture2D rtBloom; // contains the bright parts of the image + mipchain + wiGraphics::Texture2D rtSSAO[2]; // ping-pong when rendering and blurring SSAO + wiGraphics::Texture2D rtSun[2]; // 0: sun render target used for lightshafts (can be MSAA), 1: radial blurred lightshafts + wiGraphics::Texture2D rtSun_resolved; // sun render target, but the resolved version if MSAA is enabled - wiGraphics::Texture2D depthBuffer; - wiGraphics::Texture2D depthCopy; - wiGraphics::Texture2D smallDepth; - wiGraphics::Texture2D depthBuffer_reflection; + wiGraphics::Texture2D rtPostprocess_HDR; // ping-pong with main scene RT in HDR post-process chain + wiGraphics::Texture2D rtPostprocess_LDR[2]; // ping-pong with itself in LDR post-process chain + + wiGraphics::Texture2D depthBuffer; // used for depth-testing, can be MSAA + wiGraphics::Texture2D depthBuffer_Copy; // used for shader resource, single sample + wiGraphics::Texture2D rtLinearDepth; // linear depth result + wiGraphics::Texture2D smallDepth; // downsampled depth buffer + wiGraphics::Texture2D depthBuffer_reflection; // depth-test for reflection rendering + + // Post-processes are ping-ponged, this function helps to obtain the last postprocess render target that was written + const wiGraphics::Texture2D* GetLastPostprocessRT() const + { + int ldr_postprocess_count = 0; + ldr_postprocess_count += sharpenFilterEnabled ? 1 : 0; + ldr_postprocess_count += colorGradingEnabled ? 1 : 0; + ldr_postprocess_count += fxaaEnabled ? 1 : 0; + int rt_index = ldr_postprocess_count % 2; + return &rtPostprocess_LDR[rt_index]; + } void ResizeBuffers() override; @@ -84,17 +96,12 @@ protected: virtual void RenderLightShafts(GRAPHICSTHREAD threadID) const; virtual void RenderVolumetrics(GRAPHICSTHREAD threadID) const; virtual void RenderParticles(bool isDistrortionPass, GRAPHICSTHREAD threadID) const; - virtual void RenderWaterRipples(GRAPHICSTHREAD threadID) const; virtual void RenderRefractionSource(const wiGraphics::Texture2D& srcSceneRT, GRAPHICSTHREAD threadID) const; virtual void RenderTransparents(const wiGraphics::Texture2D& dstSceneRT, RENDERPASS renderPass, GRAPHICSTHREAD threadID) const; virtual void TemporalAAResolve(const wiGraphics::Texture2D& srcdstSceneRT, const wiGraphics::Texture2D& srcGbuffer1, GRAPHICSTHREAD threadID) const; virtual void RenderBloom(const wiGraphics::Texture2D& srcdstSceneRT, GRAPHICSTHREAD threadID) const; - virtual void RenderMotionBlur(const wiGraphics::Texture2D& srcSceneRT, const wiGraphics::Texture2D& srcGbuffer1, GRAPHICSTHREAD threadID) const; - virtual void ToneMapping(const wiGraphics::Texture2D& srcSceneRT, GRAPHICSTHREAD threadID) const; - virtual void SharpenFilter(const wiGraphics::Texture2D& dstSceneRT, const wiGraphics::Texture2D& srcSceneRT, GRAPHICSTHREAD threadID) const; - virtual void RenderDepthOfField(const wiGraphics::Texture2D& srcSceneRT, GRAPHICSTHREAD threadID) const; - virtual void RenderFXAA(const wiGraphics::Texture2D& dstSceneRT, const wiGraphics::Texture2D& srcSceneRT, GRAPHICSTHREAD threadID) const; - + virtual void RenderPostprocessChain(const wiGraphics::Texture2D& srcSceneRT, const wiGraphics::Texture2D& srcGbuffer1, GRAPHICSTHREAD threadID) const; + public: virtual const wiGraphics::Texture2D* GetDepthBuffer() { return &depthBuffer; } diff --git a/WickedEngine/RenderPath3D_Deferred.cpp b/WickedEngine/RenderPath3D_Deferred.cpp index 83723fc6e..04f458808 100644 --- a/WickedEngine/RenderPath3D_Deferred.cpp +++ b/WickedEngine/RenderPath3D_Deferred.cpp @@ -104,14 +104,14 @@ void RenderPath3D_Deferred::Render() const } device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_DEPTH_WRITE, RESOURCE_STATE_COPY_SOURCE, threadID); - device->CopyTexture2D(&depthCopy, &depthBuffer, threadID); + device->CopyTexture2D(&depthBuffer_Copy, &depthBuffer, threadID); device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_COPY_SOURCE, RESOURCE_STATE_DEPTH_READ, threadID); RenderLinearDepth(threadID); device->UnbindResources(TEXSLOT_ONDEMAND0, TEXSLOT_ONDEMAND_COUNT, threadID); - wiRenderer::BindDepthTextures(&depthCopy, &rtLinearDepth, threadID); + wiRenderer::BindDepthTextures(&depthBuffer_Copy, &rtLinearDepth, threadID); RenderDecals(threadID); @@ -155,8 +155,6 @@ void RenderPath3D_Deferred::Render() const RenderParticles(false, GRAPHICSTHREAD_IMMEDIATE); - RenderWaterRipples(GRAPHICSTHREAD_IMMEDIATE); - RenderRefractionSource(rtDeferred, GRAPHICSTHREAD_IMMEDIATE); RenderTransparents(rtDeferred, RENDERPASS_FORWARD, GRAPHICSTHREAD_IMMEDIATE); @@ -167,23 +165,7 @@ void RenderPath3D_Deferred::Render() const RenderBloom(rtDeferred, GRAPHICSTHREAD_IMMEDIATE); - RenderMotionBlur(rtDeferred, rtGBuffer[1], GRAPHICSTHREAD_IMMEDIATE); - - ToneMapping(rtDeferred, GRAPHICSTHREAD_IMMEDIATE); - - const Texture2D* rt0 = &rtFinal[0]; - const Texture2D* rt1 = &rtFinal[1]; - - SharpenFilter(*rt1, *rt0, GRAPHICSTHREAD_IMMEDIATE); - - if (getSharpenFilterEnabled()) - { - SwapPtr(rt0, rt1); - } - - RenderDepthOfField(*rt0, GRAPHICSTHREAD_IMMEDIATE); - - RenderFXAA(*rt1, *rt0, GRAPHICSTHREAD_IMMEDIATE); + RenderPostprocessChain(rtDeferred, rtGBuffer[1], GRAPHICSTHREAD_IMMEDIATE); RenderPath2D::Render(); } diff --git a/WickedEngine/RenderPath3D_Forward.cpp b/WickedEngine/RenderPath3D_Forward.cpp index 3d6d08ced..f7de24b9c 100644 --- a/WickedEngine/RenderPath3D_Forward.cpp +++ b/WickedEngine/RenderPath3D_Forward.cpp @@ -98,7 +98,7 @@ void RenderPath3D_Forward::Render() const if (getMSAASampleCount() > 1) { device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_DEPTH_WRITE, RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, threadID); - wiRenderer::ResolveMSAADepthBuffer(&depthCopy, &depthBuffer, threadID); + wiRenderer::ResolveMSAADepthBuffer(&depthBuffer_Copy, &depthBuffer, threadID); device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, RESOURCE_STATE_DEPTH_READ, threadID); device->MSAAResolve(scene_read[0], &rtMain[0], threadID); @@ -107,14 +107,14 @@ void RenderPath3D_Forward::Render() const else { device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_DEPTH_WRITE, RESOURCE_STATE_COPY_SOURCE, threadID); - device->CopyTexture2D(&depthCopy, &depthBuffer, threadID); + device->CopyTexture2D(&depthBuffer_Copy, &depthBuffer, threadID); device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_COPY_SOURCE, RESOURCE_STATE_DEPTH_READ, threadID); } wiRenderer::BindGBufferTextures(scene_read[0], scene_read[1], nullptr, threadID); RenderLinearDepth(threadID); - wiRenderer::BindDepthTextures(&depthCopy, &rtLinearDepth, threadID); + wiRenderer::BindDepthTextures(&depthBuffer_Copy, &rtLinearDepth, threadID); RenderSSAO(threadID); @@ -133,8 +133,6 @@ void RenderPath3D_Forward::Render() const RenderParticles(false, GRAPHICSTHREAD_IMMEDIATE); - RenderWaterRipples(GRAPHICSTHREAD_IMMEDIATE); - RenderRefractionSource(*scene_read[0], GRAPHICSTHREAD_IMMEDIATE); RenderTransparents(rtMain[0], RENDERPASS_FORWARD, GRAPHICSTHREAD_IMMEDIATE); @@ -150,23 +148,7 @@ void RenderPath3D_Forward::Render() const RenderBloom(*scene_read[0], GRAPHICSTHREAD_IMMEDIATE); - RenderMotionBlur(*scene_read[0], *scene_read[1], GRAPHICSTHREAD_IMMEDIATE); - - ToneMapping(*scene_read[0], GRAPHICSTHREAD_IMMEDIATE); - - const Texture2D* rt0 = &rtFinal[0]; - const Texture2D* rt1 = &rtFinal[1]; - - SharpenFilter(*rt1, *rt0, GRAPHICSTHREAD_IMMEDIATE); - - if (getSharpenFilterEnabled()) - { - SwapPtr(rt0, rt1); - } - - RenderDepthOfField(*rt0, GRAPHICSTHREAD_IMMEDIATE); - - RenderFXAA(*rt1, *rt0, GRAPHICSTHREAD_IMMEDIATE); + RenderPostprocessChain(*scene_read[0], *scene_read[1], GRAPHICSTHREAD_IMMEDIATE); RenderPath2D::Render(); } diff --git a/WickedEngine/RenderPath3D_Stereogram.cpp b/WickedEngine/RenderPath3D_Stereogram.cpp index 0977b4862..fe3c53b29 100644 --- a/WickedEngine/RenderPath3D_Stereogram.cpp +++ b/WickedEngine/RenderPath3D_Stereogram.cpp @@ -29,11 +29,11 @@ void RenderPath3D_Stereogram::Render() const wiRenderer::DrawScene(wiRenderer::GetCamera(), getTessellationEnabled(), GRAPHICSTHREAD_IMMEDIATE, RENDERPASS_DEPTHONLY, getHairParticlesEnabled(), true, getLayerMask()); device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_DEPTH_WRITE, RESOURCE_STATE_COPY_SOURCE, GRAPHICSTHREAD_IMMEDIATE); - device->CopyTexture2D(&depthCopy, &depthBuffer, GRAPHICSTHREAD_IMMEDIATE); + device->CopyTexture2D(&depthBuffer_Copy, &depthBuffer, GRAPHICSTHREAD_IMMEDIATE); RenderLinearDepth(GRAPHICSTHREAD_IMMEDIATE); - wiRenderer::BindDepthTextures(&depthCopy, &rtLinearDepth, GRAPHICSTHREAD_IMMEDIATE); + wiRenderer::BindDepthTextures(&depthBuffer_Copy, &rtLinearDepth, GRAPHICSTHREAD_IMMEDIATE); } void RenderPath3D_Stereogram::Compose() const diff --git a/WickedEngine/RenderPath3D_TiledDeferred.cpp b/WickedEngine/RenderPath3D_TiledDeferred.cpp index f91f55f97..696fcc0c7 100644 --- a/WickedEngine/RenderPath3D_TiledDeferred.cpp +++ b/WickedEngine/RenderPath3D_TiledDeferred.cpp @@ -52,14 +52,14 @@ void RenderPath3D_TiledDeferred::Render() const } device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_DEPTH_WRITE, RESOURCE_STATE_COPY_SOURCE, threadID); - device->CopyTexture2D(&depthCopy, &depthBuffer, threadID); + device->CopyTexture2D(&depthBuffer_Copy, &depthBuffer, threadID); device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_COPY_SOURCE, RESOURCE_STATE_DEPTH_READ, threadID); RenderLinearDepth(threadID); device->UnbindResources(TEXSLOT_ONDEMAND0, TEXSLOT_ONDEMAND_COUNT, threadID); - wiRenderer::BindDepthTextures(&depthCopy, &rtLinearDepth, threadID); + wiRenderer::BindDepthTextures(&depthBuffer_Copy, &rtLinearDepth, threadID); RenderDecals(threadID); @@ -91,8 +91,6 @@ void RenderPath3D_TiledDeferred::Render() const RenderParticles(false, GRAPHICSTHREAD_IMMEDIATE); - RenderWaterRipples(GRAPHICSTHREAD_IMMEDIATE); - RenderRefractionSource(rtDeferred, GRAPHICSTHREAD_IMMEDIATE); RenderTransparents(rtDeferred, RENDERPASS_TILEDFORWARD, GRAPHICSTHREAD_IMMEDIATE); @@ -103,23 +101,7 @@ void RenderPath3D_TiledDeferred::Render() const RenderBloom(rtDeferred, GRAPHICSTHREAD_IMMEDIATE); - RenderMotionBlur(rtDeferred, rtGBuffer[1], GRAPHICSTHREAD_IMMEDIATE); - - ToneMapping(rtDeferred, GRAPHICSTHREAD_IMMEDIATE); - - const Texture2D* rt0 = &rtFinal[0]; - const Texture2D* rt1 = &rtFinal[1]; - - SharpenFilter(*rt1, *rt0, GRAPHICSTHREAD_IMMEDIATE); - - if (getSharpenFilterEnabled()) - { - SwapPtr(rt0, rt1); - } - - RenderDepthOfField(*rt0, GRAPHICSTHREAD_IMMEDIATE); - - RenderFXAA(*rt1, *rt0, GRAPHICSTHREAD_IMMEDIATE); + RenderPostprocessChain(rtDeferred, rtGBuffer[1], GRAPHICSTHREAD_IMMEDIATE); RenderPath2D::Render(); } diff --git a/WickedEngine/RenderPath3D_TiledForward.cpp b/WickedEngine/RenderPath3D_TiledForward.cpp index 47acf775c..aaf887407 100644 --- a/WickedEngine/RenderPath3D_TiledForward.cpp +++ b/WickedEngine/RenderPath3D_TiledForward.cpp @@ -52,19 +52,19 @@ void RenderPath3D_TiledForward::Render() const if (getMSAASampleCount() > 1) { device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_DEPTH_WRITE, RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, threadID); - wiRenderer::ResolveMSAADepthBuffer(&depthCopy, &depthBuffer, threadID); + wiRenderer::ResolveMSAADepthBuffer(&depthBuffer_Copy, &depthBuffer, threadID); device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, RESOURCE_STATE_DEPTH_READ, threadID); } else { device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_DEPTH_WRITE, RESOURCE_STATE_COPY_SOURCE, threadID); - device->CopyTexture2D(&depthCopy, &depthBuffer, threadID); + device->CopyTexture2D(&depthBuffer_Copy, &depthBuffer, threadID); device->TransitionBarrier(dsv, ARRAYSIZE(dsv), RESOURCE_STATE_COPY_SOURCE, RESOURCE_STATE_DEPTH_READ, threadID); } RenderLinearDepth(threadID); - wiRenderer::BindDepthTextures(&depthCopy, &rtLinearDepth, threadID); + wiRenderer::BindDepthTextures(&depthBuffer_Copy, &rtLinearDepth, threadID); wiRenderer::ComputeTiledLightCulling(threadID); @@ -122,8 +122,6 @@ void RenderPath3D_TiledForward::Render() const RenderParticles(false, GRAPHICSTHREAD_IMMEDIATE); - RenderWaterRipples(GRAPHICSTHREAD_IMMEDIATE); - RenderRefractionSource(*scene_read[0], GRAPHICSTHREAD_IMMEDIATE); RenderTransparents(rtMain[0], RENDERPASS_TILEDFORWARD, GRAPHICSTHREAD_IMMEDIATE); @@ -133,29 +131,11 @@ void RenderPath3D_TiledForward::Render() const device->MSAAResolve(scene_read[0], &rtMain[0], GRAPHICSTHREAD_IMMEDIATE); } - RenderParticles(true, GRAPHICSTHREAD_IMMEDIATE); - TemporalAAResolve(*scene_read[0], *scene_read[1], GRAPHICSTHREAD_IMMEDIATE); RenderBloom(*scene_read[0], GRAPHICSTHREAD_IMMEDIATE); - RenderMotionBlur(*scene_read[0], *scene_read[1], GRAPHICSTHREAD_IMMEDIATE); - - ToneMapping(*scene_read[0], GRAPHICSTHREAD_IMMEDIATE); - - const Texture2D* rt0 = &rtFinal[0]; - const Texture2D* rt1 = &rtFinal[1]; - - SharpenFilter(*rt1, *rt0, GRAPHICSTHREAD_IMMEDIATE); - - if (getSharpenFilterEnabled()) - { - SwapPtr(rt0, rt1); - } - - RenderDepthOfField(*rt0, GRAPHICSTHREAD_IMMEDIATE); - - RenderFXAA(*rt1, *rt0, GRAPHICSTHREAD_IMMEDIATE); + RenderPostprocessChain(*scene_read[0], *scene_read[1], GRAPHICSTHREAD_IMMEDIATE); RenderPath2D::Render(); } diff --git a/WickedEngine/wiImage.cpp b/WickedEngine/wiImage.cpp index 51d5b8b08..ba9c1c063 100644 --- a/WickedEngine/wiImage.cpp +++ b/WickedEngine/wiImage.cpp @@ -243,7 +243,8 @@ namespace wiImage switch (params.process.type) { - case wiImageParams::PostProcess::BLUR: + case wiImageParams::PostProcess::BLUR_LDR: + case wiImageParams::PostProcess::BLUR_HDR: prcb.xPPParams0.x = params.process.params.blur.x / params.siz.x; prcb.xPPParams0.y = params.process.params.blur.y / params.siz.y; prcb.xPPParams0.z = params.mipLevel; @@ -267,7 +268,7 @@ namespace wiImage device->UpdateBuffer(&processCb, &prcb, threadID); break; case wiImageParams::PostProcess::DEPTHOFFIELD: - prcb.xPPParams0.z = params.process.params.dofStrength; + prcb.xPPParams0.z = params.process.params.dofFocus; device->UpdateBuffer(&processCb, &prcb, threadID); break; case wiImageParams::PostProcess::MOTIONBLUR: @@ -375,7 +376,8 @@ namespace wiImage imagePS[IMAGE_SHADER_MASKED][IMAGE_SAMPLING_BICUBIC] = static_cast(wiResourceManager::GetShaderManager().add(path + "imagePS_masked_bicubic.cso", wiResourceManager::PIXELSHADER)); imagePS[IMAGE_SHADER_FULLSCREEN][IMAGE_SAMPLING_BICUBIC] = static_cast(wiResourceManager::GetShaderManager().add(path + "screenPS_bicubic.cso", wiResourceManager::PIXELSHADER)); - postprocessPS[wiImageParams::PostProcess::BLUR] = static_cast(wiResourceManager::GetShaderManager().add(path + "blurPS.cso", wiResourceManager::PIXELSHADER)); + postprocessPS[wiImageParams::PostProcess::BLUR_LDR] = static_cast(wiResourceManager::GetShaderManager().add(path + "blurPS.cso", wiResourceManager::PIXELSHADER)); + postprocessPS[wiImageParams::PostProcess::BLUR_HDR] = static_cast(wiResourceManager::GetShaderManager().add(path + "blurPS.cso", wiResourceManager::PIXELSHADER)); postprocessPS[wiImageParams::PostProcess::LIGHTSHAFT] = static_cast(wiResourceManager::GetShaderManager().add(path + "lightShaftPS.cso", wiResourceManager::PIXELSHADER)); postprocessPS[wiImageParams::PostProcess::OUTLINE] = static_cast(wiResourceManager::GetShaderManager().add(path + "outlinePS.cso", wiResourceManager::PIXELSHADER)); postprocessPS[wiImageParams::PostProcess::DEPTHOFFIELD] = static_cast(wiResourceManager::GetShaderManager().add(path + "depthofFieldPS.cso", wiResourceManager::PIXELSHADER)); @@ -487,9 +489,13 @@ namespace wiImage desc.RTFormats[0] = wiRenderer::RTFormat_hdr; desc.bs = &blendStates[BLENDMODE_ALPHA]; } - else if (i == wiImageParams::PostProcess::BLOOMSEPARATE || i == wiImageParams::PostProcess::BLUR) + else if (i == wiImageParams::PostProcess::BLOOMSEPARATE) + { + desc.numRTs = 1; + desc.RTFormats[0] = device->GetBackBufferFormat(); + } + else if (i == wiImageParams::PostProcess::BLUR_LDR) { - // todo: bloom and DoF blur should really be HDR lol... desc.numRTs = 1; desc.RTFormats[0] = device->GetBackBufferFormat(); } diff --git a/WickedEngine/wiImage.h b/WickedEngine/wiImage.h index 8627f06dc..713af1a38 100644 --- a/WickedEngine/wiImage.h +++ b/WickedEngine/wiImage.h @@ -100,7 +100,8 @@ struct wiImageParams enum POSTPROCESS { DISABLED, - BLUR, + BLUR_LDR, + BLUR_HDR, LIGHTSHAFT, OUTLINE, DEPTHOFFIELD, @@ -143,7 +144,7 @@ struct wiImageParams float range; UINT sampleCount; } ssao; - float dofStrength; + float dofFocus; float sharpen; float exposure; float bloomThreshold; @@ -151,9 +152,9 @@ struct wiImageParams bool isActive() const { return type != DISABLED; } void clear() { type = DISABLED; } - void setBlur(const XMFLOAT2& direction) { type = BLUR; params.blur.x = direction.x; params.blur.y = direction.y; } + void setBlur(const XMFLOAT2& direction, bool hdr = false) { type = (hdr ? BLUR_HDR : BLUR_LDR); params.blur.x = direction.x; params.blur.y = direction.y; } void setBloom(float threshold) { type = BLOOMSEPARATE; params.bloomThreshold = threshold; } - void setDOF(float value) { if (value > 0) { type = DEPTHOFFIELD; params.dofStrength = value; } } + void setDOF(float focus) { if (focus > 0) { type = DEPTHOFFIELD; params.dofFocus = focus; } } void setMotionBlur() { type = MOTIONBLUR; } void setOutline(float threshold = 0.1f, float thickness = 1.0f, const XMFLOAT3& color = XMFLOAT3(0, 0, 0)) { diff --git a/WickedEngine/wiRenderer.cpp b/WickedEngine/wiRenderer.cpp index 7e9ae50ae..adcbd945d 100644 --- a/WickedEngine/wiRenderer.cpp +++ b/WickedEngine/wiRenderer.cpp @@ -8229,7 +8229,7 @@ void BindDepthTextures(const Texture2D* depth, const Texture2D* linearDepth, GRA } -const Texture2D* GetLuminance(const Texture2D* sourceImage, GRAPHICSTHREAD threadID) +const Texture2D* ComputeLuminance(const Texture2D* sourceImage, GRAPHICSTHREAD threadID) { GraphicsDevice* device = GetDevice(); @@ -8272,6 +8272,8 @@ const Texture2D* GetLuminance(const Texture2D* sourceImage, GRAPHICSTHREAD threa } if (luminance_map != nullptr) { + device->EventBegin("Compute Luminance", threadID); + // Pass 1 : Create luminance map from scene tex TextureDesc luminance_map_desc = luminance_map->GetDesc(); device->BindComputePSO(&CPSO[CSTYPE_LUMINANCE_PASS1], threadID); @@ -8300,6 +8302,8 @@ const Texture2D* GetLuminance(const Texture2D* sourceImage, GRAPHICSTHREAD threa device->UnbindUAVs(0, 1, threadID); + device->EventEnd(threadID); + return luminance_avg.back(); } diff --git a/WickedEngine/wiRenderer.h b/WickedEngine/wiRenderer.h index 079b1952c..bd7b0843f 100644 --- a/WickedEngine/wiRenderer.h +++ b/WickedEngine/wiRenderer.h @@ -151,6 +151,8 @@ namespace wiRenderer void DrawTracedScene(const wiSceneSystem::CameraComponent& camera, const wiGraphics::Texture2D* result, GRAPHICSTHREAD threadID); // Render the scene BVH with ray tracing void DrawTracedSceneBVH(GRAPHICSTHREAD threadID); + // Compute the luminance for the source image and return the texture containing the luminance value in pixel [0,0] + const wiGraphics::Texture2D* ComputeLuminance(const wiGraphics::Texture2D* sourceImage, GRAPHICSTHREAD threadID); // Render occluders against a depth buffer void OcclusionCulling_Render(GRAPHICSTHREAD threadID); @@ -280,7 +282,6 @@ namespace wiRenderer bool IsRequestedReflectionRendering(); void SetEnvironmentMap(wiGraphics::Texture2D* tex); const wiGraphics::Texture2D* GetEnvironmentMap(); - const wiGraphics::Texture2D* GetLuminance(const wiGraphics::Texture2D* sourceImage, GRAPHICSTHREAD threadID); const XMFLOAT4& GetWaterPlane(); void SetGameSpeed(float value); float GetGameSpeed(); diff --git a/WickedEngine/wiVersion.cpp b/WickedEngine/wiVersion.cpp index eccb974fe..cc3c32cdf 100644 --- a/WickedEngine/wiVersion.cpp +++ b/WickedEngine/wiVersion.cpp @@ -9,7 +9,7 @@ namespace wiVersion // minor features, major updates const int minor = 25; // minor bug fixes, alterations, refactors, updates - const int revision = 2; + const int revision = 3; long GetVersion()