Merge pull request o3de#17234 from hosea1008/aa_switchable

AMZN-alexpete · web-flow · commit b174ef8b71de · 2024-01-11T10:16:17.000-08:00
Support switching anti-aliasing and multi-sampling from CVar
diff --git a/Gems/Atom/Bootstrap/Code/Include/Atom/Bootstrap/BootstrapRequestBus.h b/Gems/Atom/Bootstrap/Code/Include/Atom/Bootstrap/BootstrapRequestBus.h
@@ -25,6 +25,8 @@ namespace AZ::Render::Bootstrap
         virtual AZ::RPI::ScenePtr GetOrCreateAtomSceneFromAzScene(AzFramework::Scene* scene) = 0;
         virtual bool EnsureDefaultRenderPipelineInstalledForScene(AZ::RPI::ScenePtr scene, AZ::RPI::ViewportContextPtr viewportContext) = 0;
         virtual void SwitchRenderPipeline(const AZ::RPI::RenderPipelineDescriptor& newRenderPipelineDesc, AZ::RPI::ViewportContextPtr viewportContext) = 0;
+        virtual void SwitchAntiAliasing(const AZStd::string& newAntiAliasing, AZ::RPI::ViewportContextPtr viewportContext) = 0;
+        virtual void SwitchMultiSample(const uint16_t newSampleCount, AZ::RPI::ViewportContextPtr viewportContext) = 0;
 
     protected:
         ~Request() = default;
diff --git a/Gems/Atom/Bootstrap/Code/Source/BootstrapSystemComponent.cpp b/Gems/Atom/Bootstrap/Code/Source/BootstrapSystemComponent.cpp
@@ -74,6 +74,45 @@ void cvar_r_renderPipelinePath_Changed(const AZ::CVarFixedString& newPipelinePat
     }
 }
 
+void cvar_r_antiAliasing_Changed(const AZ::CVarFixedString& newAntiAliasing)
+{
+    auto viewportContextManager = AZ::Interface<AZ::RPI::ViewportContextRequestsInterface>::Get();
+    if (!viewportContextManager)
+    {
+        return;
+    }
+    auto viewportContext = viewportContextManager->GetDefaultViewportContext();
+    if (!viewportContext)
+    {
+        return;
+    }
+
+    AZ::Render::Bootstrap::RequestBus::Broadcast(&AZ::Render::Bootstrap::RequestBus::Events::SwitchAntiAliasing, newAntiAliasing.c_str(), viewportContext);
+}
+
+void cvar_r_multiSample_Changed(const uint16_t& newSampleCount)
+{
+    auto viewportContextManager = AZ::Interface<AZ::RPI::ViewportContextRequestsInterface>::Get();
+    if (!viewportContextManager)
+    {
+        return;
+    }
+    auto viewportContext = viewportContextManager->GetDefaultViewportContext();
+    if (!viewportContext)
+    {
+        return;
+    }
+    if (newSampleCount > 0 && ((newSampleCount & (newSampleCount - 1))) == 0)
+    {
+        AZ::Render::Bootstrap::RequestBus::Broadcast(&AZ::Render::Bootstrap::RequestBus::Events::SwitchMultiSample, AZStd::clamp(newSampleCount, uint16_t(1), uint16_t(8)), viewportContext);
+    }
+    else
+    {
+        AZ_Warning("SetMultiSampleCount", false, "Failed to set multi-sample count %d: invalid multi-sample count", newSampleCount);
+    }
+}
+
+
 AZ_CVAR(AZ::CVarFixedString, r_renderPipelinePath, AZ_TRAIT_BOOTSTRAPSYSTEMCOMPONENT_PIPELINE_NAME, cvar_r_renderPipelinePath_Changed, AZ::ConsoleFunctorFlags::DontReplicate, "The asset (.azasset) path for default render pipeline");
 AZ_CVAR(AZ::CVarFixedString, r_default_openxr_pipeline_name, "passes/MultiViewRenderPipeline.azasset", nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Default openXr render pipeline name");
 AZ_CVAR(AZ::CVarFixedString, r_default_openxr_left_pipeline_name, "passes/XRLeftRenderPipeline.azasset", nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Default openXr Left eye render pipeline name");
@@ -83,6 +122,8 @@ AZ_CVAR(uint32_t, r_height, 1080, nullptr, AZ::ConsoleFunctorFlags::DontReplicat
 AZ_CVAR(uint32_t, r_fullscreen, false, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Starting fullscreen state.");
 AZ_CVAR(uint32_t, r_resolutionMode, 0, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "0: render resolution same as window client area size, 1: render resolution use the values specified by r_width and r_height");
 AZ_CVAR(float, r_renderScale, 1.0f, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Scale to apply to the window resolution.");
+AZ_CVAR(AZ::CVarFixedString, r_antiAliasing, "", cvar_r_antiAliasing_Changed, AZ::ConsoleFunctorFlags::DontReplicate, "The anti-aliasing to be used for the current render pipeline. Available options: MSAA, TAA, SMAA");
+AZ_CVAR(uint16_t, r_multiSampleCount, 0, cvar_r_multiSample_Changed, AZ::ConsoleFunctorFlags::DontReplicate, "The multi-sample count to be used for the current render pipeline."); // 0 stands for unchanged, load the default setting from the pipeline itself
 
 namespace AZ
 {
@@ -243,6 +284,24 @@ namespace AZ
                         }
                     }
                 }
+
+                const AZStd::string multiSampleCvarName("r_multiSampleCount");
+                if (pCmdLine->HasSwitch(multiSampleCvarName))
+                {
+                    auto numValues = pCmdLine->GetNumSwitchValues(multiSampleCvarName);
+                    if (numValues > 0)
+                    {
+                        auto valueStr = pCmdLine->GetSwitchValue(multiSampleCvarName);
+                        if (AZ::StringFunc::LooksLikeInt(valueStr.c_str()))
+                        {
+                            auto multiSample = AZ::StringFunc::ToInt(valueStr.c_str());
+                            if (multiSample > 0)
+                            {
+                                r_multiSampleCount = static_cast<uint16_t>(multiSample);
+                            }
+                        }
+                    }
+                }
             }
 
             void BootstrapSystemComponent::Activate()
@@ -507,11 +566,18 @@ namespace AZ
                         }
                     }
 
