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

tests/Rendering/unit/test_camera_scene_renderer.cpp

@@ -11,6 +11,7 @@
 #include <XCEngine/Rendering/Execution/CameraRenderer.h>
 #include <XCEngine/Rendering/Execution/RenderPipelineHost.h>
 #include <XCEngine/Rendering/Graph/RenderGraph.h>
+#include <XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h>
 #include <XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h>
 #include <XCEngine/Rendering/Pipelines/ScriptableRenderPipelineHost.h>
 #include <XCEngine/Rendering/RenderPassGraphContract.h>
@@ -22,6 +23,7 @@
 #include <XCEngine/Scene/Scene.h>
 
 #include "Rendering/Execution/Internal/CameraFrameGraph/SurfaceResolver.h"
+#include "Rendering/Internal/RenderPipelineFactory.h"
 #include <functional>
 #include <memory>
 #include <string>
@@ -4508,6 +4510,39 @@ TEST(ScriptableRenderPipelineHost_Test, BindsCurrentPipelineRendererIntoStageRec
         host.GetPipelineRenderer());
 }
 
+TEST(
+    RenderPipelineFactory_Test,
+    NullPreferredAssetSkipsConfiguredManagedPipelineAssetWhenCreatingNativeSceneRenderer) {
+    Pipelines::ClearManagedRenderPipelineBridge();
+    Pipelines::ClearConfiguredManagedRenderPipelineAssetDescriptor();
+
+    const Pipelines::ManagedRenderPipelineAssetDescriptor descriptor = {
+        "GameScripts",
+        "Gameplay",
+        "ManagedRenderPipelineProbeAsset"
+    };
+    auto bridgeState = std::make_shared<MockManagedRenderPipelineBridgeState>();
+    Pipelines::SetManagedRenderPipelineBridge(
+        std::make_shared<MockManagedRenderPipelineBridge>(bridgeState));
+    Pipelines::SetConfiguredManagedRenderPipelineAssetDescriptor(descriptor);
+
+    std::shared_ptr<const RenderPipelineAsset> resolvedAsset = nullptr;
+    std::unique_ptr<NativeSceneRenderer> sceneRenderer =
+        Internal::CreateNativeSceneRendererFromAsset(
+            nullptr,
+            &resolvedAsset);
+
+    ASSERT_NE(sceneRenderer, nullptr);
+    EXPECT_EQ(resolvedAsset, nullptr);
+    EXPECT_NE(
+        dynamic_cast<Pipelines::BuiltinForwardPipeline*>(sceneRenderer.get()),
+        nullptr);
+    EXPECT_EQ(bridgeState->createAssetRuntimeCalls, 0);
+
+    Pipelines::ClearConfiguredManagedRenderPipelineAssetDescriptor();
+    Pipelines::ClearManagedRenderPipelineBridge();
+}
+
 TEST(
     ScriptableRenderPipelineHost_Test,
     FallsBackToRendererWhenStageRecorderDeclinesRecording) {

tests/scripting/test_mono_script_runtime.cpp

@@ -2462,6 +2462,127 @@ TEST_F(
         nullptr);
 }
 
