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

Refactor rendering frame execution contracts

Browse Source
This commit is contained in:
ssdfasd
2026-04-13 22:16:04 +08:00
parent 48daaa1bd0
commit 712f99e723
30 changed files with 1398 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,6 +13,14 @@ namespace Rendering {
namespace {
bool CompareCameraFramePlans(
const CameraFramePlan& lhs,
const CameraFramePlan& rhs) {
return SceneRenderRequestUtils::CompareCameraRenderRequests(
lhs.request,
rhs.request);
}
RenderSurface ConfigureFullscreenStageSurface(
const FullscreenPassSurfaceCache::SurfaceEntry& entry,
const RenderSurface& templateSurface,
@@ -94,44 +102,72 @@ std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
Components::CameraComponent* overrideCamera,
const RenderContext& context,
const RenderSurface& surface) {
std::vector<CameraRenderRequest> requests =
m_requestPlanner.BuildRequests(scene, overrideCamera, context, surface);
ResolveCameraFinalColorPolicies(requests);
AttachFullscreenStageRequests(context, requests);
const std::vector<CameraFramePlan> plans =
BuildFramePlans(scene, overrideCamera, context, surface);
std::vector<CameraRenderRequest> requests = {};
requests.reserve(plans.size());
for (const CameraFramePlan& plan : plans) {
requests.push_back(BuildLegacyCameraRenderRequest(plan));
}
return requests;
}
std::vector<CameraFramePlan> SceneRenderer::BuildFramePlans(
const Components::Scene& scene,
Components::CameraComponent* overrideCamera,
const RenderContext& context,
const RenderSurface& surface) {
const std::vector<CameraRenderRequest> requests =
m_requestPlanner.BuildRequests(scene, overrideCamera, context, surface);
std::vector<CameraFramePlan> plans = CreateFramePlansFromRequests(requests);
ResolveCameraFinalColorPolicies(plans);
AttachFullscreenStageRequests(context, plans);
return plans;
}
bool SceneRenderer::Render(const CameraRenderRequest& request) {
return m_cameraRenderer.Render(request);
return Render(CameraFramePlan::FromRequest(request));
}
bool SceneRenderer::Render(const std::vector<CameraRenderRequest>& requests) {
if (requests.empty()) {
std::vector<CameraFramePlan> plans = CreateFramePlansFromRequests(requests);
return Render(plans);
}
bool SceneRenderer::Render(const CameraFramePlan& plan) {
return m_cameraRenderer.Render(plan);
}
bool SceneRenderer::Render(const std::vector<CameraFramePlan>& plans) {
if (plans.empty()) {
return false;
}
for (const CameraRenderRequest& request : requests) {
if (!request.IsValid()) {
for (const CameraFramePlan& plan : plans) {
if (!plan.IsValid()) {
return false;
}
}
std::vector<CameraRenderRequest> sortedRequests = requests;
SceneRenderRequestUtils::SortCameraRenderRequests(sortedRequests);
std::vector<CameraFramePlan> sortedPlans = plans;
std::stable_sort(
sortedPlans.begin(),
sortedPlans.end(),
CompareCameraFramePlans);
bool rendered = false;
for (const CameraRenderRequest& request : sortedRequests) {
if (!m_cameraRenderer.Render(request)) {
for (const CameraFramePlan& plan : sortedPlans) {
if (!m_cameraRenderer.Render(plan)) {
return false;
}
UpdateTrackedFullscreenSurfaceState(
m_ownedFullscreenStageSurfaces,
&request.GetMainSceneSurface());
if (request.postProcess.IsRequested()) {
&plan.GetMainSceneSurface());
if (plan.postProcess.IsRequested()) {
UpdateTrackedFullscreenSurfaceState(
m_ownedFullscreenStageSurfaces,
&request.postProcess.destinationSurface);
&plan.postProcess.destinationSurface);
}
rendered = true;
@@ -145,7 +181,18 @@ bool SceneRenderer::Render(
Components::CameraComponent* overrideCamera,
const RenderContext& context,
const RenderSurface& surface) {
return Render(BuildRenderRequests(scene, overrideCamera, context, surface));
return Render(BuildFramePlans(scene, overrideCamera, context, surface));
}
std::vector<CameraFramePlan> SceneRenderer::CreateFramePlansFromRequests(
const std::vector<CameraRenderRequest>& requests) const {
std::vector<CameraFramePlan> plans = {};
plans.reserve(requests.size());
for (const CameraRenderRequest& request : requests) {
plans.push_back(CameraFramePlan::FromRequest(request));
}
return plans;
}
void SceneRenderer::PrepareOwnedFullscreenStageState(size_t requestCount) {
@@ -166,39 +213,39 @@ void SceneRenderer::PrepareOwnedFullscreenStageState(size_t requestCount) {
}
void SceneRenderer::ResolveCameraFinalColorPolicies(
std::vector<CameraRenderRequest>& requests) const {
std::vector<CameraFramePlan>& plans) const {
const RenderPipelineAsset* pipelineAsset = GetPipelineAsset();
const FinalColorSettings pipelineDefaults =
pipelineAsset != nullptr ? pipelineAsset->GetDefaultFinalColorSettings() : FinalColorSettings();
for (CameraRenderRequest& request : requests) {
if (request.camera == nullptr) {
for (CameraFramePlan& plan : plans) {
if (plan.request.camera == nullptr) {
continue;
}
request.finalColorPolicy = ResolveFinalColorPolicy(
plan.finalColorPolicy = ResolveFinalColorPolicy(
pipelineDefaults,
&request.camera->GetFinalColorOverrides());
&plan.request.camera->GetFinalColorOverrides());
}
}
void SceneRenderer::AttachFullscreenStageRequests(
const RenderContext& context,
std::vector<CameraRenderRequest>& requests) {
PrepareOwnedFullscreenStageState(requests.size());
std::vector<CameraFramePlan>& plans) {
PrepareOwnedFullscreenStageState(plans.size());
for (size_t index = 0; index < requests.size(); ++index) {
CameraRenderRequest& request = requests[index];
if (request.camera == nullptr ||
request.context.device == nullptr ||
!HasValidColorTarget(request.surface)) {
for (size_t index = 0; index < plans.size(); ++index) {
CameraFramePlan& plan = plans[index];
if (plan.request.camera == nullptr ||
plan.request.context.device == nullptr ||
!HasValidColorTarget(plan.request.surface)) {
continue;
}
std::unique_ptr<RenderPassSequence> postProcessSequence =
BuildCameraPostProcessPassSequence(request.camera->GetPostProcessPasses());
BuildCameraPostProcessPassSequence(plan.request.camera->GetPostProcessPasses());
std::unique_ptr<RenderPassSequence> finalOutputSequence =
BuildFinalColorPassSequence(request.finalColorPolicy);
BuildFinalColorPassSequence(plan.finalColorPolicy);
const bool hasPostProcess =
postProcessSequence != nullptr && postProcessSequence->GetPassCount() > 0u;
@@ -208,14 +255,14 @@ void SceneRenderer::AttachFullscreenStageRequests(
continue;
}
if (request.surface.GetSampleCount() > 1u) {
if (plan.request.surface.GetSampleCount() > 1u) {
Debug::Logger::Get().Error(
Debug::LogCategory::Rendering,
"SceneRenderer fullscreen post-process/final-output chain currently requires a single-sample main scene surface");
continue;
}
const std::vector<RHI::RHIResourceView*>& colorAttachments = request.surface.GetColorAttachments();
const std::vector<RHI::RHIResourceView*>& colorAttachments = plan.request.surface.GetColorAttachments();
const RHI::Format colorFormat = colorAttachments[0]->GetFormat();
if (colorFormat == RHI::Format::Unknown) {
continue;
@@ -226,8 +273,8 @@ void SceneRenderer::AttachFullscreenStageRequests(
if (surfaceCache == nullptr ||
!surfaceCache->EnsureSurfaces(
context,
request.surface.GetWidth(),
request.surface.GetHeight(),
plan.request.surface.GetWidth(),
plan.request.surface.GetHeight(),
colorFormat,
fullscreenSurfaceCount)) {
continue;
@@ -246,30 +293,30 @@ void SceneRenderer::AttachFullscreenStageRequests(
}
if (hasPostProcess) {
request.postProcess.sourceSurface =
ConfigureFullscreenStageSurface(*sceneColorEntry, request.surface, true);
request.postProcess.sourceColorView = sceneColorEntry->shaderResourceView;
request.postProcess.sourceColorState = request.postProcess.sourceSurface.GetColorStateAfter();
request.postProcess.destinationSurface =
plan.postProcess.sourceSurface =
ConfigureFullscreenStageSurface(*sceneColorEntry, plan.request.surface, true);
plan.postProcess.sourceColorView = sceneColorEntry->shaderResourceView;
plan.postProcess.sourceColorState = plan.postProcess.sourceSurface.GetColorStateAfter();
plan.postProcess.destinationSurface =
hasFinalOutput
? ConfigureFullscreenStageSurface(*postProcessOutputEntry, request.surface, false)
: request.surface;
? ConfigureFullscreenStageSurface(*postProcessOutputEntry, plan.request.surface, false)
: plan.request.surface;
m_ownedPostProcessSequences[index] = std::move(postProcessSequence);
request.postProcess.passes = m_ownedPostProcessSequences[index].get();
plan.postProcess.passes = m_ownedPostProcessSequences[index].get();
}
if (hasFinalOutput) {
const FullscreenPassSurfaceCache::SurfaceEntry* finalOutputSourceEntry =
hasPostProcess ? postProcessOutputEntry : sceneColorEntry;
request.finalOutput.sourceSurface =
plan.finalOutput.sourceSurface =
hasPostProcess
? request.postProcess.destinationSurface
: ConfigureFullscreenStageSurface(*sceneColorEntry, request.surface, true);
request.finalOutput.sourceColorView = finalOutputSourceEntry->shaderResourceView;
request.finalOutput.sourceColorState = request.finalOutput.sourceSurface.GetColorStateAfter();
request.finalOutput.destinationSurface = request.surface;
? plan.postProcess.destinationSurface
: ConfigureFullscreenStageSurface(*sceneColorEntry, plan.request.surface, true);
plan.finalOutput.sourceColorView = finalOutputSourceEntry->shaderResourceView;
plan.finalOutput.sourceColorState = plan.finalOutput.sourceSurface.GetColorStateAfter();
plan.finalOutput.destinationSurface = plan.request.surface;
m_ownedFinalOutputSequences[index] = std::move(finalOutputSequence);
request.finalOutput.passes = m_ownedFinalOutputSequences[index].get();
plan.finalOutput.passes = m_ownedFinalOutputSequences[index].get();
}
}
}