-                    if (!LoadPipeline(scene, viewportContext, pipelineName, AZ::RPI::ViewType::Default, multisampleState))
+                    RPI::RenderPipelinePtr renderPipeline = LoadPipeline(scene, viewportContext, pipelineName, AZ::RPI::ViewType::Default, multisampleState);
+                    if (!renderPipeline)
                     {
                         return false;
                     }
 
+                    AZ::CVarFixedString antiAliasing = static_cast<AZ::CVarFixedString>(r_antiAliasing);
+                    if (antiAliasing != "")
+                    {
+                        renderPipeline->SetActiveAAMethod(antiAliasing.c_str());
+                    }
+
                     // As part of our initialization we need to create the BRDF texture generation pipeline
                     AZ::RPI::RenderPipelineDescriptor pipelineDesc;
                     pipelineDesc.m_mainViewTagName = "MainCamera";
@@ -564,6 +630,11 @@ namespace AZ
                 // been created so the same values are applied to all.
                 // As it cannot be applied MSAA values per pipeline,
                 // it's setting the MSAA state from the last pipeline loaded.
+                const auto cvarMultiSample = static_cast<uint16_t>(r_multiSampleCount);
+                if (cvarMultiSample > 0 && ((cvarMultiSample & (cvarMultiSample - 1))) == 0)
+                {
+                    multisampleState.m_samples = static_cast<uint16_t>(cvarMultiSample);
+                }
                 AZ::RPI::RPISystemInterface::Get()->SetApplicationMultisampleState(multisampleState);
 
                 // Send notification when the scene and its pipeline are ready.
@@ -612,6 +683,19 @@ namespace AZ
                 AZ::RPI::RPISystemInterface::Get()->SetApplicationMultisampleState(newRenderPipeline->GetRenderSettings().m_multisampleState);
             }
 