+TEST_F(
+    MonoScriptRuntimeTest,
+    ScriptCoreUniversalRenderPipelineAssetExposesBuiltinForwardRendererAsset) {
+    const auto bridge =
+        XCEngine::Rendering::Pipelines::GetManagedRenderPipelineBridge();
+    ASSERT_NE(bridge, nullptr);
+
+    const XCEngine::Rendering::Pipelines::ManagedRenderPipelineAssetDescriptor descriptor = {
+        "XCEngine.RenderPipelines.Universal",
+        "XCEngine.Rendering.Universal",
+        "UniversalRenderPipelineAsset"
+    };
+
+    std::shared_ptr<const XCEngine::Rendering::Pipelines::ManagedRenderPipelineAssetRuntime>
+        assetRuntime = bridge->CreateAssetRuntime(descriptor);
+    ASSERT_NE(assetRuntime, nullptr);
+
+    const std::shared_ptr<const XCEngine::Rendering::RenderPipelineAsset>
+        rendererAsset = assetRuntime->GetPipelineRendererAsset();
+    ASSERT_NE(rendererAsset, nullptr);
+
+    std::unique_ptr<XCEngine::Rendering::RenderPipeline> pipeline =
+        rendererAsset->CreatePipeline();
+    ASSERT_NE(pipeline, nullptr);
+    EXPECT_NE(
+        dynamic_cast<XCEngine::Rendering::Pipelines::BuiltinForwardPipeline*>(
+            pipeline.get()),
+        nullptr);
+}
+
+TEST_F(
+    MonoScriptRuntimeTest,
+    ManagedRenderPipelineBridgeFallsBackToDefaultSceneRecorderWhenBackendKeyIsUnknown) {
+    const auto bridge =
+        XCEngine::Rendering::Pipelines::GetManagedRenderPipelineBridge();
+    ASSERT_NE(bridge, nullptr);
+
+    const XCEngine::Rendering::Pipelines::ManagedRenderPipelineAssetDescriptor descriptor = {
+        "GameScripts",
+        "Gameplay",
+        "ManagedUnknownBackendRenderPipelineProbeAsset"
+    };
+
+    std::shared_ptr<const XCEngine::Rendering::Pipelines::ManagedRenderPipelineAssetRuntime>
+        assetRuntime = bridge->CreateAssetRuntime(descriptor);
+    ASSERT_NE(assetRuntime, nullptr);
+    EXPECT_EQ(assetRuntime->GetPipelineRendererAsset(), nullptr);
+
+    std::unique_ptr<XCEngine::Rendering::RenderPipelineStageRecorder> recorder =
+        assetRuntime->CreateStageRecorder();
+    ASSERT_NE(recorder, nullptr);
+
+    const XCEngine::Rendering::RenderContext renderContext = {};
+    ASSERT_TRUE(recorder->Initialize(renderContext));
+    ASSERT_TRUE(
+        recorder->SupportsStageRenderGraph(
+            XCEngine::Rendering::CameraFrameStage::MainScene));
+
+    XCEngine::Rendering::RenderGraph graph;
+    XCEngine::Rendering::RenderGraphBuilder graphBuilder(graph);
+    XCEngine::Rendering::RenderGraphTextureDesc colorDesc = {};
+    colorDesc.width = 64u;
+    colorDesc.height = 64u;
+    colorDesc.format =
+        static_cast<XCEngine::Core::uint32>(
+            XCEngine::RHI::Format::R8G8B8A8_UNorm);
+    XCEngine::Rendering::RenderGraphTextureDesc depthDesc = colorDesc;
+    depthDesc.format =
+        static_cast<XCEngine::Core::uint32>(
+            XCEngine::RHI::Format::D32_Float);
+    const XCEngine::Rendering::RenderGraphTextureHandle colorTarget =
+        graphBuilder.CreateTransientTexture("ManagedUnknownBackendColor", colorDesc);
+    const XCEngine::Rendering::RenderGraphTextureHandle depthTarget =
+        graphBuilder.CreateTransientTexture("ManagedUnknownBackendDepth", depthDesc);
+
+    const XCEngine::Rendering::RenderSceneData sceneData = {};
+    const XCEngine::Rendering::RenderSurface surface(64u, 64u);
+    bool executionSucceeded = true;
+    XCEngine::Rendering::RenderGraphBlackboard blackboard = {};
+    const XCEngine::Rendering::RenderPipelineStageRenderGraphContext graphContext = {
+        graphBuilder,
+        "ManagedUnknownBackendMainScene",
+        XCEngine::Rendering::CameraFrameStage::MainScene,
+        renderContext,
+        sceneData,
+        surface,
+        nullptr,
+        nullptr,
+        XCEngine::RHI::ResourceStates::Common,
+        {},
+        { colorTarget },
+        depthTarget,
+        {},
+        &executionSucceeded,
+        &blackboard
+    };
+
+    EXPECT_TRUE(recorder->RecordStageRenderGraph(graphContext));
+
+    XCEngine::Rendering::CompiledRenderGraph compiledGraph = {};
+    XCEngine::Containers::String errorMessage;
+    ASSERT_TRUE(
+        XCEngine::Rendering::RenderGraphCompiler::Compile(
+            graph,
+            compiledGraph,
+            &errorMessage))
+        << errorMessage.CStr();
+    ASSERT_EQ(compiledGraph.GetPassCount(), 3u);
+    EXPECT_STREQ(
+        compiledGraph.GetPassName(0).CStr(),
+        "ManagedUnknownBackendMainScene.Opaque");
+    EXPECT_STREQ(
+        compiledGraph.GetPassName(1).CStr(),
+        "ManagedUnknownBackendMainScene.Skybox");
+    EXPECT_STREQ(
+        compiledGraph.GetPassName(2).CStr(),
+        "ManagedUnknownBackendMainScene.Transparent");
+
+    recorder->Shutdown();
+}
+
 TEST_F(
     MonoScriptRuntimeTest,
     ManagedStageRecorderRecordsMainSceneThroughScriptableRenderContext) {