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

refactor(rendering): move scene data policy into render pipelines

Browse Source
This commit is contained in:
ssdfasd
2026-04-15 21:28:02 +08:00
parent 215c353ace
commit f2eebfc842
5 changed files with 115 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
engine/CMakeLists.txt
View File

@@ -600,6 +600,7 @@ add_library(XCEngine STATIC
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Features/BuiltinGaussianSplatPass.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Features/BuiltinVolumetricPass.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Features/Internal/BuiltinGaussianSplatPassResources.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/RenderPipeline.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/RenderPipelineAsset.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/RenderSurface.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/SceneRenderFeaturePass.cpp

5
engine/include/XCEngine/Rendering/RenderPipeline.h
View File

@@ -18,6 +18,7 @@ namespace XCEngine {
namespace Rendering {
class RenderGraphBuilder;
struct CameraFramePlan;
struct RenderPipelineStageRenderGraphContext {
RenderGraphBuilder& graphBuilder;
@@ -84,6 +85,10 @@ public:
~RenderPipeline() override = default;
virtual void ConfigureRenderSceneData(
const CameraFramePlan& plan,
RenderSceneData& sceneData) const;
void SetCameraFrameStandalonePass(
CameraFrameStage stage,
std::unique_ptr<RenderPass> pass) {

41
engine/src/Rendering/Execution/CameraRenderer.cpp
View File

@@ -31,41 +31,6 @@ std::unique_ptr<RenderPipeline> CreatePipelineFromAsset(
return std::make_unique<Pipelines::ScriptableRenderPipelineHost>();
}
Resources::ShaderKeywordSet BuildSceneGlobalShaderKeywords(
const RenderSceneData& sceneData) {
Resources::ShaderKeywordSet keywords = {};
if (sceneData.lighting.HasMainDirectionalShadow()) {
keywords.enabledKeywords.PushBack("XC_MAIN_LIGHT_SHADOWS");
}
Resources::NormalizeShaderKeywordSetInPlace(keywords);
return keywords;
}
RenderEnvironmentData BuildEnvironmentData(const CameraFramePlan& plan) {
RenderEnvironmentData environment = {};
const RenderSurface& mainSceneSurface = plan.GetMainSceneSurface();
if (plan.request.camera == nullptr ||
mainSceneSurface.GetDepthAttachment() == nullptr ||
!HasRenderClearFlag(plan.request.clearFlags, RenderClearFlags::Color) ||
!plan.request.camera->IsSkyboxEnabled() ||
plan.request.camera->GetProjectionType() != Components::CameraProjectionType::Perspective) {
return environment;
}
if (const Resources::Material* skyboxMaterial = plan.request.camera->GetSkyboxMaterial()) {
environment.mode = RenderEnvironmentMode::MaterialSkybox;
environment.materialSkybox.material = skyboxMaterial;
return environment;
}
environment.mode = RenderEnvironmentMode::ProceduralSkybox;
environment.skybox.topColor = plan.request.camera->GetSkyboxTopColor();
environment.skybox.horizonColor = plan.request.camera->GetSkyboxHorizonColor();
environment.skybox.bottomColor = plan.request.camera->GetSkyboxBottomColor();
return environment;
}
} // namespace
CameraRenderer::CameraRenderer()
@@ -127,10 +92,10 @@ bool CameraRenderer::BuildSceneDataForPlan(
}
outSceneData.lighting.mainDirectionalShadow = shadowState.shadowData;
outSceneData.globalShaderKeywords = BuildSceneGlobalShaderKeywords(outSceneData);
outSceneData.cameraData.clearFlags = plan.request.clearFlags;
outSceneData.environment = BuildEnvironmentData(plan);
if (m_pipeline != nullptr) {
m_pipeline->ConfigureRenderSceneData(plan, outSceneData);
}
if (plan.request.hasClearColorOverride) {
outSceneData.cameraData.clearColor = plan.request.clearColorOverride;
}

58
engine/src/Rendering/RenderPipeline.cpp Normal file
View File

@@ -0,0 +1,58 @@
#include <XCEngine/Rendering/RenderPipeline.h>
#include "Components/CameraComponent.h"
#include "Rendering/Execution/CameraFramePlan.h"
namespace XCEngine {
namespace Rendering {
namespace {
Resources::ShaderKeywordSet BuildDefaultSceneGlobalShaderKeywords(
const RenderSceneData& sceneData) {
Resources::ShaderKeywordSet keywords = {};
if (sceneData.lighting.HasMainDirectionalShadow()) {
keywords.enabledKeywords.PushBack("XC_MAIN_LIGHT_SHADOWS");
}
Resources::NormalizeShaderKeywordSetInPlace(keywords);
return keywords;
}
RenderEnvironmentData BuildDefaultEnvironmentData(const CameraFramePlan& plan) {
RenderEnvironmentData environment = {};
const RenderSurface& mainSceneSurface = plan.GetMainSceneSurface();
if (plan.request.camera == nullptr ||
mainSceneSurface.GetDepthAttachment() == nullptr ||
!HasRenderClearFlag(plan.request.clearFlags, RenderClearFlags::Color) ||
!plan.request.camera->IsSkyboxEnabled() ||
plan.request.camera->GetProjectionType() != Components::CameraProjectionType::Perspective) {
return environment;
}
if (const Resources::Material* skyboxMaterial = plan.request.camera->GetSkyboxMaterial()) {
environment.mode = RenderEnvironmentMode::MaterialSkybox;
environment.materialSkybox.material = skyboxMaterial;
return environment;
}
environment.mode = RenderEnvironmentMode::ProceduralSkybox;
environment.skybox.topColor = plan.request.camera->GetSkyboxTopColor();
environment.skybox.horizonColor = plan.request.camera->GetSkyboxHorizonColor();
environment.skybox.bottomColor = plan.request.camera->GetSkyboxBottomColor();
return environment;
}
} // namespace
void RenderPipeline::ConfigureRenderSceneData(
const CameraFramePlan& plan,
RenderSceneData& sceneData) const {
sceneData.globalShaderKeywords =
BuildDefaultSceneGlobalShaderKeywords(sceneData);
sceneData.environment =
BuildDefaultEnvironmentData(plan);
}
} // namespace Rendering
} // namespace XCEngine

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

@@ -50,6 +50,7 @@ CameraFrameStageSourceBinding ResolveStageSourceBinding(
struct MockPipelineState {
int initializeCalls = 0;
int shutdownCalls = 0;
int configureRenderSceneDataCalls = 0;
int renderCalls = 0;
int recordMainSceneCalls = 0;
int executeRecordedMainSceneCalls = 0;
@@ -84,6 +85,7 @@ struct MockPipelineState {
bool lastBlackboardMainSceneDepthValid = false;
bool lastBlackboardMainDirectionalShadowValid = false;
bool lastBlackboardObjectIdColorValid = false;
std::function<void(const CameraFramePlan&, RenderSceneData&)> configureRenderSceneData = {};
std::vector<CameraComponent*> renderedCameras;
std::vector<RenderClearFlags> renderedClearFlags;
std::vector<XCEngine::Math::Color> renderedClearColors;
@@ -439,6 +441,18 @@ public:
return true;
}
void ConfigureRenderSceneData(
const CameraFramePlan& plan,
RenderSceneData& sceneData) const override {
++m_state->configureRenderSceneDataCalls;
if (m_state->configureRenderSceneData) {
m_state->configureRenderSceneData(plan, sceneData);
return;
}
RenderPipeline::ConfigureRenderSceneData(plan, sceneData);
}
void Shutdown() override {
++m_state->shutdownCalls;
ShutdownCameraFrameStandalonePasses();
@@ -1205,6 +1219,40 @@ TEST(CameraRenderer_Test, PromotesSkyboxMaterialIntoEnvironmentFrameData) {
EXPECT_EQ(state->lastSkyboxMaterial, &skyboxMaterial);
}
TEST(CameraRenderer_Test, UsesPipelineSceneDataConfigurationHook) {
Scene scene("CameraRendererSceneDataHookScene");
GameObject* cameraObject = scene.CreateGameObject("Camera");
auto* camera = cameraObject->AddComponent<CameraComponent>();
camera->SetPrimary(true);
camera->SetSkyboxEnabled(true);
XCEngine::Resources::Material skyboxMaterial;
camera->SetSkyboxMaterial(&skyboxMaterial);
auto state = std::make_shared<MockPipelineState>();
state->configureRenderSceneData = [](
const CameraFramePlan&,
RenderSceneData& sceneData) {
sceneData.environment = {};
sceneData.globalShaderKeywords = {};
};
CameraRenderer renderer(std::make_unique<MockPipeline>(state));
CameraRenderRequest request;
request.scene = &scene;
request.camera = camera;
request.context = CreateValidContext();
request.surface = RenderSurface(320, 200);
request.surface.SetDepthAttachment(reinterpret_cast<XCEngine::RHI::RHIResourceView*>(1));
ASSERT_TRUE(renderer.Render(CameraFramePlan::FromRequest(request)));
EXPECT_EQ(state->configureRenderSceneDataCalls, 1);
EXPECT_FALSE(state->lastHasSkybox);
EXPECT_EQ(state->lastEnvironmentMode, RenderEnvironmentMode::None);
EXPECT_EQ(state->lastSkyboxMaterial, nullptr);
}
TEST(CameraRenderer_Test, ExecutesInjectedPreAndPostPassSequencesAroundPipelineRender) {
Scene scene("CameraRendererPassScene");