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

Graph-manage camera fullscreen stage routing

Browse Source
This commit is contained in:
ssdfasd
2026-04-14 19:32:27 +08:00
parent c4fe643427
commit c710063d92
10 changed files with 337 additions and 440 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -2735,9 +2735,12 @@ TEST(SceneRenderer_Test, BuildsCameraColorScalePostProcessRequestFromCameraPassS
ASSERT_EQ(plans.size(), 1u);
const CameraFramePlan& plan = plans[0];
EXPECT_TRUE(plan.postProcess.IsRequested());
EXPECT_TRUE(plan.postProcess.IsValid());
EXPECT_TRUE(plan.IsPostProcessStageValid());
EXPECT_NE(plan.postProcess.passes, nullptr);
ASSERT_EQ(plan.postProcess.passes->GetPassCount(), 2u);
EXPECT_TRUE(plan.usesGraphManagedMainSceneColor);
EXPECT_FALSE(plan.usesGraphManagedPostProcessColor);
EXPECT_EQ(plan.postProcessSource, CameraFrameColorSource::MainSceneColor);
EXPECT_EQ(plan.postProcess.destinationSurface.GetColorAttachments()[0], backBufferColorView);
EXPECT_EQ(plan.postProcess.destinationSurface.GetDepthAttachment(), depthView);
EXPECT_EQ(
@@ -2746,30 +2749,28 @@ TEST(SceneRenderer_Test, BuildsCameraColorScalePostProcessRequestFromCameraPassS
EXPECT_EQ(
plan.postProcess.destinationSurface.GetDepthStateAfter(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
EXPECT_EQ(plan.postProcess.sourceSurface.GetDepthAttachment(), depthView);
EXPECT_EQ(plan.GetMainSceneSurface().GetDepthAttachment(), depthView);
EXPECT_EQ(
plan.postProcess.sourceSurface.GetDepthStateBefore(),
plan.GetMainSceneSurface().GetDepthStateBefore(),
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(
plan.postProcess.sourceSurface.GetDepthStateAfter(),
plan.GetMainSceneSurface().GetDepthStateAfter(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
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(plan.GetMainSceneSurface().GetWidth(), 800u);
EXPECT_EQ(plan.GetMainSceneSurface().GetHeight(), 600u);
const XCEngine::Math::RectInt sourceRenderArea = plan.GetMainSceneSurface().GetRenderArea();
EXPECT_EQ(sourceRenderArea.x, 200);
EXPECT_EQ(sourceRenderArea.y, 75);
EXPECT_EQ(sourceRenderArea.width, 400);
EXPECT_EQ(sourceRenderArea.height, 375);
EXPECT_NE(plan.postProcess.sourceColorView, nullptr);
EXPECT_NE(plan.postProcess.sourceColorView, backBufferColorView);
EXPECT_EQ(plan.GetSourceSurface(CameraFrameStage::PostProcess), nullptr);
EXPECT_EQ(plan.GetSourceColorView(CameraFrameStage::PostProcess), nullptr);
EXPECT_EQ(
plan.postProcess.sourceColorState,
XCEngine::RHI::ResourceStates::PixelShaderResource);
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);
plan.GetSourceColorState(CameraFrameStage::PostProcess),
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(allocationState->createTextureCalls, 0);
EXPECT_EQ(allocationState->createRenderTargetViewCalls, 0);
EXPECT_EQ(allocationState->createShaderViewCalls, 0);
delete depthView;
delete backBufferColorView;
@@ -2870,9 +2871,11 @@ TEST(SceneRenderer_Test, BuildsFinalOutputRequestFromResolvedFinalColorPolicy) {
const CameraFramePlan& plan = plans[0];
EXPECT_FALSE(plan.postProcess.IsRequested());
EXPECT_TRUE(plan.finalOutput.IsRequested());
EXPECT_TRUE(plan.finalOutput.IsValid());
EXPECT_TRUE(plan.IsFinalOutputStageValid());
ASSERT_NE(plan.finalOutput.passes, nullptr);
EXPECT_EQ(plan.finalOutput.passes->GetPassCount(), 1u);
EXPECT_TRUE(plan.usesGraphManagedMainSceneColor);
EXPECT_EQ(plan.finalOutputSource, CameraFrameColorSource::MainSceneColor);
EXPECT_EQ(plan.finalOutput.destinationSurface.GetColorAttachments()[0], backBufferColorView);
EXPECT_EQ(plan.finalOutput.destinationSurface.GetDepthAttachment(), depthView);
EXPECT_EQ(
@@ -2881,25 +2884,23 @@ TEST(SceneRenderer_Test, BuildsFinalOutputRequestFromResolvedFinalColorPolicy) {
EXPECT_EQ(
plan.finalOutput.destinationSurface.GetDepthStateAfter(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
EXPECT_EQ(plan.finalOutput.sourceSurface.GetDepthAttachment(), depthView);
EXPECT_EQ(plan.GetMainSceneSurface().GetDepthAttachment(), depthView);
EXPECT_EQ(
plan.finalOutput.sourceSurface.GetDepthStateBefore(),
plan.GetMainSceneSurface().GetDepthStateBefore(),
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(
plan.finalOutput.sourceSurface.GetDepthStateAfter(),
plan.GetMainSceneSurface().GetDepthStateAfter(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
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(plan.GetMainSceneSurface().GetWidth(), 800u);
EXPECT_EQ(plan.GetMainSceneSurface().GetHeight(), 600u);
EXPECT_EQ(plan.GetSourceSurface(CameraFrameStage::FinalOutput), nullptr);
EXPECT_EQ(plan.GetSourceColorView(CameraFrameStage::FinalOutput), nullptr);
EXPECT_EQ(
plan.finalOutput.sourceColorState,
XCEngine::RHI::ResourceStates::PixelShaderResource);
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);
plan.GetSourceColorState(CameraFrameStage::FinalOutput),
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(allocationState->createTextureCalls, 0);
EXPECT_EQ(allocationState->createRenderTargetViewCalls, 0);
EXPECT_EQ(allocationState->createShaderViewCalls, 0);
delete depthView;
delete backBufferColorView;
@@ -2956,32 +2957,21 @@ TEST(SceneRenderer_Test, RoutesPostProcessIntoIntermediateSurfaceBeforeFinalOutp
const CameraFramePlan& plan = plans[0];
EXPECT_TRUE(plan.postProcess.IsRequested());
EXPECT_TRUE(plan.finalOutput.IsRequested());
EXPECT_TRUE(plan.IsPostProcessStageValid());
EXPECT_TRUE(plan.IsFinalOutputStageValid());
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);
EXPECT_TRUE(plan.usesGraphManagedMainSceneColor);
EXPECT_TRUE(plan.usesGraphManagedPostProcessColor);
EXPECT_EQ(plan.postProcessSource, CameraFrameColorSource::MainSceneColor);
EXPECT_EQ(plan.finalOutputSource, CameraFrameColorSource::PostProcessColor);
ASSERT_FALSE(plan.postProcess.sourceSurface.GetColorAttachments().empty());
ASSERT_FALSE(plan.postProcess.destinationSurface.GetColorAttachments().empty());
ASSERT_FALSE(plan.finalOutput.sourceSurface.GetColorAttachments().empty());
EXPECT_NE(
plan.postProcess.sourceSurface.GetColorAttachments()[0],
plan.postProcess.destinationSurface.GetColorAttachments()[0]);
EXPECT_EQ(
plan.finalOutput.sourceSurface.GetColorAttachments()[0],
plan.postProcess.destinationSurface.GetColorAttachments()[0]);
EXPECT_EQ(plan.GetSourceSurface(CameraFrameStage::PostProcess), nullptr);
EXPECT_EQ(plan.GetOutputSurface(CameraFrameStage::PostProcess), nullptr);
EXPECT_EQ(plan.GetSourceSurface(CameraFrameStage::FinalOutput), nullptr);
EXPECT_EQ(plan.finalOutput.destinationSurface.GetColorAttachments()[0], backBufferColorView);
EXPECT_EQ(plan.postProcess.sourceSurface.GetDepthAttachment(), depthView);
EXPECT_EQ(
plan.postProcess.sourceSurface.GetDepthStateBefore(),
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(
plan.postProcess.sourceSurface.GetDepthStateAfter(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
EXPECT_EQ(plan.postProcess.destinationSurface.GetDepthAttachment(), nullptr);
EXPECT_EQ(plan.finalOutput.sourceSurface.GetDepthAttachment(), nullptr);
EXPECT_EQ(plan.finalOutput.destinationSurface.GetDepthAttachment(), depthView);
EXPECT_EQ(
plan.finalOutput.destinationSurface.GetDepthStateBefore(),
@@ -2989,30 +2979,27 @@ TEST(SceneRenderer_Test, RoutesPostProcessIntoIntermediateSurfaceBeforeFinalOutp
EXPECT_EQ(
plan.finalOutput.destinationSurface.GetDepthStateAfter(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
const XCEngine::Math::RectInt postProcessSourceArea = plan.postProcess.sourceSurface.GetRenderArea();
const XCEngine::Math::RectInt postProcessSourceArea = plan.GetMainSceneSurface().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 = plan.finalOutput.sourceSurface.GetRenderArea();
const XCEngine::Math::RectInt finalOutputSourceArea = plan.GetMainSceneSurface().GetRenderArea();
EXPECT_EQ(finalOutputSourceArea.x, 200);
EXPECT_EQ(finalOutputSourceArea.y, 75);
EXPECT_EQ(finalOutputSourceArea.width, 400);
EXPECT_EQ(finalOutputSourceArea.height, 375);
EXPECT_NE(plan.postProcess.sourceColorView, nullptr);
EXPECT_NE(plan.finalOutput.sourceColorView, nullptr);
EXPECT_NE(plan.postProcess.sourceColorView, plan.finalOutput.sourceColorView);
EXPECT_EQ(plan.GetSourceColorView(CameraFrameStage::PostProcess), nullptr);
EXPECT_EQ(plan.GetSourceColorView(CameraFrameStage::FinalOutput), nullptr);
EXPECT_EQ(
plan.postProcess.sourceColorState,
XCEngine::RHI::ResourceStates::PixelShaderResource);
plan.GetSourceColorState(CameraFrameStage::PostProcess),
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(
plan.finalOutput.sourceColorState,
XCEngine::RHI::ResourceStates::PixelShaderResource);
EXPECT_EQ(allocationState->createTextureCalls, 2);
EXPECT_EQ(allocationState->createRenderTargetViewCalls, 2);
EXPECT_EQ(allocationState->createShaderViewCalls, 2);
plan.GetSourceColorState(CameraFrameStage::FinalOutput),
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(allocationState->createTextureCalls, 0);
EXPECT_EQ(allocationState->createRenderTargetViewCalls, 0);
EXPECT_EQ(allocationState->createShaderViewCalls, 0);
delete depthView;
delete backBufferColorView;
@@ -3074,7 +3061,7 @@ TEST(SceneRenderer_Test, DoesNotBuildFullscreenStagesForMultisampledMainSceneSur
delete backBufferColorView;
}
TEST(SceneRenderer_Test, ReusesTrackedSceneColorStateAcrossFramesWhenPostProcessIsEnabled) {
TEST(SceneRenderer_Test, KeepsMainSceneGraphManagedWhenPostProcessIsEnabledAcrossFrames) {
Scene scene("SceneRendererTrackedSceneColorStateScene");
GameObject* cameraObject = scene.CreateGameObject("Camera");
@@ -3087,6 +3074,7 @@ TEST(SceneRenderer_Test, ReusesTrackedSceneColorStateAcrossFramesWhenPostProcess
});
auto pipelineState = std::make_shared<MockPipelineState>();
pipelineState->supportsMainSceneRenderGraph = true;
auto allocationState = std::make_shared<MockShadowAllocationState>();
MockShadowDevice device(allocationState);
@@ -3114,6 +3102,8 @@ TEST(SceneRenderer_Test, ReusesTrackedSceneColorStateAcrossFramesWhenPostProcess
renderer.BuildFramePlans(scene, nullptr, context, surface);
ASSERT_EQ(firstFramePlans.size(), 1u);
CameraFramePlan firstFramePlan = firstFramePlans[0];
EXPECT_TRUE(firstFramePlan.usesGraphManagedMainSceneColor);
EXPECT_EQ(firstFramePlan.postProcessSource, CameraFrameColorSource::MainSceneColor);
EXPECT_EQ(
firstFramePlan.GetMainSceneSurface().GetColorStateBefore(),
XCEngine::RHI::ResourceStates::Common);
@@ -3123,23 +3113,31 @@ TEST(SceneRenderer_Test, ReusesTrackedSceneColorStateAcrossFramesWhenPostProcess
firstFramePlans[0].postProcess.passes = &postProcessPasses;
ASSERT_TRUE(renderer.Render(firstFramePlans));
const int createTextureCallsAfterFirstRender = allocationState->createTextureCalls;
const int createRenderTargetViewCallsAfterFirstRender =
allocationState->createRenderTargetViewCalls;
const int createShaderViewCallsAfterFirstRender = allocationState->createShaderViewCalls;
const std::vector<CameraFramePlan> secondFramePlans =
renderer.BuildFramePlans(scene, nullptr, context, surface);
ASSERT_EQ(secondFramePlans.size(), 1u);
const CameraFramePlan secondFramePlan = secondFramePlans[0];
EXPECT_TRUE(secondFramePlan.usesGraphManagedMainSceneColor);
EXPECT_EQ(secondFramePlan.postProcessSource, CameraFrameColorSource::MainSceneColor);
EXPECT_EQ(
secondFramePlan.GetMainSceneSurface().GetColorStateBefore(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(allocationState->createTextureCalls, createTextureCallsAfterFirstRender);
EXPECT_EQ(
secondFramePlan.GetMainSceneSurface().GetColorStateAfter(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
allocationState->createRenderTargetViewCalls,
createRenderTargetViewCallsAfterFirstRender);
EXPECT_EQ(allocationState->createShaderViewCalls, createShaderViewCallsAfterFirstRender);
delete depthView;
delete backBufferColorView;
}
TEST(SceneRenderer_Test, ReusesTrackedPostProcessOutputStateAcrossFramesWhenFinalOutputIsEnabled) {
TEST(SceneRenderer_Test, KeepsPostProcessOutputGraphManagedWhenFinalOutputIsEnabledAcrossFrames) {
Scene scene("SceneRendererTrackedPostProcessOutputStateScene");
GameObject* cameraObject = scene.CreateGameObject("Camera");
@@ -3157,6 +3155,7 @@ TEST(SceneRenderer_Test, ReusesTrackedPostProcessOutputStateAcrossFramesWhenFina
camera->SetFinalColorOverrides(finalColorOverrides);
auto pipelineState = std::make_shared<MockPipelineState>();
pipelineState->supportsMainSceneRenderGraph = true;
auto allocationState = std::make_shared<MockShadowAllocationState>();
MockShadowDevice device(allocationState);
@@ -3186,12 +3185,14 @@ TEST(SceneRenderer_Test, ReusesTrackedPostProcessOutputStateAcrossFramesWhenFina
CameraFramePlan firstFramePlan = firstFramePlans[0];
EXPECT_TRUE(firstFramePlans[0].postProcess.IsRequested());
EXPECT_TRUE(firstFramePlans[0].finalOutput.IsRequested());
EXPECT_TRUE(firstFramePlan.usesGraphManagedMainSceneColor);
EXPECT_TRUE(firstFramePlan.usesGraphManagedPostProcessColor);
EXPECT_EQ(firstFramePlan.postProcessSource, CameraFrameColorSource::MainSceneColor);
EXPECT_EQ(firstFramePlan.finalOutputSource, CameraFrameColorSource::PostProcessColor);
EXPECT_EQ(
firstFramePlan.GetMainSceneSurface().GetColorStateBefore(),
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(
firstFramePlan.postProcess.destinationSurface.GetColorStateBefore(),
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(firstFramePlan.GetOutputSurface(CameraFrameStage::PostProcess), nullptr);
RenderPassSequence postProcessPasses;
postProcessPasses.AddPass(std::make_unique<MockScenePass>(pipelineState, "postProcess"));
@@ -3201,20 +3202,29 @@ TEST(SceneRenderer_Test, ReusesTrackedPostProcessOutputStateAcrossFramesWhenFina
firstFramePlans[0].finalOutput.passes = &finalOutputPasses;
ASSERT_TRUE(renderer.Render(firstFramePlans));
const int createTextureCallsAfterFirstRender = allocationState->createTextureCalls;
const int createRenderTargetViewCallsAfterFirstRender =
allocationState->createRenderTargetViewCalls;
const int createShaderViewCallsAfterFirstRender = allocationState->createShaderViewCalls;
const std::vector<CameraFramePlan> secondFramePlans =
renderer.BuildFramePlans(scene, nullptr, context, surface);
ASSERT_EQ(secondFramePlans.size(), 1u);
const CameraFramePlan secondFramePlan = secondFramePlans[0];
EXPECT_TRUE(secondFramePlan.usesGraphManagedMainSceneColor);
EXPECT_TRUE(secondFramePlan.usesGraphManagedPostProcessColor);
EXPECT_EQ(secondFramePlan.postProcessSource, CameraFrameColorSource::MainSceneColor);
EXPECT_EQ(secondFramePlan.finalOutputSource, CameraFrameColorSource::PostProcessColor);
EXPECT_EQ(
secondFramePlan.GetMainSceneSurface().GetColorStateBefore(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
XCEngine::RHI::ResourceStates::Common);
EXPECT_EQ(secondFramePlan.GetOutputSurface(CameraFrameStage::PostProcess), nullptr);
EXPECT_EQ(secondFramePlan.GetSourceSurface(CameraFrameStage::FinalOutput), nullptr);
EXPECT_EQ(allocationState->createTextureCalls, createTextureCallsAfterFirstRender);
EXPECT_EQ(
secondFramePlan.postProcess.destinationSurface.GetColorStateBefore(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
EXPECT_EQ(
secondFramePlan.finalOutput.sourceSurface.GetColorStateBefore(),
XCEngine::RHI::ResourceStates::PixelShaderResource);
allocationState->createRenderTargetViewCalls,
createRenderTargetViewCallsAfterFirstRender);
EXPECT_EQ(allocationState->createShaderViewCalls, createShaderViewCallsAfterFirstRender);
delete depthView;
delete backBufferColorView;