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

Remove scene viewport postprocess API from engine

Browse Source
This commit is contained in:
ssdfasd
2026-04-03 15:26:17 +08:00
parent 7cc4aa3b45
commit e8f64407ba
13 changed files with 20 additions and 831 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
engine/CMakeLists.txt
View File

@@ -361,14 +361,11 @@ add_library(XCEngine STATIC
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/SceneRenderer.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Passes/BuiltinObjectIdPass.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Passes/BuiltinInfiniteGridPass.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Passes/BuiltinPostProcessPassPlan.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Passes/BuiltinPostProcessPassSequenceBuilder.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Passes/BuiltinObjectIdOutlinePass.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/CameraRenderer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Passes/BuiltinObjectIdPass.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Passes/BuiltinInfiniteGridPass.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Passes/BuiltinPostProcessPassSequenceBuilder.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Passes/BuiltinObjectIdOutlinePass.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/RenderSurface.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/RenderSceneExtractor.cpp

14
engine/include/XCEngine/Rendering/CameraRenderRequest.h
View File

@@ -1,7 +1,5 @@
#pragma once
#include <XCEngine/Rendering/Passes/BuiltinInfiniteGridPass.h>
#include <XCEngine/Rendering/Passes/BuiltinObjectIdOutlinePass.h>
#include <XCEngine/Rendering/RenderPass.h>
#include <XCEngine/Rendering/RenderCameraData.h>
#include <XCEngine/Rendering/RenderContext.h>
@@ -32,24 +30,12 @@ struct ObjectIdRenderRequest {
}
};
struct BuiltinPostProcessRequest {
Passes::InfiniteGridPassData gridPassData = {};
RHI::RHIResourceView* objectIdTextureView = nullptr;
std::vector<uint64_t> selectedObjectIds = {};
Passes::ObjectIdOutlineStyle outlineStyle = {};
bool IsRequested() const {
return gridPassData.valid || !selectedObjectIds.empty();
}
};
struct CameraRenderRequest {
const Components::Scene* scene = nullptr;
Components::CameraComponent* camera = nullptr;
RenderContext context;
RenderSurface surface;
ObjectIdRenderRequest objectId;
BuiltinPostProcessRequest builtinPostProcess;
float cameraDepth = 0.0f;
uint8_t cameraStackOrder = 0;
RenderClearFlags clearFlags = RenderClearFlags::All;

2
engine/include/XCEngine/Rendering/CameraRenderer.h
View File

@@ -2,7 +2,6 @@
#include <XCEngine/Rendering/CameraRenderRequest.h>
#include <XCEngine/Rendering/ObjectIdPass.h>
#include <XCEngine/Rendering/Passes/BuiltinPostProcessPassSequenceBuilder.h>
#include <XCEngine/Rendering/RenderPipeline.h>
#include <memory>
@@ -44,7 +43,6 @@ private:
std::shared_ptr<const RenderPipelineAsset> m_pipelineAsset;
std::unique_ptr<RenderPipeline> m_pipeline;
std::unique_ptr<ObjectIdPass> m_objectIdPass;
Passes::BuiltinPostProcessPassSequenceBuilder m_builtinPostProcessBuilder;
};
} // namespace Rendering

91
engine/include/XCEngine/Rendering/Passes/BuiltinPostProcessPassPlan.h
View File

