XCEngine/engine/src/Rendering/SceneRenderer.cpp

#include "Rendering/SceneRenderer.h"
#include "Rendering/SceneRenderRequestUtils.h"

#include "Components/GameObject.h"
#include "Scene/Scene.h"

#include <algorithm>

namespace XCEngine {
namespace Rendering {

SceneRenderer::SceneRenderer() = default;

SceneRenderer::SceneRenderer(std::unique_ptr<RenderPipeline> pipeline)
    : m_cameraRenderer(std::move(pipeline)) {
}

SceneRenderer::SceneRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
    : m_cameraRenderer(std::move(pipelineAsset)) {
}

void SceneRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
    m_cameraRenderer.SetPipeline(std::move(pipeline));
}

void SceneRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset) {
    m_cameraRenderer.SetPipelineAsset(std::move(pipelineAsset));
}

std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
    const Components::Scene& scene,
    Components::CameraComponent* overrideCamera,
    const RenderContext& context,
    const RenderSurface& surface) const {
    std::vector<CameraRenderRequest> requests;

    std::vector<Components::CameraComponent*> cameras;
    if (SceneRenderRequestUtils::IsUsableCamera(overrideCamera)) {
        cameras.push_back(overrideCamera);
    } else {
        cameras = scene.FindObjectsOfType<Components::CameraComponent>();
        cameras.erase(
            std::remove_if(
                cameras.begin(),
                cameras.end(),
                [](const Components::CameraComponent* camera) {
                    return !SceneRenderRequestUtils::IsUsableCamera(camera);
                }),
            cameras.end());
    }

    SceneRenderRequestUtils::SortSceneCamerasForRendering(cameras);

    size_t renderedBaseCameraCount = 0;
    for (Components::CameraComponent* camera : cameras) {
        CameraRenderRequest request;
        if (SceneRenderRequestUtils::BuildCameraRenderRequest(
                scene,
                *camera,
                context,
                surface,
                renderedBaseCameraCount,
                requests.size(),
                request)) {
            requests.push_back(request);
            if (camera->GetStackType() == Components::CameraStackType::Base) {
                ++renderedBaseCameraCount;
            }
        }
    }

    return requests;
}

bool SceneRenderer::Render(const CameraRenderRequest& request) {
    return m_cameraRenderer.Render(request);
}

bool SceneRenderer::Render(const std::vector<CameraRenderRequest>& requests) {
    if (requests.empty()) {
        return false;
    }

    for (const CameraRenderRequest& request : requests) {
        if (!request.IsValid()) {
            return false;
        }
    }

    std::vector<CameraRenderRequest> sortedRequests = requests;
    SceneRenderRequestUtils::SortCameraRenderRequests(sortedRequests);

    bool rendered = false;
    for (const CameraRenderRequest& request : sortedRequests) {
        if (!m_cameraRenderer.Render(request)) {
            return false;
        }
        rendered = true;
    }

    return rendered;
}

bool SceneRenderer::Render(
    const Components::Scene& scene,
    Components::CameraComponent* overrideCamera,
    const RenderContext& context,
    const RenderSurface& surface) {
    return Render(BuildRenderRequests(scene, overrideCamera, context, surface));
}

} // namespace Rendering
} // namespace XCEngine