+            void BootstrapSystemComponent::SwitchAntiAliasing(const AZStd::string& newAntiAliasing, AZ::RPI::ViewportContextPtr viewportContext)
+            {
+                auto defaultRenderPipeline = viewportContext->GetRenderScene()->GetDefaultRenderPipeline();
+                defaultRenderPipeline->SetActiveAAMethod(newAntiAliasing);
+            }
+
+            void BootstrapSystemComponent::SwitchMultiSample(const uint16_t newSampleCount, AZ::RPI::ViewportContextPtr viewportContext)
+            {
+                auto multiSampleStete = viewportContext->GetRenderScene()->GetDefaultRenderPipeline()->GetRenderSettings().m_multisampleState;
+                multiSampleStete.m_samples = newSampleCount;
+                AZ::RPI::RPISystemInterface::Get()->SetApplicationMultisampleState(multiSampleStete);
+            }
+
             RPI::RenderPipelinePtr BootstrapSystemComponent::LoadPipeline( AZ::RPI::ScenePtr scene, AZ::RPI::ViewportContextPtr viewportContext,
                                                     AZStd::string_view pipelineName, AZ::RPI::ViewType viewType, AZ::RHI::MultisampleState& multisampleState)
             {
diff --git a/Gems/Atom/Bootstrap/Code/Source/BootstrapSystemComponent.h b/Gems/Atom/Bootstrap/Code/Source/BootstrapSystemComponent.h
@@ -70,6 +70,8 @@ namespace AZ
                 AZ::RPI::ScenePtr GetOrCreateAtomSceneFromAzScene(AzFramework::Scene* scene) override;
                 bool EnsureDefaultRenderPipelineInstalledForScene(AZ::RPI::ScenePtr scene, AZ::RPI::ViewportContextPtr viewportContext) override;
                 void SwitchRenderPipeline(const AZ::RPI::RenderPipelineDescriptor& newRenderPipelineDesc, AZ::RPI::ViewportContextPtr viewportContext) override;
+                void SwitchAntiAliasing(const AZStd::string& newAntiAliasing, AZ::RPI::ViewportContextPtr viewportContext) override;
+                void SwitchMultiSample(const uint16_t newSampleCount, AZ::RPI::ViewportContextPtr viewportContext) override;
 
             protected:
                 // Component overrides ...
diff --git a/Gems/Atom/Feature/Common/Assets/Passes/MainRenderPipeline.azasset b/Gems/Atom/Feature/Common/Assets/Passes/MainRenderPipeline.azasset
@@ -12,6 +12,7 @@
             "MultisampleState": {
                 "samples": 2
             }
-        }
+        },
+        "DefaultAAMethod": "MSAA"
     }
-}
+}
diff --git a/Gems/Atom/Feature/Common/Assets/Passes/PostProcessParent.pass b/Gems/Atom/Feature/Common/Assets/Passes/PostProcessParent.pass
@@ -66,6 +66,7 @@
             "PassRequests": [
                 {
                     "Name": "SMAA1xApplyLinearHDRColorPass",
+                    "Enabled": false,
                     "TemplateName": "SMAA1xApplyLinearHDRColorTemplate",
                     "Connections": [
                         {
diff --git a/Gems/Atom/RPI/Code/Include/Atom/RPI.Public/RenderPipeline.h b/Gems/Atom/RPI/Code/Include/Atom/RPI.Public/RenderPipeline.h
@@ -98,6 +98,12 @@ namespace AZ
                                                                    const ViewType viewType = ViewType::Default);
             static RenderPipelinePtr CreateRenderPipelineForWindow(Data::Asset<AnyAsset> pipelineAsset, const WindowContext& windowContext);
 
+            // Anti-aliasing
+            bool SetActiveAAMethod(AZStd::string aaMethodName);
+            static AntiAliasingMode GetAAMethodByName(AZStd::string aaMethodName);
+            static AZStd::string GetAAMethodNameByIndex(AntiAliasingMode aaMethodIndex);            
+            AntiAliasingMode GetActiveAAMethod();
+
             //! Create a render pipeline which renders to the specified attachment image
             //! The render pipeline's root pass is created from the pass template specified from RenderPipelineDescriptor::m_rootPassTemplate
             //! The input AttachmentImageAsset is used to connect to first output attachment of the root pass template
@@ -301,6 +307,11 @@ namespace AZ
             void SetDrawFilterTags(RHI::DrawFilterTagRegistry* tagRegistry);
             void ReleaseDrawFilterTags(RHI::DrawFilterTagRegistry* tagRegistry);
 
+            // AA method
+            static bool SetAAMethod(RenderPipeline* pipeline, AZStd::string aaMethodName);
+            static bool SetAAMethod(RenderPipeline* pipeline, AntiAliasingMode aaMethod);
+            static bool EnablePass(RenderPipeline* pipeline, Name& passName, bool enable);
+
             // End of functions accessed by Scene class
             //////////////////////////////////////////////////
 
@@ -355,6 +366,8 @@ namespace AZ
             // The descriptor used to created this render pipeline
             RenderPipelineDescriptor m_descriptor;
 
+            AntiAliasingMode m_activeAAMethod = AntiAliasingMode::MSAA;
+
             // View type associated with the Render Pipeline.
             ViewType m_viewType = ViewType::Default;
 
diff --git a/Gems/Atom/RPI/Code/Include/Atom/RPI.Reflect/System/RenderPipelineDescriptor.h b/Gems/Atom/RPI/Code/Include/Atom/RPI.Reflect/System/RenderPipelineDescriptor.h
@@ -18,6 +18,16 @@ namespace AZ
 
     namespace RPI
     {
+         // Rendering Settings
+        enum class AntiAliasingMode
+        {
+            MSAA,
+            SMAA,
+            TAA,
+            Default = -1
+        };
+
+
         //! A descriptor used to create a render pipeline
         struct RenderPipelineDescriptor final
         {
@@ -49,6 +59,9 @@ namespace AZ
 
             //! Flag indicating if this pipeline can accept modifications from scene's feature processors
             bool m_allowModification = false;
+
+            //! Include(MSAA, TAA, SMAA)
+            AZStd::string m_defaultAAMethod = "MSAA";
         };
 
     } // namespace RPI
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/RenderPipeline.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/RenderPipeline.cpp
@@ -172,10 +172,12 @@ namespace AZ
             pipeline->m_nameId = desc.m_name.data();
             pipeline->m_materialPipelineTagName = Name{desc.m_materialPipelineTag};
             pipeline->m_activeRenderSettings = desc.m_renderSettings;
+            pipeline->m_activeAAMethod = GetAAMethodByName(desc.m_defaultAAMethod);
             pipeline->m_passTree.m_rootPass->SetRenderPipeline(pipeline);
             pipeline->m_passTree.m_rootPass->m_flags.m_isPipelineRoot = true;
             pipeline->m_passTree.m_rootPass->ManualPipelineBuildAndInitialize();
-
+            
+            pipeline->SetActiveAAMethod(desc.m_defaultAAMethod);
             pipeline->UpdateViewportScissor();
         }
 
@@ -624,6 +626,8 @@ namespace AZ
                     newRoot->DebugPrint();
 #endif
                 }
+                
+                SetAAMethod(this, m_activeAAMethod);
             }
 
             // Build and initialize any queued passes
