Merge pull request #1297 from aws-lumberyard-dev/Atom/dmcdiar/ATOM-15767

[ATOM-15767] ReflectionScreenSpaceBlurPass uses a fixed number of mips

Gems/Atom/Feature/Common/Assets/Passes/ReflectionScreenSpaceBlur.pass

@@ -24,9 +24,9 @@
                     },
                     "ImageDescriptor": {
                         "Format": "R16G16B16A16_FLOAT",
-                        "MipLevels": "8",
                         "SharedQueueMask": "Graphics"
-                    }
+                    },
+                    "GenerateFullMipChain": true
                 }
             ],
             "Connections": [

Gems/Atom/Feature/Common/Assets/Passes/ReflectionScreenSpaceComposite.pass

@@ -5,7 +5,7 @@
     "ClassData": {
         "PassTemplate": {
             "Name": "ReflectionScreenSpaceCompositePassTemplate",
-            "PassClass": "FullScreenTriangle",
+            "PassClass": "ReflectionScreenSpaceCompositePass",
             "Slots": [
                 {
                     "Name": "TraceInput",

Gems/Atom/Feature/Common/Assets/Shaders/Reflections/ReflectionScreenSpaceComposite.azsl

@@ -37,6 +37,9 @@ ShaderResourceGroup PassSrg : SRG_PerPass
         AddressV = Clamp;
         AddressW = Clamp;
     };
+
+    // the max roughness mip level for sampling the previous frame image
+    uint m_maxMipLevel;
 }
 
 #include <Atom/RPI/ShaderResourceGroups/DefaultDrawSrg.azsli>
@@ -69,10 +72,6 @@ PSOutput MainPS(VSOutput IN, in uint sampleIndex : SV_SampleIndex)
     float4 positionWS = mul(ViewSrg::m_viewProjectionInverseMatrix, projectedPos);
     positionWS /= positionWS.w;
 
-    //float4 positionVS = mul(ViewSrg::m_projectionMatrixInverse, projectedPos);
-    //positionVS /= positionVS.w;
-    //float4 positionWS = mul(ViewSrg::m_viewMatrixInverse, positionVS);
-
     // compute ray from camera to surface position
     float3 cameraToPositionWS = normalize(positionWS.xyz - ViewSrg::m_worldPosition);
 
@@ -103,8 +102,7 @@ PSOutput MainPS(VSOutput IN, in uint sampleIndex : SV_SampleIndex)
     // compute the roughness mip to use in the previous frame image
     // remap the roughness mip into a lower range to more closely match the material roughness values
     const float MaxRoughness = 0.5f;
-    const float MaxRoughnessMip = 7;
-    float mip = saturate(roughness / MaxRoughness) * MaxRoughnessMip;
+    float mip = saturate(roughness / MaxRoughness) * PassSrg::m_maxMipLevel;
     
     // sample reflection value from the roughness mip
     float4 reflectionColor = float4(PassSrg::m_previousFrame.SampleLevel(PassSrg::LinearSampler, tracePrevUV, mip).rgb, 1.0f);  

Gems/Atom/Feature/Common/Code/Source/CommonSystemComponent.cpp

@@ -103,6 +103,7 @@
 #include <DiffuseGlobalIllumination/DiffuseGlobalIlluminationFeatureProcessor.h>
 #include <ReflectionScreenSpace/ReflectionScreenSpaceBlurPass.h>
 #include <ReflectionScreenSpace/ReflectionScreenSpaceBlurChildPass.h>
+#include <ReflectionScreenSpace/ReflectionScreenSpaceCompositePass.h>
 #include <ReflectionScreenSpace/ReflectionCopyFrameBufferPass.h>
 #include <OcclusionCullingPlane/OcclusionCullingPlaneFeatureProcessor.h>
 
@@ -283,6 +284,7 @@ namespace AZ
             // Add Reflection passes
             passSystem->AddPassCreator(Name("ReflectionScreenSpaceBlurPass"), &Render::ReflectionScreenSpaceBlurPass::Create);
             passSystem->AddPassCreator(Name("ReflectionScreenSpaceBlurChildPass"), &Render::ReflectionScreenSpaceBlurChildPass::Create);
+            passSystem->AddPassCreator(Name("ReflectionScreenSpaceCompositePass"), &Render::ReflectionScreenSpaceCompositePass::Create);
             passSystem->AddPassCreator(Name("ReflectionCopyFrameBufferPass"), &Render::ReflectionCopyFrameBufferPass::Create);
 
             // Add RayTracing pas

Gems/Atom/Feature/Common/Code/Source/ReflectionScreenSpace/ReflectionScreenSpaceBlurPass.h

@@ -37,6 +37,9 @@ namespace AZ
             //! to store the previous frame image
             Data::Instance<RPI::AttachmentImage>& GetFrameBufferImageAttachment() { return m_frameBufferImageAttachment; }
 
+            //! Returns the number of mip levels in the blur
+            uint32_t GetNumBlurMips() const { return m_numBlurMips; }
+
         private:
             explicit ReflectionScreenSpaceBlurPass(const RPI::PassDescriptor& descriptor);
 

Gems/Atom/Feature/Common/Code/Source/ReflectionScreenSpace/ReflectionScreenSpaceCompositePass.cpp

@@ -0,0 +1,58 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "ReflectionScreenSpaceCompositePass.h"
+#include "ReflectionScreenSpaceBlurPass.h"
+#include <Atom/RPI.Public/Pass/PassSystemInterface.h>
+#include <Atom/RPI.Public/Pass/PassFilter.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        RPI::Ptr<ReflectionScreenSpaceCompositePass> ReflectionScreenSpaceCompositePass::Create(const RPI::PassDescriptor& descriptor)
+        {
+            RPI::Ptr<ReflectionScreenSpaceCompositePass> pass = aznew ReflectionScreenSpaceCompositePass(descriptor);
+            return AZStd::move(pass);
+        }
+
+        ReflectionScreenSpaceCompositePass::ReflectionScreenSpaceCompositePass(const RPI::PassDescriptor& descriptor)
+            : RPI::FullscreenTrianglePass(descriptor)
+        {
+        }
+
+        void ReflectionScreenSpaceCompositePass::CompileResources([[maybe_unused]] const RHI::FrameGraphCompileContext& context)
+        {
+            if (!m_shaderResourceGroup)
+            {
+                return;
+            }
+
+            RPI::PassHierarchyFilter passFilter(AZ::Name("ReflectionScreenSpaceBlurPass"));
+            const AZStd::vector<RPI::Pass*>& passes = RPI::PassSystemInterface::Get()->FindPasses(passFilter);
+            if (!passes.empty())
+            {
+                Render::ReflectionScreenSpaceBlurPass* blurPass = azrtti_cast<ReflectionScreenSpaceBlurPass*>(passes.front());
+
+                // compute the max mip level based on the available mips in the previous frame image, and capping it
+                // to stay within a range that has reasonable data
+                const uint32_t MaxNumRoughnessMips = 8;
+                uint32_t maxMipLevel = AZStd::min(MaxNumRoughnessMips, blurPass->GetNumBlurMips()) - 1;
+
+                auto constantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_maxMipLevel"));
+                m_shaderResourceGroup->SetConstant(constantIndex, maxMipLevel);
+            }
+
+            FullscreenTrianglePass::CompileResources(context);
+        }
+    }   // namespace RPI
+}   // namespace AZ

Gems/Atom/Feature/Common/Code/Source/ReflectionScreenSpace/ReflectionScreenSpaceCompositePass.h

@@ -0,0 +1,43 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <Atom/RPI.Public/Pass/Pass.h>
+#include <Atom/RPI.Public/Pass/FullscreenTrianglePass.h>
+#include <Atom/RPI.Public/Shader/ShaderResourceGroup.h>
+#include <Atom/RPI.Public/Shader/Shader.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        //! This pass composites the screenspace reflection trace onto the reflection buffer.
+        class ReflectionScreenSpaceCompositePass
+            : public RPI::FullscreenTrianglePass
+        {
+            AZ_RPI_PASS(ReflectionScreenSpaceCompositePass);
+
+        public:
+            AZ_RTTI(Render::ReflectionScreenSpaceCompositePass, "{88739CC9-C3F1-413A-A527-9916C697D93A}", FullscreenTrianglePass);
+            AZ_CLASS_ALLOCATOR(Render::ReflectionScreenSpaceCompositePass, SystemAllocator, 0);
+
+            //! Creates a new pass without a PassTemplate
+            static RPI::Ptr<ReflectionScreenSpaceCompositePass> Create(const RPI::PassDescriptor& descriptor);
+
+        private:
+            explicit ReflectionScreenSpaceCompositePass(const RPI::PassDescriptor& descriptor);
+
+            // Pass Overrides...
+            void CompileResources(const RHI::FrameGraphCompileContext& context) override;
+        };
+    }   // namespace RPI
+}   // namespace AZ

Gems/Atom/Feature/Common/Code/atom_feature_common_files.cmake

@@ -267,6 +267,8 @@ set(FILES
     Source/ReflectionScreenSpace/ReflectionScreenSpaceBlurPass.h
     Source/ReflectionScreenSpace/ReflectionScreenSpaceBlurChildPass.cpp
     Source/ReflectionScreenSpace/ReflectionScreenSpaceBlurChildPass.h
+    Source/ReflectionScreenSpace/ReflectionScreenSpaceCompositePass.cpp
+    Source/ReflectionScreenSpace/ReflectionScreenSpaceCompositePass.h
     Source/ReflectionScreenSpace/ReflectionCopyFrameBufferPass.cpp
     Source/ReflectionScreenSpace/ReflectionCopyFrameBufferPass.h
     Source/ScreenSpace/DeferredFogSettings.cpp