refactor(srp): let universal assets declare native backend keys

engine/src/Scripting/Mono/MonoScriptRuntime.cpp

@@ -15,7 +15,6 @@
 #include "Rendering/Internal/RenderPipelineFactory.h"
 #include "Rendering/Passes/BuiltinVectorFullscreenPass.h"
 #include "Rendering/Planning/FullscreenPassDesc.h"
-#include "Rendering/Pipelines/BuiltinForwardPipeline.h"
 #include "Rendering/Pipelines/NativeSceneRecorder.h"
 #include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
 #include "Rendering/RenderPipelineStageGraphContract.h"
@@ -743,6 +742,8 @@ private:
         MonoObject* assetObject) const;
     MonoMethod* ResolveGetDefaultFinalColorSettingsMethod(
         MonoObject* assetObject) const;
+    MonoMethod* ResolveGetPipelineRendererAssetKeyMethod(
+        MonoObject* assetObject) const;
 
     MonoScriptRuntime* m_runtime = nullptr;
     std::weak_ptr<void> m_runtimeLifetime;
@@ -751,8 +752,12 @@ private:
     mutable MonoMethod* m_createPipelineMethod = nullptr;
     mutable MonoMethod* m_configureCameraRenderRequestMethod = nullptr;
     mutable MonoMethod* m_getDefaultFinalColorSettingsMethod = nullptr;
+    mutable MonoMethod* m_getPipelineRendererAssetKeyMethod = nullptr;
     mutable bool m_ownsManagedAssetHandle = false;
     mutable bool m_assetCreationAttempted = false;
+    mutable bool m_pipelineRendererAssetResolved = false;
+    mutable std::shared_ptr<const Rendering::RenderPipelineAsset>
+        m_pipelineRendererAsset = nullptr;
 };
 
 class MonoManagedRenderPipelineStageRecorder final
@@ -1088,10 +1093,42 @@ bool MonoManagedRenderPipelineAssetRuntime::TryGetDefaultFinalColorSettings(
 
 std::shared_ptr<const Rendering::RenderPipelineAsset>
 MonoManagedRenderPipelineAssetRuntime::GetPipelineRendererAsset() const {
-    static const std::shared_ptr<const Rendering::RenderPipelineAsset>
-        s_builtinForwardPipelineAsset =
-            std::make_shared<Rendering::Pipelines::BuiltinForwardPipelineAsset>();
-    return s_builtinForwardPipelineAsset;
+    if (m_pipelineRendererAssetResolved) {
+        return m_pipelineRendererAsset;
+    }
+
+    m_pipelineRendererAssetResolved = true;
+    m_pipelineRendererAsset.reset();
+    if (!EnsureManagedAsset()) {
+        return nullptr;
+    }
+
+    MonoObject* const assetObject = GetManagedAssetObject();
+    MonoMethod* const method =
+        ResolveGetPipelineRendererAssetKeyMethod(assetObject);
+    if (assetObject == nullptr || method == nullptr) {
+        return nullptr;
+    }
+
+    MonoObject* managedKeyObject = nullptr;
+    if (!m_runtime->InvokeManagedMethod(
+            assetObject,
+            method,
+            nullptr,
+            &managedKeyObject)) {
+        return nullptr;
+    }
+
+    const std::string pipelineRendererAssetKey =
+        MonoStringToUtf8(reinterpret_cast<MonoString*>(managedKeyObject));
+    if (pipelineRendererAssetKey.empty()) {
+        return nullptr;
+    }
+
+    m_pipelineRendererAsset =
+        Rendering::Internal::CreatePipelineRendererAssetByKey(
+            pipelineRendererAssetKey);
+    return m_pipelineRendererAsset;
 }
 
 bool MonoManagedRenderPipelineAssetRuntime::CreateManagedPipeline(
@@ -1199,6 +1236,9 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const {
     m_createPipelineMethod = nullptr;
     m_configureCameraRenderRequestMethod = nullptr;
     m_getDefaultFinalColorSettingsMethod = nullptr;
+    m_getPipelineRendererAssetKeyMethod = nullptr;
+    m_pipelineRendererAsset.reset();
+    m_pipelineRendererAssetResolved = false;
     const bool ownsManagedAssetHandle = m_ownsManagedAssetHandle;
     m_ownsManagedAssetHandle = false;
     m_assetCreationAttempted = false;
@@ -1262,6 +1302,20 @@ MonoManagedRenderPipelineAssetRuntime::ResolveGetDefaultFinalColorSettingsMethod
     return m_getDefaultFinalColorSettingsMethod;
 }
 
+MonoMethod*
+MonoManagedRenderPipelineAssetRuntime::ResolveGetPipelineRendererAssetKeyMethod(
+    MonoObject* assetObject) const {
+    if (m_getPipelineRendererAssetKeyMethod == nullptr) {
+        m_getPipelineRendererAssetKeyMethod =
+            m_runtime->ResolveManagedMethod(
+                assetObject,
+                "GetPipelineRendererAssetKey",
+                0);
+    }
+
+    return m_getPipelineRendererAssetKeyMethod;
+}
+
 class MonoManagedRenderPipelineBridge final
     : public Rendering::Pipelines::ManagedRenderPipelineBridge {
 public: