From b8d29e39f6523a0ecc8b3d45e7fb51585a468d69 Mon Sep 17 00:00:00 2001 From: ssdfasd <2156608475@qq.com> Date: Tue, 14 Apr 2026 00:52:43 +0800 Subject: [PATCH] Migrate scene renderer callers to frame plans --- .../Rendering/Execution/SceneRenderer.h | 4 +- .../src/Rendering/Execution/SceneRenderer.cpp | 6 +- .../integration/alpha_cutout_scene/main.cpp | 18 +- .../directional_shadow_scene/main.cpp | 8 +- .../unit/test_camera_scene_renderer.cpp | 354 +++++++++--------- 5 files changed, 196 insertions(+), 194 deletions(-) diff --git a/engine/include/XCEngine/Rendering/Execution/SceneRenderer.h b/engine/include/XCEngine/Rendering/Execution/SceneRenderer.h index 1d4acb85..07338311 100644 --- a/engine/include/XCEngine/Rendering/Execution/SceneRenderer.h +++ b/engine/include/XCEngine/Rendering/Execution/SceneRenderer.h @@ -31,6 +31,7 @@ public: RenderPipeline* GetPipeline() const { return m_cameraRenderer.GetPipeline(); } const RenderPipelineAsset* GetPipelineAsset() const { return m_cameraRenderer.GetPipelineAsset(); } + // Legacy compatibility adapters retained for callers that still consume CameraRenderRequest. std::vector BuildRenderRequests( const Components::Scene& scene, Components::CameraComponent* overrideCamera, @@ -42,6 +43,7 @@ public: const RenderContext& context, const RenderSurface& surface); + // Legacy compatibility adapters retained for callers that still submit CameraRenderRequest. bool Render(const CameraRenderRequest& request); bool Render(const std::vector& requests); bool Render(const CameraFramePlan& plan); @@ -53,7 +55,7 @@ public: const RenderSurface& surface); private: - std::vector CreateFramePlansFromRequests( + std::vector CreateFramePlansFromLegacyRequests( const std::vector& requests) const; void PrepareOwnedFullscreenStageState(size_t requestCount); void ResolveCameraFinalColorPolicies( diff --git a/engine/src/Rendering/Execution/SceneRenderer.cpp b/engine/src/Rendering/Execution/SceneRenderer.cpp index d6d027d4..ab4bb7ad 100644 --- a/engine/src/Rendering/Execution/SceneRenderer.cpp +++ b/engine/src/Rendering/Execution/SceneRenderer.cpp @@ -119,7 +119,7 @@ std::vector SceneRenderer::BuildFramePlans( const RenderSurface& surface) { const std::vector requests = m_requestPlanner.BuildRequests(scene, overrideCamera, context, surface); - std::vector plans = CreateFramePlansFromRequests(requests); + std::vector plans = CreateFramePlansFromLegacyRequests(requests); ResolveCameraFinalColorPolicies(plans); AttachFullscreenStageRequests(context, plans); return plans; @@ -130,7 +130,7 @@ bool SceneRenderer::Render(const CameraRenderRequest& request) { } bool SceneRenderer::Render(const std::vector& requests) { - std::vector plans = CreateFramePlansFromRequests(requests); + std::vector plans = CreateFramePlansFromLegacyRequests(requests); return Render(plans); } @@ -184,7 +184,7 @@ bool SceneRenderer::Render( return Render(BuildFramePlans(scene, overrideCamera, context, surface)); } -std::vector SceneRenderer::CreateFramePlansFromRequests( +std::vector SceneRenderer::CreateFramePlansFromLegacyRequests( const std::vector& requests) const { std::vector plans = {}; plans.reserve(requests.size()); diff --git a/tests/Rendering/integration/alpha_cutout_scene/main.cpp b/tests/Rendering/integration/alpha_cutout_scene/main.cpp index 108ff014..270c5631 100644 --- a/tests/Rendering/integration/alpha_cutout_scene/main.cpp +++ b/tests/Rendering/integration/alpha_cutout_scene/main.cpp @@ -503,19 +503,19 @@ void AlphaCutoutSceneTest::RenderFrame() { renderContext.commandQueue = GetCommandQueue(); renderContext.backendType = GetBackendType(); - std::vector requests = - mSceneRenderer->BuildRenderRequests(*mScene, nullptr, renderContext, mainSurface); - ASSERT_EQ(requests.size(), 1u); - ASSERT_TRUE(requests[0].directionalShadow.IsValid()); + std::vector plans = + mSceneRenderer->BuildFramePlans(*mScene, nullptr, renderContext, mainSurface); + ASSERT_EQ(plans.size(), 1u); + ASSERT_TRUE(plans[0].directionalShadow.IsValid()); RenderSurface depthOnlySurface(kFrameWidth, kFrameHeight); depthOnlySurface.SetDepthAttachment(mDepthView); - depthOnlySurface.SetRenderArea(requests[0].surface.GetRenderArea()); - requests[0].depthOnly.surface = depthOnlySurface; - requests[0].depthOnly.clearFlags = RenderClearFlags::Depth; - requests[0].clearFlags = RenderClearFlags::Color; + depthOnlySurface.SetRenderArea(plans[0].request.surface.GetRenderArea()); + plans[0].request.depthOnly.surface = depthOnlySurface; + plans[0].request.depthOnly.clearFlags = RenderClearFlags::Depth; + plans[0].request.clearFlags = RenderClearFlags::Color; - ASSERT_TRUE(mSceneRenderer->Render(requests)); + ASSERT_TRUE(mSceneRenderer->Render(plans)); commandList->Close(); void* commandLists[] = { commandList }; diff --git a/tests/Rendering/integration/directional_shadow_scene/main.cpp b/tests/Rendering/integration/directional_shadow_scene/main.cpp index 225103ae..641584fc 100644 --- a/tests/Rendering/integration/directional_shadow_scene/main.cpp +++ b/tests/Rendering/integration/directional_shadow_scene/main.cpp @@ -449,10 +449,10 @@ void DirectionalShadowSceneTest::RenderSceneFrame() { renderContext.commandQueue = GetCommandQueue(); renderContext.backendType = GetBackendType(); - std::vector requests = - mSceneRenderer->BuildRenderRequests(*mScene, nullptr, renderContext, surface); - ASSERT_FALSE(requests.empty()); - ASSERT_TRUE(mSceneRenderer->Render(requests)); + std::vector plans = + mSceneRenderer->BuildFramePlans(*mScene, nullptr, renderContext, surface); + ASSERT_FALSE(plans.empty()); + ASSERT_TRUE(mSceneRenderer->Render(plans)); Log("[TEST] DirectionalShadowSceneTest: closing command list"); commandList->Close(); diff --git a/tests/Rendering/unit/test_camera_scene_renderer.cpp b/tests/Rendering/unit/test_camera_scene_renderer.cpp index 002f9fc6..d289bcd7 100644 --- a/tests/Rendering/unit/test_camera_scene_renderer.cpp +++ b/tests/Rendering/unit/test_camera_scene_renderer.cpp @@ -1724,23 +1724,23 @@ TEST(SceneRenderer_Test, BuildsSortedRequestsForAllUsableCamerasAndHonorsOverrid const RenderContext context = CreateValidContext(); const RenderSurface surface(320, 180); - const std::vector defaultRequests = - renderer.BuildRenderRequests(scene, nullptr, context, surface); - ASSERT_EQ(defaultRequests.size(), 2u); - EXPECT_EQ(defaultRequests[0].camera, lowCamera); - EXPECT_EQ(defaultRequests[0].cameraDepth, 1.0f); - EXPECT_EQ(defaultRequests[0].clearFlags, RenderClearFlags::All); - EXPECT_EQ(defaultRequests[0].surface.GetWidth(), 320u); - EXPECT_EQ(defaultRequests[0].surface.GetHeight(), 180u); - EXPECT_EQ(defaultRequests[1].camera, highCamera); - EXPECT_EQ(defaultRequests[1].cameraDepth, 5.0f); - EXPECT_EQ(defaultRequests[1].clearFlags, RenderClearFlags::None); + const std::vector defaultPlans = + renderer.BuildFramePlans(scene, nullptr, context, surface); + ASSERT_EQ(defaultPlans.size(), 2u); + EXPECT_EQ(defaultPlans[0].request.camera, lowCamera); + EXPECT_EQ(defaultPlans[0].request.cameraDepth, 1.0f); + EXPECT_EQ(defaultPlans[0].request.clearFlags, RenderClearFlags::All); + EXPECT_EQ(defaultPlans[0].request.surface.GetWidth(), 320u); + EXPECT_EQ(defaultPlans[0].request.surface.GetHeight(), 180u); + EXPECT_EQ(defaultPlans[1].request.camera, highCamera); + EXPECT_EQ(defaultPlans[1].request.cameraDepth, 5.0f); + EXPECT_EQ(defaultPlans[1].request.clearFlags, RenderClearFlags::None); - const std::vector overrideRequests = - renderer.BuildRenderRequests(scene, lowCamera, context, surface); - ASSERT_EQ(overrideRequests.size(), 1u); - EXPECT_EQ(overrideRequests[0].camera, lowCamera); - EXPECT_EQ(overrideRequests[0].clearFlags, RenderClearFlags::All); + const std::vector overridePlans = + renderer.BuildFramePlans(scene, lowCamera, context, surface); + ASSERT_EQ(overridePlans.size(), 1u); + EXPECT_EQ(overridePlans[0].request.camera, lowCamera); + EXPECT_EQ(overridePlans[0].request.clearFlags, RenderClearFlags::All); } TEST(SceneRenderer_Test, RendersBaseCamerasBeforeOverlayCamerasAndResolvesAutoClearPerStackType) { @@ -1762,19 +1762,19 @@ TEST(SceneRenderer_Test, RendersBaseCamerasBeforeOverlayCamerasAndResolvesAutoCl overlayCamera->SetStackType(CameraStackType::Overlay); SceneRenderer renderer; - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(640, 360)); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, CreateValidContext(), RenderSurface(640, 360)); - ASSERT_EQ(requests.size(), 3u); - EXPECT_EQ(requests[0].camera, earlyBaseCamera); - EXPECT_EQ(requests[0].cameraStackOrder, 0u); - EXPECT_EQ(requests[0].clearFlags, RenderClearFlags::All); - EXPECT_EQ(requests[1].camera, lateBaseCamera); - EXPECT_EQ(requests[1].cameraStackOrder, 0u); - EXPECT_EQ(requests[1].clearFlags, RenderClearFlags::Depth); - EXPECT_EQ(requests[2].camera, overlayCamera); - EXPECT_EQ(requests[2].cameraStackOrder, 1u); - EXPECT_EQ(requests[2].clearFlags, RenderClearFlags::Depth); + ASSERT_EQ(plans.size(), 3u); + EXPECT_EQ(plans[0].request.camera, earlyBaseCamera); + EXPECT_EQ(plans[0].request.cameraStackOrder, 0u); + EXPECT_EQ(plans[0].request.clearFlags, RenderClearFlags::All); + EXPECT_EQ(plans[1].request.camera, lateBaseCamera); + EXPECT_EQ(plans[1].request.cameraStackOrder, 0u); + EXPECT_EQ(plans[1].request.clearFlags, RenderClearFlags::Depth); + EXPECT_EQ(plans[2].request.camera, overlayCamera); + EXPECT_EQ(plans[2].request.cameraStackOrder, 1u); + EXPECT_EQ(plans[2].request.clearFlags, RenderClearFlags::Depth); } TEST(SceneRenderer_Test, PreservesSceneTraversalOrderForEqualPriorityCameras) { @@ -1793,12 +1793,12 @@ TEST(SceneRenderer_Test, PreservesSceneTraversalOrderForEqualPriorityCameras) { secondCamera->SetStackType(CameraStackType::Base); SceneRenderer renderer; - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(640, 360)); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, CreateValidContext(), RenderSurface(640, 360)); - ASSERT_EQ(requests.size(), 2u); - EXPECT_EQ(requests[0].camera, firstCamera); - EXPECT_EQ(requests[1].camera, secondCamera); + ASSERT_EQ(plans.size(), 2u); + EXPECT_EQ(plans[0].request.camera, firstCamera); + EXPECT_EQ(plans[1].request.camera, secondCamera); } TEST(SceneRenderer_Test, FallsBackToColorClearForFirstOverlayCameraWhenNoBaseCameraExists) { @@ -1815,14 +1815,14 @@ TEST(SceneRenderer_Test, FallsBackToColorClearForFirstOverlayCameraWhenNoBaseCam secondOverlay->SetStackType(CameraStackType::Overlay); SceneRenderer renderer; - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(320, 180)); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, CreateValidContext(), RenderSurface(320, 180)); - ASSERT_EQ(requests.size(), 2u); - EXPECT_EQ(requests[0].camera, firstOverlay); - EXPECT_EQ(requests[0].clearFlags, RenderClearFlags::All); - EXPECT_EQ(requests[1].camera, secondOverlay); - EXPECT_EQ(requests[1].clearFlags, RenderClearFlags::Depth); + ASSERT_EQ(plans.size(), 2u); + EXPECT_EQ(plans[0].request.camera, firstOverlay); + EXPECT_EQ(plans[0].request.clearFlags, RenderClearFlags::All); + EXPECT_EQ(plans[1].request.camera, secondOverlay); + EXPECT_EQ(plans[1].request.clearFlags, RenderClearFlags::Depth); } TEST(SceneRenderer_Test, HonorsExplicitOverrideCameraClearMode) { @@ -1835,12 +1835,12 @@ TEST(SceneRenderer_Test, HonorsExplicitOverrideCameraClearMode) { camera->SetClearMode(CameraClearMode::DepthOnly); SceneRenderer renderer; - const std::vector requests = - renderer.BuildRenderRequests(scene, camera, CreateValidContext(), RenderSurface(640, 360)); + const std::vector plans = + renderer.BuildFramePlans(scene, camera, CreateValidContext(), RenderSurface(640, 360)); - ASSERT_EQ(requests.size(), 1u); - EXPECT_EQ(requests[0].camera, camera); - EXPECT_EQ(requests[0].clearFlags, RenderClearFlags::Depth); + ASSERT_EQ(plans.size(), 1u); + EXPECT_EQ(plans[0].request.camera, camera); + EXPECT_EQ(plans[0].request.clearFlags, RenderClearFlags::Depth); } TEST(SceneRenderer_Test, ResolvesNormalizedCameraViewportRectToPerRequestRenderArea) { @@ -1853,11 +1853,11 @@ TEST(SceneRenderer_Test, ResolvesNormalizedCameraViewportRectToPerRequestRenderA camera->SetViewportRect(XCEngine::Math::Rect(0.25f, 0.1f, 0.5f, 0.4f)); SceneRenderer renderer; - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(800, 600)); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, CreateValidContext(), RenderSurface(800, 600)); - ASSERT_EQ(requests.size(), 1u); - const XCEngine::Math::RectInt renderArea = requests[0].surface.GetRenderArea(); + ASSERT_EQ(plans.size(), 1u); + const XCEngine::Math::RectInt renderArea = plans[0].request.surface.GetRenderArea(); EXPECT_EQ(renderArea.x, 200); EXPECT_EQ(renderArea.y, 60); EXPECT_EQ(renderArea.width, 400); @@ -1877,11 +1877,11 @@ TEST(SceneRenderer_Test, ComposesCameraViewportRectWithinExistingSurfaceRenderAr surface.SetRenderArea(XCEngine::Math::RectInt(100, 50, 400, 300)); SceneRenderer renderer; - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), surface); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, CreateValidContext(), surface); - ASSERT_EQ(requests.size(), 1u); - const XCEngine::Math::RectInt renderArea = requests[0].surface.GetRenderArea(); + ASSERT_EQ(plans.size(), 1u); + const XCEngine::Math::RectInt renderArea = plans[0].request.surface.GetRenderArea(); EXPECT_EQ(renderArea.x, 200); EXPECT_EQ(renderArea.y, 80); EXPECT_EQ(renderArea.width, 200); @@ -1901,11 +1901,11 @@ TEST(SceneRenderer_Test, PreservesExistingSurfaceRenderAreaForFullViewportCamera surface.SetRenderArea(XCEngine::Math::RectInt(80, 120, 320, 240)); SceneRenderer renderer; - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), surface); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, CreateValidContext(), surface); - ASSERT_EQ(requests.size(), 1u); - const XCEngine::Math::RectInt renderArea = requests[0].surface.GetRenderArea(); + ASSERT_EQ(plans.size(), 1u); + const XCEngine::Math::RectInt renderArea = plans[0].request.surface.GetRenderArea(); EXPECT_EQ(renderArea.x, 80); EXPECT_EQ(renderArea.y, 120); EXPECT_EQ(renderArea.width, 320); @@ -1951,44 +1951,44 @@ TEST(SceneRenderer_Test, BuildsCameraColorScalePostProcessRequestFromCameraPassS surface.SetDepthStateAfter(XCEngine::RHI::ResourceStates::PixelShaderResource); SceneRenderer renderer; - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, context, surface); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, context, surface); - ASSERT_EQ(requests.size(), 1u); - const CameraRenderRequest& request = requests[0]; - EXPECT_TRUE(request.postProcess.IsRequested()); - EXPECT_TRUE(request.postProcess.IsValid()); - EXPECT_NE(request.postProcess.passes, nullptr); - ASSERT_EQ(request.postProcess.passes->GetPassCount(), 2u); - EXPECT_EQ(request.postProcess.destinationSurface.GetColorAttachments()[0], backBufferColorView); - EXPECT_EQ(request.postProcess.destinationSurface.GetDepthAttachment(), depthView); + ASSERT_EQ(plans.size(), 1u); + const CameraFramePlan& plan = plans[0]; + EXPECT_TRUE(plan.postProcess.IsRequested()); + EXPECT_TRUE(plan.postProcess.IsValid()); + EXPECT_NE(plan.postProcess.passes, nullptr); + ASSERT_EQ(plan.postProcess.passes->GetPassCount(), 2u); + EXPECT_EQ(plan.postProcess.destinationSurface.GetColorAttachments()[0], backBufferColorView); + EXPECT_EQ(plan.postProcess.destinationSurface.GetDepthAttachment(), depthView); EXPECT_EQ( - request.postProcess.destinationSurface.GetDepthStateBefore(), + plan.postProcess.destinationSurface.GetDepthStateBefore(), XCEngine::RHI::ResourceStates::Common); EXPECT_EQ( - request.postProcess.destinationSurface.GetDepthStateAfter(), + plan.postProcess.destinationSurface.GetDepthStateAfter(), XCEngine::RHI::ResourceStates::PixelShaderResource); - EXPECT_EQ(request.postProcess.sourceSurface.GetDepthAttachment(), depthView); + EXPECT_EQ(plan.postProcess.sourceSurface.GetDepthAttachment(), depthView); EXPECT_EQ( - request.postProcess.sourceSurface.GetDepthStateBefore(), + plan.postProcess.sourceSurface.GetDepthStateBefore(), XCEngine::RHI::ResourceStates::Common); EXPECT_EQ( - request.postProcess.sourceSurface.GetDepthStateAfter(), + plan.postProcess.sourceSurface.GetDepthStateAfter(), XCEngine::RHI::ResourceStates::PixelShaderResource); - EXPECT_EQ(request.postProcess.sourceSurface.GetWidth(), 800u); - EXPECT_EQ(request.postProcess.sourceSurface.GetHeight(), 600u); - const XCEngine::Math::RectInt sourceRenderArea = request.postProcess.sourceSurface.GetRenderArea(); + EXPECT_EQ(plan.postProcess.sourceSurface.GetWidth(), 800u); + EXPECT_EQ(plan.postProcess.sourceSurface.GetHeight(), 600u); + const XCEngine::Math::RectInt sourceRenderArea = plan.postProcess.sourceSurface.GetRenderArea(); EXPECT_EQ(sourceRenderArea.x, 200); EXPECT_EQ(sourceRenderArea.y, 75); EXPECT_EQ(sourceRenderArea.width, 400); EXPECT_EQ(sourceRenderArea.height, 375); - EXPECT_NE(request.postProcess.sourceColorView, nullptr); - EXPECT_NE(request.postProcess.sourceColorView, backBufferColorView); + EXPECT_NE(plan.postProcess.sourceColorView, nullptr); + EXPECT_NE(plan.postProcess.sourceColorView, backBufferColorView); EXPECT_EQ( - request.postProcess.sourceColorState, + plan.postProcess.sourceColorState, XCEngine::RHI::ResourceStates::PixelShaderResource); - ASSERT_FALSE(request.postProcess.sourceSurface.GetColorAttachments().empty()); - EXPECT_NE(request.postProcess.sourceSurface.GetColorAttachments()[0], backBufferColorView); + ASSERT_FALSE(plan.postProcess.sourceSurface.GetColorAttachments().empty()); + EXPECT_NE(plan.postProcess.sourceSurface.GetColorAttachments()[0], backBufferColorView); EXPECT_EQ(allocationState->createTextureCalls, 1); EXPECT_EQ(allocationState->createRenderTargetViewCalls, 1); EXPECT_EQ(allocationState->createShaderViewCalls, 1); @@ -2022,22 +2022,22 @@ TEST(SceneRenderer_Test, ResolvesFinalColorPolicyFromPipelineDefaultsAndCameraOv XCEngine::Math::Vector4(1.0f, 0.95f, 0.9f, 1.0f); SceneRenderer renderer(std::make_shared(assetState)); - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(640, 360)); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, CreateValidContext(), RenderSurface(640, 360)); - ASSERT_EQ(requests.size(), 1u); - const CameraRenderRequest& request = requests[0]; - EXPECT_TRUE(request.finalColorPolicy.hasPipelineDefaults); - EXPECT_TRUE(request.finalColorPolicy.hasCameraOverrides); + ASSERT_EQ(plans.size(), 1u); + const CameraFramePlan& plan = plans[0]; + EXPECT_TRUE(plan.finalColorPolicy.hasPipelineDefaults); + EXPECT_TRUE(plan.finalColorPolicy.hasCameraOverrides); EXPECT_EQ( - request.finalColorPolicy.outputTransferMode, + plan.finalColorPolicy.outputTransferMode, FinalColorOutputTransferMode::LinearToSRGB); EXPECT_EQ( - request.finalColorPolicy.exposureMode, + plan.finalColorPolicy.exposureMode, FinalColorExposureMode::Fixed); - EXPECT_FLOAT_EQ(request.finalColorPolicy.exposureValue, 1.8f); - EXPECT_FLOAT_EQ(request.finalColorPolicy.finalColorScale.x, 0.95f); - EXPECT_FALSE(request.finalOutput.IsRequested()); + EXPECT_FLOAT_EQ(plan.finalColorPolicy.exposureValue, 1.8f); + EXPECT_FLOAT_EQ(plan.finalColorPolicy.finalColorScale.x, 0.95f); + EXPECT_FALSE(plan.finalOutput.IsRequested()); } TEST(SceneRenderer_Test, BuildsFinalOutputRequestFromResolvedFinalColorPolicy) { @@ -2085,40 +2085,40 @@ TEST(SceneRenderer_Test, BuildsFinalOutputRequestFromResolvedFinalColorPolicy) { surface.SetDepthStateAfter(XCEngine::RHI::ResourceStates::PixelShaderResource); SceneRenderer renderer(std::make_shared(assetState)); - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, context, surface); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, context, surface); - ASSERT_EQ(requests.size(), 1u); - const CameraRenderRequest& request = requests[0]; - EXPECT_FALSE(request.postProcess.IsRequested()); - EXPECT_TRUE(request.finalOutput.IsRequested()); - EXPECT_TRUE(request.finalOutput.IsValid()); - ASSERT_NE(request.finalOutput.passes, nullptr); - EXPECT_EQ(request.finalOutput.passes->GetPassCount(), 1u); - EXPECT_EQ(request.finalOutput.destinationSurface.GetColorAttachments()[0], backBufferColorView); - EXPECT_EQ(request.finalOutput.destinationSurface.GetDepthAttachment(), depthView); + ASSERT_EQ(plans.size(), 1u); + const CameraFramePlan& plan = plans[0]; + EXPECT_FALSE(plan.postProcess.IsRequested()); + EXPECT_TRUE(plan.finalOutput.IsRequested()); + EXPECT_TRUE(plan.finalOutput.IsValid()); + ASSERT_NE(plan.finalOutput.passes, nullptr); + EXPECT_EQ(plan.finalOutput.passes->GetPassCount(), 1u); + EXPECT_EQ(plan.finalOutput.destinationSurface.GetColorAttachments()[0], backBufferColorView); + EXPECT_EQ(plan.finalOutput.destinationSurface.GetDepthAttachment(), depthView); EXPECT_EQ( - request.finalOutput.destinationSurface.GetDepthStateBefore(), + plan.finalOutput.destinationSurface.GetDepthStateBefore(), XCEngine::RHI::ResourceStates::Common); EXPECT_EQ( - request.finalOutput.destinationSurface.GetDepthStateAfter(), + plan.finalOutput.destinationSurface.GetDepthStateAfter(), XCEngine::RHI::ResourceStates::PixelShaderResource); - EXPECT_EQ(request.finalOutput.sourceSurface.GetDepthAttachment(), depthView); + EXPECT_EQ(plan.finalOutput.sourceSurface.GetDepthAttachment(), depthView); EXPECT_EQ( - request.finalOutput.sourceSurface.GetDepthStateBefore(), + plan.finalOutput.sourceSurface.GetDepthStateBefore(), XCEngine::RHI::ResourceStates::Common); EXPECT_EQ( - request.finalOutput.sourceSurface.GetDepthStateAfter(), + plan.finalOutput.sourceSurface.GetDepthStateAfter(), XCEngine::RHI::ResourceStates::PixelShaderResource); - EXPECT_EQ(request.finalOutput.sourceSurface.GetWidth(), 800u); - EXPECT_EQ(request.finalOutput.sourceSurface.GetHeight(), 600u); - EXPECT_NE(request.finalOutput.sourceColorView, nullptr); - EXPECT_NE(request.finalOutput.sourceColorView, backBufferColorView); + EXPECT_EQ(plan.finalOutput.sourceSurface.GetWidth(), 800u); + EXPECT_EQ(plan.finalOutput.sourceSurface.GetHeight(), 600u); + EXPECT_NE(plan.finalOutput.sourceColorView, nullptr); + EXPECT_NE(plan.finalOutput.sourceColorView, backBufferColorView); EXPECT_EQ( - request.finalOutput.sourceColorState, + plan.finalOutput.sourceColorState, XCEngine::RHI::ResourceStates::PixelShaderResource); - ASSERT_FALSE(request.finalOutput.sourceSurface.GetColorAttachments().empty()); - EXPECT_NE(request.finalOutput.sourceSurface.GetColorAttachments()[0], backBufferColorView); + ASSERT_FALSE(plan.finalOutput.sourceSurface.GetColorAttachments().empty()); + EXPECT_NE(plan.finalOutput.sourceSurface.GetColorAttachments()[0], backBufferColorView); EXPECT_EQ(allocationState->createTextureCalls, 1); EXPECT_EQ(allocationState->createRenderTargetViewCalls, 1); EXPECT_EQ(allocationState->createShaderViewCalls, 1); @@ -2171,66 +2171,66 @@ TEST(SceneRenderer_Test, RoutesPostProcessIntoIntermediateSurfaceBeforeFinalOutp surface.SetDepthStateAfter(XCEngine::RHI::ResourceStates::PixelShaderResource); SceneRenderer renderer; - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, context, surface); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, context, surface); - ASSERT_EQ(requests.size(), 1u); - const CameraRenderRequest& request = requests[0]; - EXPECT_TRUE(request.postProcess.IsRequested()); - EXPECT_TRUE(request.finalOutput.IsRequested()); - ASSERT_NE(request.postProcess.passes, nullptr); - ASSERT_NE(request.finalOutput.passes, nullptr); - EXPECT_EQ(request.postProcess.passes->GetPassCount(), 1u); - EXPECT_EQ(request.finalOutput.passes->GetPassCount(), 1u); + ASSERT_EQ(plans.size(), 1u); + const CameraFramePlan& plan = plans[0]; + EXPECT_TRUE(plan.postProcess.IsRequested()); + EXPECT_TRUE(plan.finalOutput.IsRequested()); + ASSERT_NE(plan.postProcess.passes, nullptr); + ASSERT_NE(plan.finalOutput.passes, nullptr); + EXPECT_EQ(plan.postProcess.passes->GetPassCount(), 1u); + EXPECT_EQ(plan.finalOutput.passes->GetPassCount(), 1u); - ASSERT_FALSE(request.postProcess.sourceSurface.GetColorAttachments().empty()); - ASSERT_FALSE(request.postProcess.destinationSurface.GetColorAttachments().empty()); - ASSERT_FALSE(request.finalOutput.sourceSurface.GetColorAttachments().empty()); + ASSERT_FALSE(plan.postProcess.sourceSurface.GetColorAttachments().empty()); + ASSERT_FALSE(plan.postProcess.destinationSurface.GetColorAttachments().empty()); + ASSERT_FALSE(plan.finalOutput.sourceSurface.GetColorAttachments().empty()); EXPECT_NE( - request.postProcess.sourceSurface.GetColorAttachments()[0], - request.postProcess.destinationSurface.GetColorAttachments()[0]); + plan.postProcess.sourceSurface.GetColorAttachments()[0], + plan.postProcess.destinationSurface.GetColorAttachments()[0]); EXPECT_EQ( - request.finalOutput.sourceSurface.GetColorAttachments()[0], - request.postProcess.destinationSurface.GetColorAttachments()[0]); - EXPECT_EQ(request.finalOutput.destinationSurface.GetColorAttachments()[0], backBufferColorView); + plan.finalOutput.sourceSurface.GetColorAttachments()[0], + plan.postProcess.destinationSurface.GetColorAttachments()[0]); + EXPECT_EQ(plan.finalOutput.destinationSurface.GetColorAttachments()[0], backBufferColorView); - EXPECT_EQ(request.postProcess.sourceSurface.GetDepthAttachment(), depthView); + EXPECT_EQ(plan.postProcess.sourceSurface.GetDepthAttachment(), depthView); EXPECT_EQ( - request.postProcess.sourceSurface.GetDepthStateBefore(), + plan.postProcess.sourceSurface.GetDepthStateBefore(), XCEngine::RHI::ResourceStates::Common); EXPECT_EQ( - request.postProcess.sourceSurface.GetDepthStateAfter(), + plan.postProcess.sourceSurface.GetDepthStateAfter(), XCEngine::RHI::ResourceStates::PixelShaderResource); - EXPECT_EQ(request.postProcess.destinationSurface.GetDepthAttachment(), nullptr); - EXPECT_EQ(request.finalOutput.sourceSurface.GetDepthAttachment(), nullptr); - EXPECT_EQ(request.finalOutput.destinationSurface.GetDepthAttachment(), depthView); + EXPECT_EQ(plan.postProcess.destinationSurface.GetDepthAttachment(), nullptr); + EXPECT_EQ(plan.finalOutput.sourceSurface.GetDepthAttachment(), nullptr); + EXPECT_EQ(plan.finalOutput.destinationSurface.GetDepthAttachment(), depthView); EXPECT_EQ( - request.finalOutput.destinationSurface.GetDepthStateBefore(), + plan.finalOutput.destinationSurface.GetDepthStateBefore(), XCEngine::RHI::ResourceStates::Common); EXPECT_EQ( - request.finalOutput.destinationSurface.GetDepthStateAfter(), + plan.finalOutput.destinationSurface.GetDepthStateAfter(), XCEngine::RHI::ResourceStates::PixelShaderResource); - const XCEngine::Math::RectInt postProcessSourceArea = request.postProcess.sourceSurface.GetRenderArea(); + const XCEngine::Math::RectInt postProcessSourceArea = plan.postProcess.sourceSurface.GetRenderArea(); EXPECT_EQ(postProcessSourceArea.x, 200); EXPECT_EQ(postProcessSourceArea.y, 75); EXPECT_EQ(postProcessSourceArea.width, 400); EXPECT_EQ(postProcessSourceArea.height, 375); - const XCEngine::Math::RectInt finalOutputSourceArea = request.finalOutput.sourceSurface.GetRenderArea(); + const XCEngine::Math::RectInt finalOutputSourceArea = plan.finalOutput.sourceSurface.GetRenderArea(); EXPECT_EQ(finalOutputSourceArea.x, 200); EXPECT_EQ(finalOutputSourceArea.y, 75); EXPECT_EQ(finalOutputSourceArea.width, 400); EXPECT_EQ(finalOutputSourceArea.height, 375); - EXPECT_NE(request.postProcess.sourceColorView, nullptr); - EXPECT_NE(request.finalOutput.sourceColorView, nullptr); - EXPECT_NE(request.postProcess.sourceColorView, request.finalOutput.sourceColorView); + EXPECT_NE(plan.postProcess.sourceColorView, nullptr); + EXPECT_NE(plan.finalOutput.sourceColorView, nullptr); + EXPECT_NE(plan.postProcess.sourceColorView, plan.finalOutput.sourceColorView); EXPECT_EQ( - request.postProcess.sourceColorState, + plan.postProcess.sourceColorState, XCEngine::RHI::ResourceStates::PixelShaderResource); EXPECT_EQ( - request.finalOutput.sourceColorState, + plan.finalOutput.sourceColorState, XCEngine::RHI::ResourceStates::PixelShaderResource); EXPECT_EQ(allocationState->createTextureCalls, 2); EXPECT_EQ(allocationState->createRenderTargetViewCalls, 2); @@ -2280,14 +2280,14 @@ TEST(SceneRenderer_Test, DoesNotBuildFullscreenStagesForMultisampledMainSceneSur surface.SetSampleDesc(4u, 0u); SceneRenderer renderer; - const std::vector requests = - renderer.BuildRenderRequests(scene, nullptr, context, surface); + const std::vector plans = + renderer.BuildFramePlans(scene, nullptr, context, surface); - ASSERT_EQ(requests.size(), 1u); - const CameraRenderRequest& request = requests[0]; - EXPECT_EQ(request.surface.GetSampleCount(), 4u); - EXPECT_FALSE(request.postProcess.IsRequested()); - EXPECT_FALSE(request.finalOutput.IsRequested()); + ASSERT_EQ(plans.size(), 1u); + const CameraFramePlan& plan = plans[0]; + EXPECT_EQ(plan.request.surface.GetSampleCount(), 4u); + EXPECT_FALSE(plan.postProcess.IsRequested()); + EXPECT_FALSE(plan.finalOutput.IsRequested()); EXPECT_EQ(allocationState->createTextureCalls, 0); EXPECT_EQ(allocationState->createRenderTargetViewCalls, 0); EXPECT_EQ(allocationState->createShaderViewCalls, 0); @@ -2332,24 +2332,24 @@ TEST(SceneRenderer_Test, ReusesTrackedSceneColorStateAcrossFramesWhenPostProcess SceneRenderer renderer(std::make_unique(pipelineState)); - std::vector firstFrameRequests = - renderer.BuildRenderRequests(scene, nullptr, context, surface); - ASSERT_EQ(firstFrameRequests.size(), 1u); - CameraFramePlan firstFramePlan = CameraFramePlan::FromRequest(firstFrameRequests[0]); + std::vector firstFramePlans = + renderer.BuildFramePlans(scene, nullptr, context, surface); + ASSERT_EQ(firstFramePlans.size(), 1u); + CameraFramePlan firstFramePlan = firstFramePlans[0]; EXPECT_EQ( firstFramePlan.GetMainSceneSurface().GetColorStateBefore(), XCEngine::RHI::ResourceStates::Common); RenderPassSequence postProcessPasses; postProcessPasses.AddPass(std::make_unique(pipelineState, "postProcess")); - firstFrameRequests[0].postProcess.passes = &postProcessPasses; + firstFramePlans[0].postProcess.passes = &postProcessPasses; - ASSERT_TRUE(renderer.Render(firstFrameRequests)); + ASSERT_TRUE(renderer.Render(firstFramePlans)); - const std::vector secondFrameRequests = - renderer.BuildRenderRequests(scene, nullptr, context, surface); - ASSERT_EQ(secondFrameRequests.size(), 1u); - const CameraFramePlan secondFramePlan = CameraFramePlan::FromRequest(secondFrameRequests[0]); + const std::vector secondFramePlans = + renderer.BuildFramePlans(scene, nullptr, context, surface); + ASSERT_EQ(secondFramePlans.size(), 1u); + const CameraFramePlan secondFramePlan = secondFramePlans[0]; EXPECT_EQ( secondFramePlan.GetMainSceneSurface().GetColorStateBefore(), XCEngine::RHI::ResourceStates::PixelShaderResource); @@ -2402,12 +2402,12 @@ TEST(SceneRenderer_Test, ReusesTrackedPostProcessOutputStateAcrossFramesWhenFina SceneRenderer renderer(std::make_unique(pipelineState)); - std::vector firstFrameRequests = - renderer.BuildRenderRequests(scene, nullptr, context, surface); - ASSERT_EQ(firstFrameRequests.size(), 1u); - CameraFramePlan firstFramePlan = CameraFramePlan::FromRequest(firstFrameRequests[0]); - EXPECT_TRUE(firstFrameRequests[0].postProcess.IsRequested()); - EXPECT_TRUE(firstFrameRequests[0].finalOutput.IsRequested()); + std::vector firstFramePlans = + renderer.BuildFramePlans(scene, nullptr, context, surface); + ASSERT_EQ(firstFramePlans.size(), 1u); + CameraFramePlan firstFramePlan = firstFramePlans[0]; + EXPECT_TRUE(firstFramePlans[0].postProcess.IsRequested()); + EXPECT_TRUE(firstFramePlans[0].finalOutput.IsRequested()); EXPECT_EQ( firstFramePlan.GetMainSceneSurface().GetColorStateBefore(), XCEngine::RHI::ResourceStates::Common); @@ -2419,15 +2419,15 @@ TEST(SceneRenderer_Test, ReusesTrackedPostProcessOutputStateAcrossFramesWhenFina postProcessPasses.AddPass(std::make_unique(pipelineState, "postProcess")); RenderPassSequence finalOutputPasses; finalOutputPasses.AddPass(std::make_unique(pipelineState, "finalOutput")); - firstFrameRequests[0].postProcess.passes = &postProcessPasses; - firstFrameRequests[0].finalOutput.passes = &finalOutputPasses; + firstFramePlans[0].postProcess.passes = &postProcessPasses; + firstFramePlans[0].finalOutput.passes = &finalOutputPasses; - ASSERT_TRUE(renderer.Render(firstFrameRequests)); + ASSERT_TRUE(renderer.Render(firstFramePlans)); - const std::vector secondFrameRequests = - renderer.BuildRenderRequests(scene, nullptr, context, surface); - ASSERT_EQ(secondFrameRequests.size(), 1u); - const CameraFramePlan secondFramePlan = CameraFramePlan::FromRequest(secondFrameRequests[0]); + const std::vector secondFramePlans = + renderer.BuildFramePlans(scene, nullptr, context, surface); + ASSERT_EQ(secondFramePlans.size(), 1u); + const CameraFramePlan secondFramePlan = secondFramePlans[0]; EXPECT_EQ( secondFramePlan.GetMainSceneSurface().GetColorStateBefore(), XCEngine::RHI::ResourceStates::PixelShaderResource);