xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate scene renderer callers to frame plans

Browse Source
This commit is contained in:
ssdfasd
2026-04-14 00:52:43 +08:00
parent 72914b3865
commit b8d29e39f6
5 changed files with 196 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
engine/include/XCEngine/Rendering/Execution/SceneRenderer.h
View File

@@ -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<CameraRenderRequest> 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<CameraRenderRequest>& requests);
bool Render(const CameraFramePlan& plan);
@@ -53,7 +55,7 @@ public:
const RenderSurface& surface);
private:
std::vector<CameraFramePlan> CreateFramePlansFromRequests(
std::vector<CameraFramePlan> CreateFramePlansFromLegacyRequests(
const std::vector<CameraRenderRequest>& requests) const;
void PrepareOwnedFullscreenStageState(size_t requestCount);
void ResolveCameraFinalColorPolicies(

6
engine/src/Rendering/Execution/SceneRenderer.cpp
View File

@@ -119,7 +119,7 @@ std::vector<CameraFramePlan> SceneRenderer::BuildFramePlans(
const RenderSurface& surface) {
const std::vector<CameraRenderRequest> requests =
m_requestPlanner.BuildRequests(scene, overrideCamera, context, surface);
std::vector<CameraFramePlan> plans = CreateFramePlansFromRequests(requests);
std::vector<CameraFramePlan> 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<CameraRenderRequest>& requests) {
std::vector<CameraFramePlan> plans = CreateFramePlansFromRequests(requests);
std::vector<CameraFramePlan> plans = CreateFramePlansFromLegacyRequests(requests);
return Render(plans);
}
@@ -184,7 +184,7 @@ bool SceneRenderer::Render(
return Render(BuildFramePlans(scene, overrideCamera, context, surface));
}
std::vector<CameraFramePlan> SceneRenderer::CreateFramePlansFromRequests(
std::vector<CameraFramePlan> SceneRenderer::CreateFramePlansFromLegacyRequests(
const std::vector<CameraRenderRequest>& requests) const {
std::vector<CameraFramePlan> plans = {};
plans.reserve(requests.size());

18
tests/Rendering/integration/alpha_cutout_scene/main.cpp
View File

@@ -503,19 +503,19 @@ void AlphaCutoutSceneTest::RenderFrame() {
renderContext.commandQueue = GetCommandQueue();
renderContext.backendType = GetBackendType();
std::vector<CameraRenderRequest> requests =
mSceneRenderer->BuildRenderRequests(*mScene, nullptr, renderContext, mainSurface);
ASSERT_EQ(requests.size(), 1u);
ASSERT_TRUE(requests[0].directionalShadow.IsValid());
std::vector<CameraFramePlan> 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 };

8
tests/Rendering/integration/directional_shadow_scene/main.cpp
View File

@@ -449,10 +449,10 @@ void DirectionalShadowSceneTest::RenderSceneFrame() {
renderContext.commandQueue = GetCommandQueue();
renderContext.backendType = GetBackendType();
std::vector<CameraRenderRequest> requests =
mSceneRenderer->BuildRenderRequests(*mScene, nullptr, renderContext, surface);
ASSERT_FALSE(requests.empty());
ASSERT_TRUE(mSceneRenderer->Render(requests));
std::vector<CameraFramePlan> plans =
mSceneRenderer->BuildFramePlans(*mScene, nullptr, renderContext, surface);
ASSERT_FALSE(plans.empty());
ASSERT_TRUE(mSceneRenderer->Render(plans));
Log("[TEST] DirectionalShadowSceneTest: closing command list");
commandList->Close();

354
tests/Rendering/unit/test_camera_scene_renderer.cpp
View File

@@ -1724,23 +1724,23 @@ TEST(SceneRenderer_Test, BuildsSortedRequestsForAllUsableCamerasAndHonorsOverrid
const RenderContext context = CreateValidContext();
const RenderSurface surface(320, 180);
const std::vector<CameraRenderRequest> 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<CameraFramePlan> 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<CameraRenderRequest> 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<CameraFramePlan> 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<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(640, 360));
const std::vector<CameraFramePlan> 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<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(640, 360));
const std::vector<CameraFramePlan> 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<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(320, 180));
const std::vector<CameraFramePlan> 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<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, camera, CreateValidContext(), RenderSurface(640, 360));
const std::vector<CameraFramePlan> 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<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(800, 600));
const std::vector<CameraFramePlan> 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<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), surface);
const std::vector<CameraFramePlan> 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<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), surface);
const std::vector<CameraFramePlan> 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<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, context, surface);
const std::vector<CameraFramePlan> 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<MockPipelineAsset>(assetState));
const std::vector<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(640, 360));
const std::vector<CameraFramePlan> 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<MockPipelineAsset>(assetState));
const std::vector<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, context, surface);
const std::vector<CameraFramePlan> 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<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, context, surface);
const std::vector<CameraFramePlan> 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<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, context, surface);
const std::vector<CameraFramePlan> 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<MockPipeline>(pipelineState));
std::vector<CameraRenderRequest> firstFrameRequests =
renderer.BuildRenderRequests(scene, nullptr, context, surface);
ASSERT_EQ(firstFrameRequests.size(), 1u);
CameraFramePlan firstFramePlan = CameraFramePlan::FromRequest(firstFrameRequests[0]);
std::vector<CameraFramePlan> 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<MockScenePass>(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<CameraRenderRequest> secondFrameRequests =
renderer.BuildRenderRequests(scene, nullptr, context, surface);
ASSERT_EQ(secondFrameRequests.size(), 1u);
const CameraFramePlan secondFramePlan = CameraFramePlan::FromRequest(secondFrameRequests[0]);
const std::vector<CameraFramePlan> 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<MockPipeline>(pipelineState));
std::vector<CameraRenderRequest> 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<CameraFramePlan> 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<MockScenePass>(pipelineState, "postProcess"));
RenderPassSequence finalOutputPasses;
finalOutputPasses.AddPass(std::make_unique<MockScenePass>(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<CameraRenderRequest> secondFrameRequests =
renderer.BuildRenderRequests(scene, nullptr, context, surface);
ASSERT_EQ(secondFrameRequests.size(), 1u);
const CameraFramePlan secondFramePlan = CameraFramePlan::FromRequest(secondFrameRequests[0]);
const std::vector<CameraFramePlan> 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);