Group rendering execution and planning files
This commit is contained in:
437
engine/src/Rendering/Execution/CameraRenderer.cpp
Normal file
437
engine/src/Rendering/Execution/CameraRenderer.cpp
Normal file
@@ -0,0 +1,437 @@
|
||||
#include "Rendering/Execution/CameraRenderer.h"
|
||||
|
||||
#include "Rendering/DirectionalShadowSurfaceCache.h"
|
||||
#include "Rendering/Passes/BuiltinDepthOnlyPass.h"
|
||||
#include "Rendering/Passes/BuiltinObjectIdPass.h"
|
||||
#include "Rendering/Passes/BuiltinShadowCasterPass.h"
|
||||
#include "Rendering/Pipelines/BuiltinForwardPipeline.h"
|
||||
#include "Rendering/RenderPipelineAsset.h"
|
||||
#include "Rendering/RenderSurface.h"
|
||||
#include "RHI/RHIResourceView.h"
|
||||
#include "Scene/Scene.h"
|
||||
|
||||
namespace XCEngine {
|
||||
namespace Rendering {
|
||||
|
||||
namespace {
|
||||
|
||||
std::shared_ptr<const RenderPipelineAsset> CreateDefaultPipelineAsset() {
|
||||
static const std::shared_ptr<const RenderPipelineAsset> s_defaultPipelineAsset =
|
||||
std::make_shared<Pipelines::BuiltinForwardPipelineAsset>();
|
||||
return s_defaultPipelineAsset;
|
||||
}
|
||||
|
||||
std::unique_ptr<RenderPass> CreateDefaultDepthOnlyPass() {
|
||||
return std::make_unique<Passes::BuiltinDepthOnlyPass>();
|
||||
}
|
||||
|
||||
std::unique_ptr<RenderPass> CreateDefaultShadowCasterPass() {
|
||||
return std::make_unique<Passes::BuiltinShadowCasterPass>();
|
||||
}
|
||||
|
||||
std::unique_ptr<RenderPipeline> CreatePipelineFromAsset(
|
||||
const std::shared_ptr<const RenderPipelineAsset>& pipelineAsset) {
|
||||
if (pipelineAsset != nullptr) {
|
||||
std::unique_ptr<RenderPipeline> pipeline = pipelineAsset->CreatePipeline();
|
||||
if (pipeline != nullptr) {
|
||||
return pipeline;
|
||||
}
|
||||
}
|
||||
|
||||
return std::make_unique<Pipelines::BuiltinForwardPipeline>();
|
||||
}
|
||||
|
||||
bool InitializeStandalonePass(
|
||||
RenderPass* pass,
|
||||
const RenderContext& context) {
|
||||
if (pass == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (pass->Initialize(context)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
pass->Shutdown();
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ExecuteScenePassRequest(
|
||||
RenderPass* pass,
|
||||
const ScenePassRenderRequest& request,
|
||||
const RenderContext& context,
|
||||
const RenderSceneData& baseSceneData) {
|
||||
if (!request.IsRequested()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!InitializeStandalonePass(pass, context)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
RenderSceneData sceneData = baseSceneData;
|
||||
if (request.hasCameraDataOverride) {
|
||||
sceneData.cameraData = request.cameraDataOverride;
|
||||
}
|
||||
|
||||
sceneData.cameraData.viewportWidth = request.surface.GetRenderAreaWidth();
|
||||
sceneData.cameraData.viewportHeight = request.surface.GetRenderAreaHeight();
|
||||
sceneData.cameraData.clearFlags = request.clearFlags;
|
||||
if (request.hasClearColorOverride) {
|
||||
sceneData.cameraData.clearColor = request.clearColorOverride;
|
||||
}
|
||||
|
||||
const RenderPassContext passContext = {
|
||||
context,
|
||||
request.surface,
|
||||
sceneData
|
||||
};
|
||||
return pass->Execute(passContext);
|
||||
}
|
||||
|
||||
bool ExecuteStandalonePass(
|
||||
RenderPass* pass,
|
||||
const RenderContext& context,
|
||||
const RenderSurface& surface,
|
||||
const RenderSceneData& sceneData) {
|
||||
if (pass == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!InitializeStandalonePass(pass, context)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const RenderPassContext passContext = {
|
||||
context,
|
||||
surface,
|
||||
sceneData
|
||||
};
|
||||
return pass->Execute(passContext);
|
||||
}
|
||||
|
||||
class ScopedInitializedPassSequence {
|
||||
public:
|
||||
ScopedInitializedPassSequence(
|
||||
RenderPassSequence* sequence,
|
||||
const RenderContext& context)
|
||||
: m_sequence(sequence) {
|
||||
if (m_sequence == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
m_initialized = m_sequence->Initialize(context);
|
||||
if (!m_initialized) {
|
||||
m_failed = true;
|
||||
m_sequence->Shutdown();
|
||||
m_sequence = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
ScopedInitializedPassSequence(const ScopedInitializedPassSequence&) = delete;
|
||||
ScopedInitializedPassSequence& operator=(const ScopedInitializedPassSequence&) = delete;
|
||||
|
||||
~ScopedInitializedPassSequence() {
|
||||
if (m_sequence != nullptr && m_initialized) {
|
||||
m_sequence->Shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
bool IsReady() const {
|
||||
return !m_failed;
|
||||
}
|
||||
|
||||
bool Execute(const RenderPassContext& context) const {
|
||||
return m_sequence == nullptr || m_sequence->Execute(context);
|
||||
}
|
||||
|
||||
private:
|
||||
RenderPassSequence* m_sequence = nullptr;
|
||||
bool m_initialized = false;
|
||||
bool m_failed = false;
|
||||
};
|
||||
|
||||
RenderDirectionalShadowData BuildDirectionalShadowData(
|
||||
const DirectionalShadowRenderPlan& plan,
|
||||
RHI::RHIResourceView* shadowMapView) {
|
||||
RenderDirectionalShadowData shadowData = {};
|
||||
if (!plan.IsValid() || shadowMapView == nullptr) {
|
||||
return shadowData;
|
||||
}
|
||||
|
||||
shadowData.enabled = true;
|
||||
shadowData.viewProjection = plan.cameraData.viewProjection;
|
||||
shadowData.shadowMap = shadowMapView;
|
||||
shadowData.shadowParams = Math::Vector4(
|
||||
0.0015f,
|
||||
1.0f / static_cast<float>(plan.mapWidth),
|
||||
1.0f / static_cast<float>(plan.mapHeight),
|
||||
0.85f);
|
||||
return shadowData;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
CameraRenderer::CameraRenderer()
|
||||
: CameraRenderer(CreateDefaultPipelineAsset()) {
|
||||
}
|
||||
|
||||
CameraRenderer::CameraRenderer(std::unique_ptr<RenderPipeline> pipeline)
|
||||
: CameraRenderer(
|
||||
std::move(pipeline),
|
||||
std::make_unique<Passes::BuiltinObjectIdPass>(),
|
||||
CreateDefaultDepthOnlyPass(),
|
||||
CreateDefaultShadowCasterPass()) {
|
||||
}
|
||||
|
||||
CameraRenderer::CameraRenderer(
|
||||
std::unique_ptr<RenderPipeline> pipeline,
|
||||
std::unique_ptr<RenderPass> objectIdPass,
|
||||
std::unique_ptr<RenderPass> depthOnlyPass,
|
||||
std::unique_ptr<RenderPass> shadowCasterPass)
|
||||
: m_pipelineAsset(nullptr)
|
||||
, m_objectIdPass(std::move(objectIdPass))
|
||||
, m_depthOnlyPass(std::move(depthOnlyPass))
|
||||
, m_shadowCasterPass(std::move(shadowCasterPass)) {
|
||||
if (m_objectIdPass == nullptr) {
|
||||
m_objectIdPass = std::make_unique<Passes::BuiltinObjectIdPass>();
|
||||
}
|
||||
if (m_depthOnlyPass == nullptr) {
|
||||
m_depthOnlyPass = CreateDefaultDepthOnlyPass();
|
||||
}
|
||||
if (m_shadowCasterPass == nullptr) {
|
||||
m_shadowCasterPass = CreateDefaultShadowCasterPass();
|
||||
}
|
||||
ResetPipeline(std::move(pipeline));
|
||||
}
|
||||
|
||||
CameraRenderer::CameraRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
|
||||
: m_pipelineAsset(std::move(pipelineAsset))
|
||||
, m_objectIdPass(std::make_unique<Passes::BuiltinObjectIdPass>())
|
||||
, m_depthOnlyPass(CreateDefaultDepthOnlyPass())
|
||||
, m_shadowCasterPass(CreateDefaultShadowCasterPass()) {
|
||||
SetPipelineAsset(m_pipelineAsset);
|
||||
}
|
||||
|
||||
CameraRenderer::~CameraRenderer() {
|
||||
if (m_pipeline) {
|
||||
m_pipeline->Shutdown();
|
||||
}
|
||||
if (m_objectIdPass != nullptr) {
|
||||
m_objectIdPass->Shutdown();
|
||||
}
|
||||
if (m_depthOnlyPass != nullptr) {
|
||||
m_depthOnlyPass->Shutdown();
|
||||
}
|
||||
if (m_shadowCasterPass != nullptr) {
|
||||
m_shadowCasterPass->Shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
void CameraRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
|
||||
m_pipelineAsset.reset();
|
||||
ResetPipeline(std::move(pipeline));
|
||||
}
|
||||
|
||||
void CameraRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset) {
|
||||
m_pipelineAsset = pipelineAsset != nullptr ? std::move(pipelineAsset) : CreateDefaultPipelineAsset();
|
||||
ResetPipeline(CreatePipelineFromAsset(m_pipelineAsset));
|
||||
}
|
||||
|
||||
void CameraRenderer::SetObjectIdPass(std::unique_ptr<RenderPass> objectIdPass) {
|
||||
if (m_objectIdPass != nullptr) {
|
||||
m_objectIdPass->Shutdown();
|
||||
}
|
||||
|
||||
m_objectIdPass = std::move(objectIdPass);
|
||||
if (m_objectIdPass == nullptr) {
|
||||
m_objectIdPass = std::make_unique<Passes::BuiltinObjectIdPass>();
|
||||
}
|
||||
}
|
||||
|
||||
void CameraRenderer::SetDepthOnlyPass(std::unique_ptr<RenderPass> depthOnlyPass) {
|
||||
if (m_depthOnlyPass != nullptr) {
|
||||
m_depthOnlyPass->Shutdown();
|
||||
}
|
||||
|
||||
m_depthOnlyPass = std::move(depthOnlyPass);
|
||||
if (m_depthOnlyPass == nullptr) {
|
||||
m_depthOnlyPass = CreateDefaultDepthOnlyPass();
|
||||
}
|
||||
}
|
||||
|
||||
void CameraRenderer::SetShadowCasterPass(std::unique_ptr<RenderPass> shadowCasterPass) {
|
||||
if (m_shadowCasterPass != nullptr) {
|
||||
m_shadowCasterPass->Shutdown();
|
||||
}
|
||||
|
||||
m_shadowCasterPass = std::move(shadowCasterPass);
|
||||
if (m_shadowCasterPass == nullptr) {
|
||||
m_shadowCasterPass = CreateDefaultShadowCasterPass();
|
||||
}
|
||||
}
|
||||
|
||||
void CameraRenderer::ResetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
|
||||
if (m_pipeline != nullptr) {
|
||||
m_pipeline->Shutdown();
|
||||
}
|
||||
|
||||
m_pipeline = std::move(pipeline);
|
||||
if (m_pipeline == nullptr) {
|
||||
m_pipelineAsset = CreateDefaultPipelineAsset();
|
||||
m_pipeline = CreatePipelineFromAsset(m_pipelineAsset);
|
||||
}
|
||||
}
|
||||
|
||||
bool CameraRenderer::ResolveShadowCasterRequest(
|
||||
const CameraRenderRequest& request,
|
||||
ShadowCasterRenderRequest& outResolvedShadowCaster,
|
||||
RHI::RHIResourceView*& outShadowMapView) {
|
||||
outResolvedShadowCaster = request.shadowCaster;
|
||||
outShadowMapView = nullptr;
|
||||
|
||||
if (outResolvedShadowCaster.IsRequested()) {
|
||||
return outResolvedShadowCaster.IsValid();
|
||||
}
|
||||
|
||||
if (!request.directionalShadow.IsValid()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (m_directionalShadowSurface == nullptr) {
|
||||
m_directionalShadowSurface = std::make_unique<DirectionalShadowSurfaceCache>();
|
||||
}
|
||||
|
||||
if (!m_directionalShadowSurface->EnsureSurface(request.context, request.directionalShadow)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
outResolvedShadowCaster.surface = m_directionalShadowSurface->GetSurface();
|
||||
outResolvedShadowCaster.clearFlags = RenderClearFlags::Depth;
|
||||
if (!outResolvedShadowCaster.hasCameraDataOverride) {
|
||||
outResolvedShadowCaster.hasCameraDataOverride = true;
|
||||
outResolvedShadowCaster.cameraDataOverride = request.directionalShadow.cameraData;
|
||||
}
|
||||
|
||||
outShadowMapView = m_directionalShadowSurface->GetDepthShaderView();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CameraRenderer::BuildSceneDataForRequest(
|
||||
const CameraRenderRequest& request,
|
||||
RHI::RHIResourceView* shadowMapView,
|
||||
RenderSceneData& outSceneData) {
|
||||
outSceneData = m_sceneExtractor.ExtractForCamera(
|
||||
*request.scene,
|
||||
*request.camera,
|
||||
request.surface.GetRenderAreaWidth(),
|
||||
request.surface.GetRenderAreaHeight());
|
||||
if (!outSceneData.HasCamera()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (request.directionalShadow.IsValid()) {
|
||||
outSceneData.lighting.mainDirectionalShadow =
|
||||
BuildDirectionalShadowData(request.directionalShadow, shadowMapView);
|
||||
}
|
||||
|
||||
outSceneData.cameraData.clearFlags = request.clearFlags;
|
||||
if (request.hasClearColorOverride) {
|
||||
outSceneData.cameraData.clearColor = request.clearColorOverride;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CameraRenderer::ExecuteRenderPlan(
|
||||
const CameraRenderRequest& request,
|
||||
const ShadowCasterRenderRequest& resolvedShadowCaster,
|
||||
const RenderSceneData& sceneData) {
|
||||
const RenderPassContext passContext = {
|
||||
request.context,
|
||||
request.surface,
|
||||
sceneData
|
||||
};
|
||||
|
||||
ScopedInitializedPassSequence preScenePasses(request.preScenePasses, request.context);
|
||||
if (!preScenePasses.IsReady() || !preScenePasses.Execute(passContext)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!ExecuteScenePassRequest(
|
||||
m_shadowCasterPass.get(),
|
||||
resolvedShadowCaster,
|
||||
request.context,
|
||||
sceneData)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!ExecuteScenePassRequest(
|
||||
m_depthOnlyPass.get(),
|
||||
request.depthOnly,
|
||||
request.context,
|
||||
sceneData)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!m_pipeline->Render(request.context, request.surface, sceneData)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (request.objectId.IsRequested() &&
|
||||
!ExecuteStandalonePass(
|
||||
m_objectIdPass.get(),
|
||||
request.context,
|
||||
request.objectId.surface,
|
||||
sceneData)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
ScopedInitializedPassSequence postScenePasses(request.postScenePasses, request.context);
|
||||
if (!postScenePasses.IsReady() || !postScenePasses.Execute(passContext)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
ScopedInitializedPassSequence overlayPasses(request.overlayPasses, request.context);
|
||||
if (!overlayPasses.IsReady() || !overlayPasses.Execute(passContext)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CameraRenderer::Render(
|
||||
const CameraRenderRequest& request) {
|
||||
if (!request.IsValid() || m_pipeline == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (request.surface.GetRenderAreaWidth() == 0 ||
|
||||
request.surface.GetRenderAreaHeight() == 0) {
|
||||
return false;
|
||||
}
|
||||
if (request.depthOnly.IsRequested() &&
|
||||
!request.depthOnly.IsValid()) {
|
||||
return false;
|
||||
}
|
||||
if (request.objectId.IsRequested() &&
|
||||
!request.objectId.IsValid()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
ShadowCasterRenderRequest resolvedShadowCaster = {};
|
||||
RHI::RHIResourceView* shadowMapView = nullptr;
|
||||
if (!ResolveShadowCasterRequest(request, resolvedShadowCaster, shadowMapView)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
RenderSceneData sceneData = {};
|
||||
if (!BuildSceneDataForRequest(request, shadowMapView, sceneData)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return ExecuteRenderPlan(request, resolvedShadowCaster, sceneData);
|
||||
}
|
||||
|
||||
} // namespace Rendering
|
||||
} // namespace XCEngine
|
||||
Reference in New Issue
Block a user