Align managed raster RenderGraph authoring with URP

2026-04-26 23:32:09 +08:00
parent 09b1289338
commit 3b38d65ab8
13 changed files with 430 additions and 123 deletions
--- a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp
+++ b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp
@@ -116,6 +116,7 @@ struct ManagedScriptableRenderContextState {
    struct RasterPassRecordRequest {
        Containers::String passName = {};
        Rendering::FullscreenPassDesc passDesc = {};
+        bool usesManagedRenderFuncExecution = false;
        Rendering::RenderGraphTextureHandle sourceColorTexture = {};
        std::vector<Rendering::RenderGraphTextureHandle> readTextures = {};
        std::vector<Rendering::RenderGraphTextureHandle> readDepthTextures = {};
@@ -346,6 +347,13 @@ ResolveManagedPrimaryColorTarget(
        : Rendering::RenderGraphTextureHandle{};
 }

+bool HasManagedRasterWriteTarget(
+    const ManagedScriptableRenderContextState::RasterPassRecordRequest&
+        request) {
+    return ResolveManagedPrimaryColorTarget(request.colorTargets).IsValid() ||
+           request.depthTarget.IsValid();
+}
+
 Rendering::RenderGraphTextureHandle
 ResolveManagedScriptableRenderContextPrimaryColorTarget(
    const ManagedScriptableRenderContextState* state) {
@@ -474,6 +482,58 @@ bool RecordManagedFullscreenRasterPass(
        std::move(textureBindings));
 }

+bool RecordManagedRenderFuncRasterPass(
+    const Rendering::RenderPipelineStageRenderGraphContext& stageContext,
+    Rendering::RenderGraphTextureHandle sourceColorTexture,
+    std::vector<Rendering::RenderGraphTextureHandle> colorTargets,
+    std::vector<Rendering::RenderGraphTextureHandle> additionalReadTextures,
+    std::vector<Rendering::RenderGraphTextureHandle> additionalReadDepthTextures,
+    std::vector<Rendering::RenderPassGraphTextureBindingRequest>
+        textureBindings,
+    Rendering::RenderGraphTextureHandle depthTarget,
+    const Containers::String& passName) {
+    if (!ResolveManagedPrimaryColorTarget(colorTargets).IsValid() &&
+        !depthTarget.IsValid()) {
+        return false;
+    }
+
+    const Rendering::RenderGraphRecordingContext baseContext =
+        Rendering::BuildRenderGraphRecordingContext(stageContext);
+    Rendering::RenderGraphRecordingContextBuildParams params = {};
+    if (!passName.Empty()) {
+        params.passName = &passName;
+    }
+    params.overrideSourceBinding = true;
+    if (sourceColorTexture.IsValid()) {
+        params.sourceBinding =
+            BuildManagedScriptableRenderContextSourceBinding(
+                stageContext,
+                sourceColorTexture);
+    }
+    params.overrideColorTargets = true;
+    params.colorTargets = std::move(colorTargets);
+    params.overrideDepthTarget = true;
+    params.depthTarget = depthTarget;
+
+    const Rendering::RenderGraphRecordingContext recordingContext =
+        Rendering::BuildRenderGraphRecordingContext(
+            baseContext,
+            std::move(params));
+    const Rendering::RenderPassRenderGraphContext renderGraphContext =
+        Rendering::BuildRenderPassRenderGraphContext(recordingContext);
+    const Rendering::RenderPassGraphIO io =
+        Rendering::BuildDeclaredRasterPassGraphIO(renderGraphContext);
+    return Rendering::RecordCallbackRasterRenderPass(
+        renderGraphContext,
+        io,
+        [](const Rendering::RenderPassContext&) {
+            return true;
+        },
+        std::move(additionalReadTextures),
+        std::move(additionalReadDepthTextures),
+        std::move(textureBindings));
+}
+
 bool RecordManagedFullscreenPassToTexture(
    const Rendering::RenderPipelineStageRenderGraphContext& stageContext,
    Rendering::RenderPass& pass,
@@ -1956,9 +2016,6 @@ private:
        if (managedContextState.rasterPassRequests.empty()) {
            return true;
        }
-        if (!Rendering::IsCameraFrameFullscreenSequenceStage(context.stage)) {
-            return false;
-        }

        Rendering::RenderGraphTextureHandle currentSourceColor =
            ResolveManagedScriptableRenderContextSourceColorTexture(
@@ -1966,16 +2023,50 @@ private:
        const Rendering::RenderGraphTextureHandle finalOutputColor =
            ResolveManagedScriptableRenderContextPrimaryColorTarget(
                &managedContextState);
-        if (!currentSourceColor.IsValid() ||
-            !finalOutputColor.IsValid()) {
-            return false;
-        }

        for (size_t passIndex = 0u;
             passIndex < managedContextState.rasterPassRequests.size();
             ++passIndex) {
            const ManagedScriptableRenderContextState::RasterPassRecordRequest&
                request = managedContextState.rasterPassRequests[passIndex];
+            const Containers::String resolvedPassName =
+                !request.passName.Empty()
+                    ? request.passName
+                    : managedContextState.rasterPassRequests.size() == 1u
+                        ? context.passName
+                        : Rendering::BuildRenderGraphSequencePassName(
+                              context.passName,
+                              passIndex);
+            if (request.usesManagedRenderFuncExecution) {
+                if (!RecordManagedRenderFuncRasterPass(
+                        context,
+                        request.sourceColorTexture,
+                        request.colorTargets,
+                        request.readTextures,
+                        request.readDepthTextures,
+                        request.textureBindings,
+                        request.depthTarget,
+                        resolvedPassName)) {
+                    return false;
+                }
+
+                const Rendering::RenderGraphTextureHandle
+                    resolvedOutputColor =
+                        ResolveManagedPrimaryColorTarget(
+                            request.colorTargets);
+                if (resolvedOutputColor.IsValid()) {
+                    currentSourceColor = resolvedOutputColor;
+                }
+                continue;
+            }
+
+            if (!Rendering::IsCameraFrameFullscreenSequenceStage(
+                    context.stage) ||
+                !currentSourceColor.IsValid() ||
+                !finalOutputColor.IsValid()) {
+                return false;
+            }
+
            Rendering::RenderPass* const pass =
                ConfigureManagedFullscreenPass(
                    m_fullscreenPassPool,
@@ -1985,14 +2076,6 @@ private:
                return false;
            }

-            const Containers::String resolvedPassName =
-                !request.passName.Empty()
-                    ? request.passName
-                    : managedContextState.rasterPassRequests.size() == 1u
-                        ? context.passName
-                        : Rendering::BuildRenderGraphSequencePassName(
-                              context.passName,
-                              passIndex);
            const Rendering::RenderGraphTextureHandle resolvedSourceColor =
                request.sourceColorTexture.IsValid()
                    ? request.sourceColorTexture
@@ -4717,8 +4800,7 @@ uint64_t InternalCall_Rendering_ScriptableRenderContext_BeginRasterPass(
    ManagedScriptableRenderContextState* const state =
        FindManagedScriptableRenderContextState(nativeHandle);
    if (state == nullptr ||
-        state->graphContext == nullptr ||
-        !Rendering::IsCameraFrameFullscreenSequenceStage(state->stage)) {
+        state->graphContext == nullptr) {
        return 0u;
    }

@@ -4961,10 +5043,13 @@ InternalCall_Rendering_ScriptableRenderContext_SetRasterPassColorScaleFullscreen
                state,
                rasterPassHandle);
    if (request == nullptr ||
+        state == nullptr ||
+        !Rendering::IsCameraFrameFullscreenSequenceStage(state->stage) ||
        vectorPayload == nullptr) {
        return 0;
    }

+    request->usesManagedRenderFuncExecution = false;
    request->passDesc =
        Rendering::FullscreenPassDesc::MakeColorScale(
            *vectorPayload);
@@ -4986,6 +5071,8 @@ InternalCall_Rendering_ScriptableRenderContext_SetRasterPassShaderVectorFullscre
                state,
                rasterPassHandle);
    if (request == nullptr ||
+        state == nullptr ||
+        !Rendering::IsCameraFrameFullscreenSequenceStage(state->stage) ||
        vectorPayload == nullptr) {
        return 0;
    }
@@ -4996,6 +5083,7 @@ InternalCall_Rendering_ScriptableRenderContext_SetRasterPassShaderVectorFullscre
        return 0;
    }

+    request->usesManagedRenderFuncExecution = false;
    request->passDesc =
        Rendering::FullscreenPassDesc::MakeShaderVector(
            shaderPathString,
@@ -5019,10 +5107,13 @@ InternalCall_Rendering_ScriptableRenderContext_SetRasterPassFinalColorFullscreen
                state,
                rasterPassHandle);
    if (request == nullptr ||
+        state == nullptr ||
+        !Rendering::IsCameraFrameFullscreenSequenceStage(state->stage) ||
        settingsData == nullptr) {
        return 0;
    }

+    request->usesManagedRenderFuncExecution = false;
    request->passDesc =
        Rendering::FullscreenPassDesc::MakeFinalColor(
            BuildManagedFinalColorSettings(
@@ -5032,14 +5123,33 @@ InternalCall_Rendering_ScriptableRenderContext_SetRasterPassFinalColorFullscreen
        : 0;
 }

+mono_bool
+InternalCall_Rendering_ScriptableRenderContext_SetRasterPassManagedRenderFuncExecution(
+    uint64_t nativeHandle,
+    uint64_t rasterPassHandle) {
+    ManagedScriptableRenderContextState* const state =
+        FindManagedScriptableRenderContextState(nativeHandle);
+    ManagedScriptableRenderContextState::RasterPassRecordRequest*
+        const request =
+            FindPendingManagedRasterPassRecordRequest(
+                state,
+                rasterPassHandle);
+    if (request == nullptr) {
+        return 0;
+    }
+
+    request->usesManagedRenderFuncExecution = true;
+    request->passDesc = {};
+    return 1;
+}
+
 mono_bool InternalCall_Rendering_ScriptableRenderContext_CommitRasterPass(
    uint64_t nativeHandle,
    uint64_t rasterPassHandle) {
    ManagedScriptableRenderContextState* const state =
        FindManagedScriptableRenderContextState(nativeHandle);
    if (state == nullptr ||
-        state->graphContext == nullptr ||
-        !Rendering::IsCameraFrameFullscreenSequenceStage(state->stage)) {
+        state->graphContext == nullptr) {
        return 0;
    }

@@ -5053,9 +5163,13 @@ mono_bool InternalCall_Rendering_ScriptableRenderContext_CommitRasterPass(
    ManagedScriptableRenderContextState::RasterPassRecordRequest
        request = std::move(it->second);
    state->pendingRasterPassRequests.erase(it);
-    if (!request.passDesc.IsValid() ||
-        !ResolveManagedPrimaryColorTarget(request.colorTargets)
-             .IsValid()) {
+    if (request.usesManagedRenderFuncExecution) {
+        if (!HasManagedRasterWriteTarget(request)) {
+            return 0;
+        }
+    } else if (!request.passDesc.IsValid() ||
+               !ResolveManagedPrimaryColorTarget(request.colorTargets)
+                    .IsValid()) {
        return 0;
    }

@@ -6499,6 +6613,7 @@ void RegisterInternalCalls() {
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassColorScaleFullscreenExecution", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassColorScaleFullscreenExecution));
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassShaderVectorFullscreenExecution", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassShaderVectorFullscreenExecution));
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassFinalColorFullscreenExecution", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassFinalColorFullscreenExecution));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassManagedRenderFuncExecution", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassManagedRenderFuncExecution));
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_CommitRasterPass", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_CommitRasterPass));
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetStageColorSource", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetStageColorSource));
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetStageUsesGraphManagedOutputColor", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetStageUsesGraphManagedOutputColor));