Align URP scene drawing with RenderGraph renderer lists

engine/src/Scripting/Mono/MonoScriptRuntime.cpp

@@ -29,6 +29,7 @@
 #include "Rendering/RenderPipeline.h"
 #include "Rendering/RenderPipelineAsset.h"
 #include "Rendering/RenderPipelineStageGraphContract.h"
+#include "Rendering/SceneDrawBackend.h"
 #include "Resources/BuiltinResources.h"
 #include "Core/Asset/ResourceManager.h"
 #include "RHI/RHICommandList.h"
@@ -54,6 +55,7 @@
 #include <cstdlib>
 #include <fstream>
 #include <limits>
+#include <memory>
 #include <unordered_set>
 #include <utility>
 
@@ -126,9 +128,11 @@ struct ManagedScriptableRenderContextState {
         std::vector<Rendering::RenderGraphTextureHandle> readDepthTextures = {};
         std::vector<Rendering::RenderPassGraphTextureBindingRequest>
             textureBindings = {};
+        std::vector<Core::uint32> rendererListIndices = {};
         std::vector<Rendering::RenderGraphTextureHandle> colorTargets = {};
         Rendering::RenderGraphTextureHandle depthTarget = {};
     };
+    std::vector<Rendering::DrawSettings> rendererListRequests = {};
     uint64_t nextPendingRasterPassHandle = 1u;
     std::unordered_map<uint64_t, RasterPassRecordRequest>
         pendingRasterPassRequests = {};