@@ -1,91 +0,0 @@
#pragma once
#include <cstdint>
#include <vector>
namespace XCEngine {
namespace Rendering {
namespace Passes {
enum class BuiltinPostProcessPassStep : uint8_t {
ColorToRenderTarget,
InfiniteGrid,
SelectionOutline,
ColorToShaderResource,
SelectionMaskDebug
};
struct BuiltinPostProcessPassPlanInput {
bool hasGridOverlay = false;
bool hasSelection = false;
bool debugSelectionMask = false;
bool hasObjectIdShaderView = false;
};
struct BuiltinPostProcessPassPlan {
bool valid = false;
std::vector<BuiltinPostProcessPassStep> steps;
};
inline BuiltinPostProcessPassPlan BuildBuiltinPostProcessPassPlan(
const BuiltinPostProcessPassPlanInput& input) {
BuiltinPostProcessPassPlan plan = {};
plan.valid = true;
if (input.debugSelectionMask) {
if (input.hasSelection && input.hasObjectIdShaderView) {
plan.steps = {
BuiltinPostProcessPassStep::ColorToRenderTarget,
BuiltinPostProcessPassStep::SelectionMaskDebug,
BuiltinPostProcessPassStep::ColorToShaderResource
};
return plan;
}
if (input.hasGridOverlay) {
plan.steps = {
BuiltinPostProcessPassStep::ColorToRenderTarget,
BuiltinPostProcessPassStep::ColorToShaderResource
};
return plan;
}
plan.valid = false;
return plan;
}
if (input.hasGridOverlay && input.hasSelection && input.hasObjectIdShaderView) {
plan.steps = {
BuiltinPostProcessPassStep::ColorToRenderTarget,
BuiltinPostProcessPassStep::InfiniteGrid,
BuiltinPostProcessPassStep::SelectionOutline,
BuiltinPostProcessPassStep::ColorToShaderResource
};
return plan;
}
if (input.hasGridOverlay) {
plan.steps = {
BuiltinPostProcessPassStep::ColorToRenderTarget,
BuiltinPostProcessPassStep::InfiniteGrid,
BuiltinPostProcessPassStep::ColorToShaderResource
};
return plan;
}
if (input.hasSelection && input.hasObjectIdShaderView) {
plan.steps = {
BuiltinPostProcessPassStep::ColorToRenderTarget,
BuiltinPostProcessPassStep::SelectionOutline,
BuiltinPostProcessPassStep::ColorToShaderResource
};
return plan;
}
plan.valid = false;
return plan;
}
} // namespace Passes
} // namespace Rendering
} // namespace XCEngine

59
engine/include/XCEngine/Rendering/Passes/BuiltinPostProcessPassSequenceBuilder.h
View File

@@ -1,59 +0,0 @@
#pragma once
#include <XCEngine/Rendering/Passes/BuiltinInfiniteGridPass.h>
#include <XCEngine/Rendering/Passes/BuiltinObjectIdOutlinePass.h>
#include <XCEngine/Rendering/RenderPass.h>
#include <cstdint>
#include <vector>
namespace XCEngine {
namespace Rendering {
namespace Passes {
struct BuiltinPostProcessPassSequenceInput {
InfiniteGridPassData gridPassData = {};
RHI::RHIResourceView* objectIdTextureView = nullptr;
std::vector<uint64_t> selectedObjectIds = {};
ObjectIdOutlineStyle outlineStyle = {};
};
struct BuiltinPostProcessPassSequenceBuildResult {
bool valid = false;
bool missingObjectIdTextureViewForSelection = false;
};
class BuiltinPostProcessPassSequenceBuilder {
public:
~BuiltinPostProcessPassSequenceBuilder();
void Shutdown();
BuiltinPostProcessPassSequenceBuildResult Build(
const BuiltinPostProcessPassSequenceInput& input,
RenderPassSequence& outSequence);
private:
void AddColorToRenderTargetPass(RenderPassSequence& outSequence);
void AddInfiniteGridPass(
const InfiniteGridPassData& gridPassData,
RenderPassSequence& outSequence);
void AddSelectionOutlinePass(
RHI::RHIResourceView* objectIdTextureView,
const std::vector<uint64_t>& selectedObjectIds,
const ObjectIdOutlineStyle& outlineStyle,
RenderPassSequence& outSequence);
void AddColorToShaderResourcePass(RenderPassSequence& outSequence);
void AddSelectionMaskDebugPass(
RHI::RHIResourceView* objectIdTextureView,
const std::vector<uint64_t>& selectedObjectIds,
const ObjectIdOutlineStyle& outlineStyle,
RenderPassSequence& outSequence);
BuiltinInfiniteGridPass m_gridPass;
BuiltinObjectIdOutlinePass m_outlinePass;
};
} // namespace Passes
} // namespace Rendering
} // namespace XCEngine

38
engine/src/Rendering/CameraRenderer.cpp
View File

