XCEngine/engine/src/Rendering/RenderPipelineAsset.cpp

#include <XCEngine/Rendering/RenderPipelineAsset.h>

#include "Components/CameraComponent.h"
#include "Components/LightComponent.h"
#include "Rendering/Execution/CameraFramePlan.h"
#include "Rendering/Extraction/RenderSceneUtility.h"
#include "Rendering/Planning/Internal/CameraFrameFullscreenStagePlanner.h"
#include "Rendering/Planning/Internal/DirectionalShadowPlanning.h"
#include "Rendering/Planning/CameraRenderRequest.h"
#include "Rendering/Planning/SceneRenderRequestPlanner.h"

namespace XCEngine {
namespace Rendering {

void ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
    CameraRenderRequest& request,
    size_t renderedBaseCameraCount,
    size_t renderedRequestCount,
    const DirectionalShadowPlanningSettings& directionalShadowSettings) {
    if (request.scene == nullptr ||
        request.camera == nullptr) {
        return;
    }

    if (!Internal::ShouldPlanDirectionalShadowForCamera(
            *request.camera,
            renderedBaseCameraCount,
            renderedRequestCount)) {
        return;
    }

    Components::LightComponent* const mainDirectionalLight =
        FindMainDirectionalLight(
            *request.scene,
            request.camera->GetCullingMask());
    if (mainDirectionalLight == nullptr ||
        !mainDirectionalLight->GetCastsShadows()) {
        return;
    }

    DirectionalShadowPlanningSettings effectiveShadowSettings =
        Internal::SanitizeDirectionalShadowPlanningSettings(
            directionalShadowSettings);
    if (mainDirectionalLight->GetOverridesDirectionalShadowSettings()) {
        effectiveShadowSettings.sampling =
            mainDirectionalLight->GetDirectionalShadowSamplingSettings();
        effectiveShadowSettings.casterBias =
            mainDirectionalLight->GetDirectionalShadowCasterBiasSettings();
    }

    const float viewportAspect = request.surface.GetRenderAreaHeight() > 0
        ? static_cast<float>(request.surface.GetRenderAreaWidth()) /
            static_cast<float>(request.surface.GetRenderAreaHeight())
        : 1.0f;
    request.directionalShadow =
        Internal::BuildDirectionalShadowRenderPlan(
            *request.scene,
            *request.camera,
            *mainDirectionalLight,
            effectiveShadowSettings,
            viewportAspect);
}

void ApplyDefaultRenderPipelineAssetCameraFramePlanPolicy(
    CameraFramePlan& plan,
    const FinalColorSettings& pipelineDefaults) {
    if (plan.request.camera != nullptr) {
        plan.finalColorPolicy = ResolveFinalColorPolicy(
            pipelineDefaults,
            &plan.request.camera->GetFinalColorOverrides());
    }

    Internal::PlanCameraFrameFullscreenStages(plan);
}

void RenderPipelineAsset::ConfigureCameraRenderRequest(
    CameraRenderRequest& request,
    size_t renderedBaseCameraCount,
    size_t renderedRequestCount,
    const DirectionalShadowPlanningSettings& directionalShadowSettings) const {
    ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
        request,
        renderedBaseCameraCount,
        renderedRequestCount,
        directionalShadowSettings);
}

void RenderPipelineAsset::ConfigureCameraFramePlan(CameraFramePlan& plan) const {
    ApplyDefaultRenderPipelineAssetCameraFramePlanPolicy(
        plan,
        GetDefaultFinalColorSettings());
}

} // namespace Rendering
} // namespace XCEngine