@@ -651,9 +655,7 @@ namespace AZ
                         SceneRequestBus::Event(m_scene->GetId(), &SceneRequest::PipelineStateLookupNeedsRebuild);
                     }
                 }
-                                
                 UpdateViewportScissor();
-
                 // Reset change flags
                 m_pipelinePassChanges = PipelinePassChanges::NoPassChanges;
 
@@ -948,5 +950,95 @@ namespace AZ
         {
             return m_viewType;
         }
+
+        // ---------------------------- Anti-aliasing
+
+        bool RenderPipeline::SetActiveAAMethod(AZStd::string aaMethodName)
+        {
+            AntiAliasingMode antiAliasingMode = GetAAMethodByName(aaMethodName);
+            if (antiAliasingMode == AntiAliasingMode::Default)
+            {
+                return false;
+            }
+            m_activeAAMethod = antiAliasingMode;
+            return SetAAMethod(this, m_activeAAMethod);
+        }
+
+        AntiAliasingMode RenderPipeline::GetActiveAAMethod()
+        {
+            return m_activeAAMethod;
+        }
+
+        AntiAliasingMode RenderPipeline::GetAAMethodByName(AZStd::string aaMethodName)
+        {
+            const AZStd::unordered_map<AZStd::string, AntiAliasingMode> AAMethodsLookup = {
+                {"MSAA", AntiAliasingMode::MSAA}, {"SMAA", AntiAliasingMode::SMAA}, 
+                {"TAA", AntiAliasingMode::TAA}
+            };
+ 
+            auto findIt = AAMethodsLookup.find(aaMethodName);
+            if (findIt != AAMethodsLookup.end())
+            {
+                return findIt->second;
+            }
+            return AntiAliasingMode::Default;
+        }        
+
+        AZStd::string RenderPipeline::GetAAMethodNameByIndex(AntiAliasingMode aaMethodIndex)
+        {
+            const AZStd::unordered_map<AntiAliasingMode, AZStd::string> AAMethodNameLookup = {
+                {AntiAliasingMode::MSAA, "MSAA"}, {AntiAliasingMode::SMAA, "SMAA"}, 
+                {AntiAliasingMode::TAA, "TAA"}
+            };
+ 
+            auto findIt = AAMethodNameLookup.find(aaMethodIndex);
+            if (findIt != AAMethodNameLookup.end())
+            {
+                return findIt->second;
+            }
+            return "MSAA";
+        }
+
+        bool RenderPipeline::EnablePass(RenderPipeline* pipeline, Name& passName, bool enable)
+        {
+            PassFilter passFilter = PassFilter::CreateWithPassName(passName, pipeline);
+            Ptr<Pass> aaPass = PassSystemInterface::Get()->FindFirstPass(passFilter);
+            if (!aaPass)
+            {
+                return false;
+            }
+            if (aaPass->IsEnabled() != enable)
+            {
+                aaPass->SetEnabled(enable);
+            }
+            return true;
+        }
+
+        bool RenderPipeline::SetAAMethod(RenderPipeline* pipeline, AZStd::string aaMethodName)
+        {
+            AntiAliasingMode antiAliasingMode = GetAAMethodByName(aaMethodName);
+            return SetAAMethod(pipeline, antiAliasingMode);
+        }
+
+        bool RenderPipeline::SetAAMethod(RenderPipeline* pipeline, AntiAliasingMode antiAliasingMode)
+        {
+            if (antiAliasingMode == AntiAliasingMode::Default)
+            {
+                return false;
+            }
+
+            const AZStd::unordered_map<AntiAliasingMode, AZStd::vector<Name>> AAPassNamesLookup = {
+                {AntiAliasingMode::SMAA, {Name("SMAA1xApplyLinearHDRColorPass")}}, 
+                {AntiAliasingMode::TAA, {Name("TaaPass"), Name("ContrastAdaptiveSharpeningPass")}}
+            };
+
+            for (auto& aaPassMap : AAPassNamesLookup)
+            {
+                AZStd::for_each(aaPassMap.second.begin(), aaPassMap.second.end(), [&pipeline, &aaPassMap, &antiAliasingMode](Name passName){
+                    EnablePass(pipeline, passName, aaPassMap.first == antiAliasingMode);
+                });
+            }
+            return true;
+        }
     }
 }
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Reflect/System/RenderPipelineDescriptor.cpp b/Gems/Atom/RPI/Code/Source/RPI.Reflect/System/RenderPipelineDescriptor.cpp
@@ -26,6 +26,7 @@ namespace AZ
                     ->Field("MaterialPipelineTag", &RenderPipelineDescriptor::m_materialPipelineTag)
                     ->Field("ExecuteOnce", &RenderPipelineDescriptor::m_executeOnce)
                     ->Field("RenderSettings", &RenderPipelineDescriptor::m_renderSettings)