@@ -86,7 +86,6 @@ CameraRenderer::~CameraRenderer() {
if (m_objectIdPass != nullptr) {
m_objectIdPass->Shutdown();
}
m_builtinPostProcessBuilder.Shutdown();
}
void CameraRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
@@ -136,12 +135,6 @@ bool CameraRenderer::Render(
!request.objectId.IsValid()) {
return false;
}
if (request.builtinPostProcess.IsRequested() &&
request.builtinPostProcess.objectIdTextureView != nullptr &&
!request.objectId.IsRequested()) {
return false;
}
RenderSceneData sceneData = m_sceneExtractor.ExtractForCamera(
*request.scene,
*request.camera,
@@ -201,37 +194,6 @@ bool CameraRenderer::Render(
return false;
}
RenderPassSequence builtinPostProcessPasses = {};
bool builtinPostProcessPassesInitialized = false;
if (request.builtinPostProcess.IsRequested()) {
const Passes::BuiltinPostProcessPassSequenceBuildResult buildResult =
m_builtinPostProcessBuilder.Build(
{
request.builtinPostProcess.gridPassData,
request.builtinPostProcess.objectIdTextureView,
request.builtinPostProcess.selectedObjectIds,
request.builtinPostProcess.outlineStyle
},
builtinPostProcessPasses);
if (!buildResult.valid ||
!InitializePassSequence(
&builtinPostProcessPasses,
request.context,
builtinPostProcessPassesInitialized)) {
ShutdownPassSequence(request.postScenePasses, postScenePassesInitialized);
ShutdownPassSequence(request.preScenePasses, preScenePassesInitialized);
return false;
}
if (!builtinPostProcessPasses.Execute(passContext)) {
ShutdownPassSequence(&builtinPostProcessPasses, builtinPostProcessPassesInitialized);
ShutdownPassSequence(request.postScenePasses, postScenePassesInitialized);
ShutdownPassSequence(request.preScenePasses, preScenePassesInitialized);
return false;
}
}
ShutdownPassSequence(&builtinPostProcessPasses, builtinPostProcessPassesInitialized);
bool overlayPassesInitialized = false;
if (!InitializePassSequence(
request.overlayPasses,

214
engine/src/Rendering/Passes/BuiltinPostProcessPassSequenceBuilder.cpp
View File

@@ -1,214 +0,0 @@
#include "Rendering/Passes/BuiltinPostProcessPassSequenceBuilder.h"
#include "Rendering/Passes/BuiltinPostProcessPassPlan.h"
#include <XCEngine/Core/Math/Color.h>
#include <XCEngine/RHI/RHICommandList.h>
#include <functional>
#include <memory>
#include <string>
#include <utility>
namespace XCEngine {
namespace Rendering {
namespace Passes {
namespace {
class LambdaRenderPass final : public RenderPass {
public:
using ExecuteCallback = std::function<bool(const RenderPassContext&)>;
LambdaRenderPass(std::string name, ExecuteCallback executeCallback)
: m_name(std::move(name))
, m_executeCallback(std::move(executeCallback)) {
}
const char* GetName() const override {
return m_name.c_str();
}
bool Execute(const RenderPassContext& context) override {
return m_executeCallback != nullptr && m_executeCallback(context);
}
private:
std::string m_name;
ExecuteCallback m_executeCallback;
};
template <typename Callback>
std::unique_ptr<RenderPass> MakeLambdaRenderPass(const char* name, Callback&& callback) {
return std::make_unique<LambdaRenderPass>(
name,
LambdaRenderPass::ExecuteCallback(std::forward<Callback>(callback)));
}
} // namespace
BuiltinPostProcessPassSequenceBuilder::~BuiltinPostProcessPassSequenceBuilder() {
Shutdown();
}
void BuiltinPostProcessPassSequenceBuilder::Shutdown() {
m_outlinePass.Shutdown();
m_gridPass.Shutdown();
}
BuiltinPostProcessPassSequenceBuildResult BuiltinPostProcessPassSequenceBuilder::Build(
const BuiltinPostProcessPassSequenceInput& input,
RenderPassSequence& outSequence) {
BuiltinPostProcessPassSequenceBuildResult result = {};
const bool hasSelection = !input.selectedObjectIds.empty();
const bool hasObjectIdTextureView = input.objectIdTextureView != nullptr;
if (hasSelection && !hasObjectIdTextureView) {
result.missingObjectIdTextureViewForSelection = true;
}
const BuiltinPostProcessPassPlan plan = BuildBuiltinPostProcessPassPlan({
input.gridPassData.valid,
hasSelection,
input.outlineStyle.debugSelectionMask,
hasObjectIdTextureView
});
if (!plan.valid) {
return result;
}
result.valid = true;
for (const BuiltinPostProcessPassStep step : plan.steps) {
switch (step) {
case BuiltinPostProcessPassStep::ColorToRenderTarget:
AddColorToRenderTargetPass(outSequence);
break;
case BuiltinPostProcessPassStep::InfiniteGrid:
AddInfiniteGridPass(input.gridPassData, outSequence);
break;
case BuiltinPostProcessPassStep::SelectionOutline:
AddSelectionOutlinePass(
input.objectIdTextureView,
input.selectedObjectIds,
input.outlineStyle,
outSequence);
break;
case BuiltinPostProcessPassStep::ColorToShaderResource:
AddColorToShaderResourcePass(outSequence);
break;
case BuiltinPostProcessPassStep::SelectionMaskDebug:
AddSelectionMaskDebugPass(
input.objectIdTextureView,
input.selectedObjectIds,
input.outlineStyle,
outSequence);
break;
default:
break;
}
}
return result;
}
void BuiltinPostProcessPassSequenceBuilder::AddColorToRenderTargetPass(
RenderPassSequence& outSequence) {
outSequence.AddPass(MakeLambdaRenderPass(
"SceneColorToRenderTarget",
[](const RenderPassContext& context) {
const std::vector<RHI::RHIResourceView*>& colorAttachments = context.surface.GetColorAttachments();
if (colorAttachments.empty() || colorAttachments[0] == nullptr || context.renderContext.commandList == nullptr) {
return false;
}
context.renderContext.commandList->TransitionBarrier(
colorAttachments[0],
context.surface.GetColorStateAfter(),
RHI::ResourceStates::RenderTarget);
return true;
}));
}
void BuiltinPostProcessPassSequenceBuilder::AddInfiniteGridPass(
const InfiniteGridPassData& gridPassData,
RenderPassSequence& outSequence) {
outSequence.AddPass(MakeLambdaRenderPass(
"SceneInfiniteGrid",
[this, gridPassData](const RenderPassContext& context) {
return m_gridPass.Render(
context.renderContext,
context.surface,
gridPassData);
}));
}
void BuiltinPostProcessPassSequenceBuilder::AddSelectionOutlinePass(
RHI::RHIResourceView* objectIdTextureView,
const std::vector<uint64_t>& selectedObjectIds,
const ObjectIdOutlineStyle& outlineStyle,
RenderPassSequence& outSequence) {
outSequence.AddPass(MakeLambdaRenderPass(
"SceneSelectionOutline",
[this, objectIdTextureView, selectedObjectIds, outlineStyle](const RenderPassContext& context) {
return m_outlinePass.Render(
context.renderContext,
context.surface,
objectIdTextureView,
selectedObjectIds,
outlineStyle);
}));
}
void BuiltinPostProcessPassSequenceBuilder::AddColorToShaderResourcePass(
RenderPassSequence& outSequence) {
outSequence.AddPass(MakeLambdaRenderPass(
"SceneColorToShaderResource",
[](const RenderPassContext& context) {
const std::vector<RHI::RHIResourceView*>& colorAttachments = context.surface.GetColorAttachments();
if (colorAttachments.empty() || colorAttachments[0] == nullptr || context.renderContext.commandList == nullptr) {
return false;
}
context.renderContext.commandList->TransitionBarrier(
colorAttachments[0],
RHI::ResourceStates::RenderTarget,
context.surface.GetColorStateAfter());
return true;
}));
}
void BuiltinPostProcessPassSequenceBuilder::AddSelectionMaskDebugPass(
RHI::RHIResourceView* objectIdTextureView,
const std::vector<uint64_t>& selectedObjectIds,
const ObjectIdOutlineStyle& outlineStyle,
RenderPassSequence& outSequence) {
outSequence.AddPass(MakeLambdaRenderPass(
"SceneSelectionMaskDebug",
[this, objectIdTextureView, selectedObjectIds, outlineStyle](const RenderPassContext& context) {
const std::vector<RHI::RHIResourceView*>& colorAttachments = context.surface.GetColorAttachments();
if (colorAttachments.empty() || colorAttachments[0] == nullptr || context.renderContext.commandList == nullptr) {
return false;
}
const float debugClearColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
RHI::RHIResourceView* colorView = colorAttachments[0];
context.renderContext.commandList->SetRenderTargets(
1,
&colorView,
context.surface.GetDepthAttachment());
context.renderContext.commandList->ClearRenderTarget(colorView, debugClearColor);
ObjectIdOutlineStyle debugStyle = outlineStyle;
debugStyle.debugSelectionMask = true;
return m_outlinePass.Render(
context.renderContext,
context.surface,
objectIdTextureView,
selectedObjectIds,
debugStyle);
}));
}
} // namespace Passes
} // namespace Rendering
} // namespace XCEngine