@@ -169,16 +173,29 @@ struct ManagedScriptableRenderPipelinePlanningContextState {
 
 struct ManagedCommandBufferCommand {
     enum class Kind {
-        ClearRenderTarget
+        ClearRenderTarget,
+        DrawRendererList,
+        DrawSkybox
     };
 
     Kind kind = Kind::ClearRenderTarget;
     float color[4] = {};
+    Core::uint32 rendererListIndex = 0u;
+};
+
+struct ManagedSceneDrawCommandExecutionState {
+    bool initialized = false;
+    bool clearAttachments = true;
 };
 
 struct ManagedCommandBufferState {
     uint64_t handle = 0;
     const Rendering::RenderPassContext* passContext = nullptr;
+    Rendering::SceneDrawBackend* sceneDrawBackend = nullptr;
+    std::shared_ptr<ManagedSceneDrawCommandExecutionState>
+        sceneDrawState = nullptr;
+    std::vector<Rendering::DrawSettings> rendererLists = {};
+    std::vector<Core::uint32> declaredRendererListIndices = {};
     std::vector<ManagedCommandBufferCommand> commands = {};
 };
 
@@ -317,6 +334,59 @@ bool FlushManagedCommandBufferState(
         state.passContext->renderContext.commandList;
     const std::vector<RHI::RHIResourceView*>& colorAttachments =
         state.passContext->surface.GetColorAttachments();
+    bool sceneDrawPassBegan = false;
+
+    const auto isRendererListDeclared =
+        [&state](Core::uint32 rendererListIndex) {
+            return std::find(
+                       state.declaredRendererListIndices.begin(),
+                       state.declaredRendererListIndices.end(),
+                       rendererListIndex) !=
+                   state.declaredRendererListIndices.end();
+        };
+
+    const auto ensureSceneDrawPass =
+        [&state, &sceneDrawPassBegan]() -> bool {
+            if (state.sceneDrawBackend == nullptr ||
+                state.sceneDrawState == nullptr) {
+                return false;
+            }
+
+            if (!state.sceneDrawState->initialized) {
+                if (!state.sceneDrawBackend->Initialize(
+                        state.passContext->renderContext)) {
+                    return false;
+                }
+
+                const Rendering::FrameExecutionContext executionContext(
+                    state.passContext->renderContext,
+                    state.passContext->surface,
+                    state.passContext->sceneData,
+                    state.passContext->sourceSurface,
+                    state.passContext->sourceColorView,
+                    state.passContext->sourceColorState);
+                if (!state.sceneDrawBackend->PrepareSceneDraw(
+                        executionContext)) {
+                    return false;
+                }
+
+                state.sceneDrawState->initialized = true;
+            }
+
+            if (sceneDrawPassBegan) {
+                return true;
+            }
+
+            if (!state.sceneDrawBackend->BeginSceneDrawPass(
+                    *state.passContext,
+                    state.sceneDrawState->clearAttachments)) {
+                return false;
+            }
+
+            state.sceneDrawState->clearAttachments = false;
+            sceneDrawPassBegan = true;
+            return true;
+        };
 
     for (const ManagedCommandBufferCommand& command : state.commands) {
         switch (command.kind) {
@@ -330,11 +400,59 @@ bool FlushManagedCommandBufferState(
                 colorAttachments[0],
                 command.color);
             break;
+        case ManagedCommandBufferCommand::Kind::DrawRendererList:
+            if (command.rendererListIndex >= state.rendererLists.size() ||
+                !isRendererListDeclared(command.rendererListIndex) ||
+                !ensureSceneDrawPass()) {
+                if (sceneDrawPassBegan &&
+                    state.sceneDrawBackend != nullptr) {
+                    state.sceneDrawBackend->EndSceneDrawPass(
+                        *state.passContext);
+                }
+                return false;
+            }
+
+            if (!state.sceneDrawBackend->DrawSceneRenderers(
+                    *state.passContext,
+                    state.rendererLists[command.rendererListIndex])) {
+                state.sceneDrawBackend->EndSceneDrawPass(
+                    *state.passContext);
+                return false;
+            }
+            break;
+        case ManagedCommandBufferCommand::Kind::DrawSkybox:
+            if (!ensureSceneDrawPass()) {
+                if (sceneDrawPassBegan &&
+                    state.sceneDrawBackend != nullptr) {
+                    state.sceneDrawBackend->EndSceneDrawPass(
+                        *state.passContext);
+                }
+                return false;
+            }
+
+            if (!state.sceneDrawBackend->DrawScenePhase(
+                    *state.passContext,
+                    Rendering::ScenePhase::Skybox)) {
+                state.sceneDrawBackend->EndSceneDrawPass(
+                    *state.passContext);
+                return false;
+            }
+            break;
         default:
+            if (sceneDrawPassBegan &&
+                state.sceneDrawBackend != nullptr) {
+                state.sceneDrawBackend->EndSceneDrawPass(
+                    *state.passContext);
+            }
             return false;
         }
     }
 
+    if (sceneDrawPassBegan &&
+        state.sceneDrawBackend != nullptr) {
+        state.sceneDrawBackend->EndSceneDrawPass(
+            *state.passContext);
+    }
     return true;
 }
 
@@ -1536,6 +1654,9 @@ Rendering::SortingSettings BuildManagedSortingSettings(
     return sortingSettings;
 }
 
+Rendering::RenderStateBlock BuildManagedRenderStateBlock(
+    const ManagedRenderStateBlockData& renderStateBlockData);
+
 bool TryBuildManagedRendererListDesc(
     const ManagedRendererListDescData& rendererListDescData,
     Rendering::RendererListDesc& outRendererListDesc) {
@@ -1555,6 +1676,98 @@ bool TryBuildManagedRendererListDesc(
     return true;
 }
 
+Rendering::ScenePhase ResolveManagedRendererListScenePhase(
+    Rendering::RendererListType rendererListType) {
+    switch (rendererListType) {
+    case Rendering::RendererListType::Transparent:
+        return Rendering::ScenePhase::Transparent;
+    case Rendering::RendererListType::Opaque:
+    case Rendering::RendererListType::ShadowCaster:
+    case Rendering::RendererListType::AllVisible:
+    case Rendering::RendererListType::ObjectId:
+    default:
+        return Rendering::ScenePhase::Opaque;
+    }
+}
+
+bool IsManagedStandaloneScenePassStage(
+    Rendering::CameraFrameStage stage) {
+    return stage == Rendering::CameraFrameStage::ShadowCaster ||
+           stage == Rendering::CameraFrameStage::DepthOnly;
+}
+
+void ApplyManagedStandaloneScenePassDefaults(
+    Rendering::CameraFrameStage stage,
+    Rendering::DrawSettings& drawSettings) {
+    if (!IsManagedStandaloneScenePassStage(stage) ||
+        drawSettings.HasShaderPassName()) {
+        return;
+    }
+
+    drawSettings.shaderPassName =
+        stage == Rendering::CameraFrameStage::ShadowCaster
+            ? Containers::String("ShadowCaster")
+            : Containers::String("DepthOnly");
+}
+
+bool TryBuildManagedDrawSettings(
+    Rendering::CameraFrameStage stage,
+    const ManagedRendererListDescData& rendererListDescData,
+    MonoString* overrideMaterialPath,
+    MonoString* shaderPassName,
+    const ManagedRenderStateBlockData* renderStateBlockData,
+    Rendering::DrawSettings& outDrawSettings) {
+    outDrawSettings = {};
+    if (!TryBuildManagedRendererListDesc(
+            rendererListDescData,
+            outDrawSettings.rendererListDesc)) {
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            "ScriptableRenderContext received an unsupported renderer-list type");
+        return false;
+    }
+
+    outDrawSettings.scenePhase =
+        ResolveManagedRendererListScenePhase(
+            outDrawSettings.rendererListDesc.type);
+
+    const std::string overrideMaterialPathUtf8 =
+        MonoStringToUtf8(overrideMaterialPath);
+    if (!overrideMaterialPathUtf8.empty()) {
+        outDrawSettings.overrideMaterial =
+            Resources::ResourceManager::Get().Load<Resources::Material>(
+                overrideMaterialPathUtf8.c_str());
+        if (!outDrawSettings.overrideMaterial.IsValid()) {
+            Debug::Logger::Get().Error(
+                Debug::LogCategory::Rendering,
+                (Containers::String(
+                     "ScriptableRenderContext failed to load override material: ") +
+                 Containers::String(overrideMaterialPathUtf8.c_str()))
+                    .CStr());
+            return false;
+        }
+    }
+
+    const std::string shaderPassNameUtf8 =
+        MonoStringToUtf8(shaderPassName);
+    if (!shaderPassNameUtf8.empty()) {
+        outDrawSettings.shaderPassName =
+            Containers::String(shaderPassNameUtf8.c_str());
+    }
+
+    ApplyManagedStandaloneScenePassDefaults(
+        stage,
+        outDrawSettings);
+
+    if (renderStateBlockData != nullptr) {
+        outDrawSettings.renderStateBlock =
+            BuildManagedRenderStateBlock(
+                *renderStateBlockData);
+    }
+
+    return true;
+}
+
 Rendering::DepthState BuildManagedDepthState(
     const ManagedDepthStateData& depthStateData) {
     Rendering::DepthState depthState = {};
@@ -2115,6 +2328,11 @@ private:
             assetRuntime = nullptr;
         uint32_t renderFuncHandle = 0u;
         Containers::String passName = {};
+        Rendering::SceneDrawBackend* sceneDrawBackend = nullptr;
+        std::shared_ptr<ManagedSceneDrawCommandExecutionState>
+            sceneDrawState = nullptr;
+        std::vector<Rendering::DrawSettings> rendererLists = {};
+        std::vector<Core::uint32> declaredRendererListIndices = {};
 
         ~ManagedRenderFuncExecutionState() {
             ReleaseRenderFunc();
@@ -2135,6 +2353,11 @@ private:
 
             ManagedCommandBufferState commandBufferState = {};
             commandBufferState.passContext = &passContext;
+            commandBufferState.sceneDrawBackend = sceneDrawBackend;
+            commandBufferState.sceneDrawState = sceneDrawState;
+            commandBufferState.rendererLists = rendererLists;
+            commandBufferState.declaredRendererListIndices =
+                declaredRendererListIndices;
             const uint64_t commandBufferHandle =
                 RegisterManagedCommandBufferState(
                     commandBufferState);
@@ -2261,6 +2484,8 @@ private:
         const Rendering::RenderGraphTextureHandle finalOutputColor =
             ResolveManagedScriptableRenderContextPrimaryColorTarget(
                 &managedContextState);
+        auto sceneDrawState =
+            std::make_shared<ManagedSceneDrawCommandExecutionState>();
 
         for (size_t passIndex = 0u;
              passIndex < managedContextState.rasterPassRequests.size();
@@ -2289,6 +2514,13 @@ private:
                 executionState->assetRuntime = m_assetRuntime;
                 executionState->renderFuncHandle = renderFuncHandle;
                 executionState->passName = resolvedPassName;
+                executionState->sceneDrawBackend =
+                    ResolveSceneDrawBackend();
+                executionState->sceneDrawState = sceneDrawState;
+                executionState->rendererLists =
+                    managedContextState.rendererListRequests;
+                executionState->declaredRendererListIndices =
+                    request.rendererListIndices;
                 Rendering::RenderPassGraphBeginCallback executeCallback =
                     [executionState](
                         const Rendering::RenderPassContext& passContext) {
@@ -4994,6 +5226,20 @@ uint64_t InternalCall_Rendering_ScriptableRenderContext_GetFramePlanId(
         : 0u;
 }
 
+MonoString* InternalCall_Rendering_ScriptableRenderContext_GetPassName(
+    uint64_t nativeHandle) {
+    const ManagedScriptableRenderContextState* const state =
+        FindManagedScriptableRenderContextState(nativeHandle);
+    const char* const passName =
+        state != nullptr &&
+            state->graphContext != nullptr
+            ? state->graphContext->passName.CStr()
+            : "";
+    return mono_string_new(
+        mono_domain_get(),
+        passName);
+}
+
 int32_t InternalCall_Rendering_ScriptableRenderContext_GetSourceColorTextureHandle(
     uint64_t nativeHandle) {
     const ManagedScriptableRenderContextState* const state =
@@ -5258,6 +5504,40 @@ InternalCall_Rendering_ScriptableRenderContext_AddRasterPassTextureBinding(
     return 1;
 }
 
+mono_bool
+InternalCall_Rendering_ScriptableRenderContext_AddRasterPassRendererList(
+    uint64_t nativeHandle,
+    uint64_t rasterPassHandle,
+    int32_t rendererListHandle) {
+    ManagedScriptableRenderContextState* const state =
+        FindManagedScriptableRenderContextState(nativeHandle);
+    ManagedScriptableRenderContextState::RasterPassRecordRequest*
+        const request =
+            FindPendingManagedRasterPassRecordRequest(
+                state,
+                rasterPassHandle);
+    if (state == nullptr ||
+        request == nullptr ||
+        rendererListHandle < 0 ||
+        static_cast<size_t>(rendererListHandle) >=
+            state->rendererListRequests.size()) {
+        return 0;
+    }
+
+    const Core::uint32 rendererListIndex =
+        static_cast<Core::uint32>(rendererListHandle);
+    if (std::find(
+            request->rendererListIndices.begin(),
+            request->rendererListIndices.end(),
+            rendererListIndex) ==
+        request->rendererListIndices.end()) {
+        request->rendererListIndices.push_back(
+            rendererListIndex);
+    }
+
+    return 1;
+}
+
 mono_bool
 InternalCall_Rendering_ScriptableRenderContext_SetRasterPassColorAttachment(
     uint64_t nativeHandle,
@@ -5516,6 +5796,51 @@ mono_bool InternalCall_Rendering_CommandBuffer_ClearRenderTarget(
     return 1;
 }
 
+mono_bool InternalCall_Rendering_CommandBuffer_DrawRendererList(
+    uint64_t nativeHandle,
+    int32_t rendererListHandle) {
+    ManagedCommandBufferState* const state =
+        FindManagedCommandBufferState(nativeHandle);
+    if (state == nullptr ||
+        rendererListHandle < 0 ||
+        static_cast<size_t>(rendererListHandle) >=
+            state->rendererLists.size()) {
+        return 0;
+    }
+
+    const Core::uint32 rendererListIndex =
+        static_cast<Core::uint32>(rendererListHandle);
+    if (std::find(
+            state->declaredRendererListIndices.begin(),
+            state->declaredRendererListIndices.end(),
+            rendererListIndex) ==
+        state->declaredRendererListIndices.end()) {
+        return 0;
+    }
+
+    ManagedCommandBufferCommand command = {};
+    command.kind =
+        ManagedCommandBufferCommand::Kind::DrawRendererList;
+    command.rendererListIndex = rendererListIndex;
+    state->commands.push_back(command);
+    return 1;
+}
+
+mono_bool InternalCall_Rendering_CommandBuffer_DrawSkybox(
+    uint64_t nativeHandle) {
+    ManagedCommandBufferState* const state =
+        FindManagedCommandBufferState(nativeHandle);
+    if (state == nullptr) {
+        return 0;
+    }
+
+    ManagedCommandBufferCommand command = {};
+    command.kind =
+        ManagedCommandBufferCommand::Kind::DrawSkybox;
+    state->commands.push_back(command);
+    return 1;
+}
+
 int32_t InternalCall_Rendering_ScriptableRenderContext_GetStageColorSource(
     uint64_t nativeHandle) {
     const ManagedScriptableRenderContextState* const state =
@@ -6062,44 +6387,17 @@ InternalCall_Rendering_ScriptableRenderContext_DrawRenderersByDesc(
     }
 
     Rendering::DrawSettings drawSettings = {};
-    drawSettings.scenePhase =
-        static_cast<Rendering::ScenePhase>(scenePhase);
-    if (!TryBuildManagedRendererListDesc(
+    if (!TryBuildManagedDrawSettings(
+            state->stage,
             *rendererListDescData,
-            drawSettings.rendererListDesc)) {
-        Debug::Logger::Get().Error(
-            Debug::LogCategory::Rendering,
-            "ScriptableRenderContext DrawRenderers received an unsupported renderer-list type");
+            overrideMaterialPath,
+            shaderPassName,
+            renderStateBlockData,
+            drawSettings)) {
         return 0;
     }
-    const std::string overrideMaterialPathUtf8 =
-        MonoStringToUtf8(overrideMaterialPath);
-    if (!overrideMaterialPathUtf8.empty()) {
-        drawSettings.overrideMaterial =
-            Resources::ResourceManager::Get().Load<Resources::Material>(
-                overrideMaterialPathUtf8.c_str());
-        if (!drawSettings.overrideMaterial.IsValid()) {
-            Debug::Logger::Get().Error(
-                Debug::LogCategory::Rendering,
-                (Containers::String(
-                     "ScriptableRenderContext DrawRenderers failed to load override material: ") +
-                 Containers::String(overrideMaterialPathUtf8.c_str()))
-                    .CStr());
-            return 0;
-        }
-    }
-
-    const std::string shaderPassNameUtf8 =
-        MonoStringToUtf8(shaderPassName);
-    if (!shaderPassNameUtf8.empty()) {
-        drawSettings.shaderPassName =
-            Containers::String(shaderPassNameUtf8.c_str());
-    }
-    if (renderStateBlockData != nullptr) {
-        drawSettings.renderStateBlock =
-            BuildManagedRenderStateBlock(
-                *renderStateBlockData);
-    }
+    drawSettings.scenePhase =
+        static_cast<Rendering::ScenePhase>(scenePhase);
 
     return state->sceneRecorder->RecordSceneDrawSettings(
                drawSettings)
@@ -6107,6 +6405,45 @@ InternalCall_Rendering_ScriptableRenderContext_DrawRenderersByDesc(
         : 0;
 }
 
+int32_t
+InternalCall_Rendering_ScriptableRenderContext_CreateRendererList(
+    uint64_t nativeHandle,
+    ManagedRendererListDescData* rendererListDescData,
+    MonoString* overrideMaterialPath,
+    MonoString* shaderPassName,
+    ManagedRenderStateBlockData* renderStateBlockData) {
+    ManagedScriptableRenderContextState* const state =
+        FindManagedScriptableRenderContextState(nativeHandle);
+    if (state == nullptr ||
+        state->graphContext == nullptr ||
+        rendererListDescData == nullptr) {
+        return -1;
+    }
+
+    Rendering::DrawSettings drawSettings = {};
+    if (!TryBuildManagedDrawSettings(
+            state->stage,
+            *rendererListDescData,
+            overrideMaterialPath,
+            shaderPassName,
+            renderStateBlockData,
+            drawSettings)) {
+        return -1;
+    }
+
+    const size_t rendererListIndex =
+        state->rendererListRequests.size();
+    if (rendererListIndex >
+        static_cast<size_t>(
+            std::numeric_limits<int32_t>::max())) {
+        return -1;
+    }
+
+    state->rendererListRequests.push_back(
+        std::move(drawSettings));
+    return static_cast<int32_t>(rendererListIndex);
+}
+
 int32_t
 InternalCall_Rendering_CameraRenderRequestContext_GetRenderedBaseCameraCount(
     uint64_t nativeHandle) {
@@ -6948,6 +7285,7 @@ void RegisterInternalCalls() {
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetStage", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetStage));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetRendererIndex", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetRendererIndex));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetFramePlanId", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetFramePlanId));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetPassName", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetPassName));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetSourceColorTextureHandle", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetSourceColorTextureHandle));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetPrimaryColorTargetHandle", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetPrimaryColorTargetHandle));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetDepthTargetHandle", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetDepthTargetHandle));
@@ -6959,6 +7297,7 @@ void RegisterInternalCalls() {
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_AddRasterPassReadTexture", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_AddRasterPassReadTexture));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_AddRasterPassReadDepthTexture", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_AddRasterPassReadDepthTexture));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_AddRasterPassTextureBinding", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_AddRasterPassTextureBinding));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_AddRasterPassRendererList", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_AddRasterPassRendererList));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassColorAttachment", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassColorAttachment));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassDepthAttachment", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassDepthAttachment));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassColorScaleFullscreenExecution", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassColorScaleFullscreenExecution));
@@ -6967,6 +7306,8 @@ void RegisterInternalCalls() {
     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_CommandBuffer_ClearRenderTarget", reinterpret_cast<const void*>(&InternalCall_Rendering_CommandBuffer_ClearRenderTarget));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_CommandBuffer_DrawRendererList", reinterpret_cast<const void*>(&InternalCall_Rendering_CommandBuffer_DrawRendererList));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_CommandBuffer_DrawSkybox", reinterpret_cast<const void*>(&InternalCall_Rendering_CommandBuffer_DrawSkybox));
     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));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetMainDirectionalShadowEnabled", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetMainDirectionalShadowEnabled));
@@ -7019,6 +7360,7 @@ void RegisterInternalCalls() {
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetFinalColorHasCameraOverrides", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_GetFinalColorHasCameraOverrides));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_RecordScenePhase", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_RecordScenePhase));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_DrawRenderersByDesc", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_DrawRenderersByDesc));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_CreateRendererList", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderContext_CreateRendererList));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderPipelinePlanningContext_GetRendererIndex", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_GetRendererIndex));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderPipelinePlanningContext_GetFramePlanId", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_GetFramePlanId));
     mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderPipelinePlanningContext_IsStageRequested", reinterpret_cast<const void*>(&InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_IsStageRequested));