+                    ->Field("DefaultAAMethod", &RenderPipelineDescriptor::m_defaultAAMethod)
                     ->Field("AllowModification", &RenderPipelineDescriptor::m_allowModification)
                 ;
             }
diff --git a/Gems/AtomLyIntegration/AtomViewportDisplayInfo/Code/Source/AtomViewportDisplayInfoSystemComponent.cpp b/Gems/AtomLyIntegration/AtomViewportDisplayInfo/Code/Source/AtomViewportDisplayInfoSystemComponent.cpp

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@`
`12`	`12`	`"MultisampleState": {`
`13`	`13`	`"samples": 2`
`14`	`14`	`}`
`15`		`- }`
	`15`	`+ },`
	`16`	`+ "DefaultAAMethod": "MSAA"`
`16`	`17`	`}`
`17`		`-}`
	`18`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -66,6 +66,7 @@`
`66`	`66`	`"PassRequests": [`
`67`	`67`	`{`
`68`	`68`	`"Name": "SMAA1xApplyLinearHDRColorPass",`
	`69`	`+ "Enabled": false,`
`69`	`70`	`"TemplateName": "SMAA1xApplyLinearHDRColorTemplate",`
`70`	`71`	`"Connections": [`
`71`	`72`	`{`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ namespace AZ`
`26`	`26`	`->Field("MaterialPipelineTag", &RenderPipelineDescriptor::m_materialPipelineTag)`
`27`	`27`	`->Field("ExecuteOnce", &RenderPipelineDescriptor::m_executeOnce)`
`28`	`28`	`->Field("RenderSettings", &RenderPipelineDescriptor::m_renderSettings)`
	`29`	`+ ->Field("DefaultAAMethod", &RenderPipelineDescriptor::m_defaultAAMethod)`
`29`	`30`	`->Field("AllowModification", &RenderPipelineDescriptor::m_allowModification)`
`30`	`31`	`;`
`31`	`32`	`}`