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

engine/src/Rendering/Internal/RenderPipelineFactory.cpp

@@ -41,6 +41,18 @@ std::shared_ptr<const RenderPipelineAsset> CreateFallbackRenderPipelineAsset() {
     return std::make_shared<Pipelines::ScriptableRenderPipelineHostAsset>();
 }
 
+std::shared_ptr<const RenderPipelineAsset> CreatePipelineRendererAssetByKey(
+    const std::string& key) {
+    if (key == "BuiltinForward") {
+        static const std::shared_ptr<const RenderPipelineAsset>
+            s_builtinForwardPipelineAsset =
+                std::make_shared<Pipelines::BuiltinForwardPipelineAsset>();
+        return s_builtinForwardPipelineAsset;
+    }
+
+    return nullptr;
+}
+
 std::shared_ptr<const RenderPipelineAsset> ResolveRenderPipelineAssetOrDefault(
     std::shared_ptr<const RenderPipelineAsset> preferredAsset) {
     if (preferredAsset != nullptr) {
@@ -112,12 +124,10 @@ std::unique_ptr<RenderPipeline> CreateRenderPipelineOrDefault(
 std::unique_ptr<NativeSceneRenderer> CreateNativeSceneRendererFromAsset(
     const std::shared_ptr<const RenderPipelineAsset>& preferredAsset,
     std::shared_ptr<const RenderPipelineAsset>* outResolvedAsset) {
-    const std::shared_ptr<const RenderPipelineAsset> resolvedAsset =
-        ResolveRenderPipelineAssetOrDefault(preferredAsset);
     if (std::unique_ptr<NativeSceneRenderer> sceneRenderer =
-            TryCreateNativeSceneRendererFromAsset(resolvedAsset)) {
+            TryCreateNativeSceneRendererFromAsset(preferredAsset)) {
         if (outResolvedAsset != nullptr) {
-            *outResolvedAsset = resolvedAsset;
+            *outResolvedAsset = preferredAsset;
         }
         return sceneRenderer;
     }

engine/src/Rendering/Internal/RenderPipelineFactory.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <string>
 #include <memory>
 
 namespace XCEngine {
@@ -13,6 +14,8 @@ namespace Internal {
 
 std::shared_ptr<const RenderPipelineAsset> CreateConfiguredRenderPipelineAsset();
 std::shared_ptr<const RenderPipelineAsset> CreateFallbackRenderPipelineAsset();
+std::shared_ptr<const RenderPipelineAsset> CreatePipelineRendererAssetByKey(
+    const std::string& key);
 
 std::shared_ptr<const RenderPipelineAsset> ResolveRenderPipelineAssetOrDefault(
     std::shared_ptr<const RenderPipelineAsset> preferredAsset);

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: