XCEngine/engine/src/Rendering/RenderSceneExtractor.cpp

#include "Rendering/RenderSceneExtractor.h"

#include "Components/CameraComponent.h"
#include "Components/GameObject.h"
#include "Components/MeshFilterComponent.h"
#include "Components/MeshRendererComponent.h"
#include "Components/TransformComponent.h"
#include "Rendering/RenderMaterialUtility.h"
#include "Scene/Scene.h"

#include <algorithm>

namespace XCEngine {
namespace Rendering {

namespace {

bool IsUsableCamera(const Components::CameraComponent* camera) {
    return camera != nullptr &&
           camera->IsEnabled() &&
           camera->GetGameObject() != nullptr &&
           camera->GetGameObject()->IsActiveInHierarchy();
}

bool CompareVisibleItems(const VisibleRenderItem& lhs, const VisibleRenderItem& rhs) {
    if (lhs.renderQueue != rhs.renderQueue) {
        return lhs.renderQueue < rhs.renderQueue;
    }

    const bool isTransparentQueue = IsTransparentRenderQueue(lhs.renderQueue);
    if (lhs.cameraDistanceSq != rhs.cameraDistanceSq) {
        return isTransparentQueue
            ? lhs.cameraDistanceSq > rhs.cameraDistanceSq
            : lhs.cameraDistanceSq < rhs.cameraDistanceSq;
    }

    if (lhs.gameObject != rhs.gameObject) {
        return lhs.gameObject < rhs.gameObject;
    }

    return lhs.sectionIndex < rhs.sectionIndex;
}

} // namespace

RenderSceneData RenderSceneExtractor::Extract(
    const Components::Scene& scene,
    Components::CameraComponent* overrideCamera,
    uint32_t viewportWidth,
    uint32_t viewportHeight) const {
    RenderSceneData sceneData;
    sceneData.camera = SelectCamera(scene, overrideCamera);
    if (sceneData.camera == nullptr) {
        return sceneData;
    }

    sceneData.cameraData = BuildCameraData(*sceneData.camera, viewportWidth, viewportHeight);
    const Math::Vector3 cameraPosition = sceneData.cameraData.worldPosition;

    const std::vector<Components::GameObject*> rootGameObjects = scene.GetRootGameObjects();
    for (Components::GameObject* rootGameObject : rootGameObjects) {
        ExtractVisibleItems(rootGameObject, cameraPosition, sceneData.visibleItems);
    }

    std::stable_sort(
        sceneData.visibleItems.begin(),
        sceneData.visibleItems.end(),
        CompareVisibleItems);

    return sceneData;
}

Components::CameraComponent* RenderSceneExtractor::SelectCamera(
    const Components::Scene& scene,
    Components::CameraComponent* overrideCamera) const {
    if (IsUsableCamera(overrideCamera)) {
        return overrideCamera;
    }

    const std::vector<Components::CameraComponent*> cameras = scene.FindObjectsOfType<Components::CameraComponent>();

    Components::CameraComponent* primaryCamera = nullptr;
    for (Components::CameraComponent* camera : cameras) {
        if (!IsUsableCamera(camera)) {
            continue;
        }

        if (camera->IsPrimary()) {
            if (primaryCamera == nullptr || camera->GetDepth() > primaryCamera->GetDepth()) {
                primaryCamera = camera;
            }
        }
    }

    if (primaryCamera != nullptr) {
        return primaryCamera;
    }

    for (Components::CameraComponent* camera : cameras) {
        if (IsUsableCamera(camera)) {
            return camera;
        }
    }

    return nullptr;
}

RenderCameraData RenderSceneExtractor::BuildCameraData(
    const Components::CameraComponent& camera,
    uint32_t viewportWidth,
    uint32_t viewportHeight) const {
    RenderCameraData cameraData;
    cameraData.viewportWidth = viewportWidth;
    cameraData.viewportHeight = viewportHeight;
    cameraData.worldPosition = camera.transform().GetPosition();
    cameraData.clearColor = camera.GetClearColor();

    const Math::Matrix4x4 view = camera.transform().GetWorldToLocalMatrix();
    const float aspect = viewportHeight > 0
        ? static_cast<float>(viewportWidth) / static_cast<float>(viewportHeight)
        : 1.0f;

    Math::Matrix4x4 projection = Math::Matrix4x4::Identity();
    if (camera.GetProjectionType() == Components::CameraProjectionType::Perspective) {
        projection = Math::Matrix4x4::Perspective(
            camera.GetFieldOfView() * Math::DEG_TO_RAD,
            aspect,
            camera.GetNearClipPlane(),
            camera.GetFarClipPlane());
    } else {
        const float orthoSize = camera.GetOrthographicSize();
        projection = Math::Matrix4x4::Orthographic(
            -orthoSize * aspect,
            orthoSize * aspect,
            -orthoSize,
            orthoSize,
            camera.GetNearClipPlane(),
            camera.GetFarClipPlane());
    }

    cameraData.view = view.Transpose();
    cameraData.projection = projection.Transpose();
    cameraData.viewProjection = (projection * view).Transpose();
    return cameraData;
}

void RenderSceneExtractor::ExtractVisibleItems(
    Components::GameObject* gameObject,
    const Math::Vector3& cameraPosition,
    std::vector<VisibleRenderItem>& visibleItems) const {
    if (gameObject == nullptr || !gameObject->IsActiveInHierarchy()) {
        return;
    }

    auto* meshFilter = gameObject->GetComponent<Components::MeshFilterComponent>();
    auto* meshRenderer = gameObject->GetComponent<Components::MeshRendererComponent>();
    if (meshFilter != nullptr &&
        meshRenderer != nullptr &&
        meshFilter->IsEnabled() &&
        meshRenderer->IsEnabled()) {
        Resources::Mesh* mesh = meshFilter->GetMesh();
        if (mesh != nullptr && mesh->IsValid()) {
            const Math::Matrix4x4 localToWorld = gameObject->GetTransform()->GetLocalToWorldMatrix();
            const Math::Vector3 worldPosition = localToWorld.GetTranslation();
            const float cameraDistanceSq = (worldPosition - cameraPosition).SqrMagnitude();
            const Containers::Array<Resources::MeshSection>& sections = mesh->GetSections();

            if (!sections.Empty()) {
                for (size_t sectionIndex = 0; sectionIndex < sections.Size(); ++sectionIndex) {
                    const Resources::MeshSection& section = sections[sectionIndex];

                    VisibleRenderItem visibleItem;
                    visibleItem.gameObject = gameObject;
                    visibleItem.meshFilter = meshFilter;
                    visibleItem.meshRenderer = meshRenderer;
                    visibleItem.mesh = mesh;
                    visibleItem.materialIndex = section.materialID;
                    visibleItem.sectionIndex = static_cast<Core::uint32>(sectionIndex);
                    visibleItem.hasSection = true;
                    visibleItem.material = ResolveMaterial(meshRenderer, mesh, section.materialID);
                    visibleItem.renderQueue = ResolveMaterialRenderQueue(visibleItem.material);
                    visibleItem.cameraDistanceSq = cameraDistanceSq;
                    visibleItem.localToWorld = localToWorld;
                    visibleItems.push_back(visibleItem);
                }
            } else {
                VisibleRenderItem visibleItem;
                visibleItem.gameObject = gameObject;
                visibleItem.meshFilter = meshFilter;
                visibleItem.meshRenderer = meshRenderer;
                visibleItem.mesh = mesh;
                visibleItem.materialIndex = 0;
                visibleItem.sectionIndex = 0;
                visibleItem.hasSection = false;
                visibleItem.material = ResolveMaterial(meshRenderer, mesh, 0);
                visibleItem.renderQueue = ResolveMaterialRenderQueue(visibleItem.material);
                visibleItem.cameraDistanceSq = cameraDistanceSq;
                visibleItem.localToWorld = localToWorld;
                visibleItems.push_back(visibleItem);
            }
        }
    }

    for (Components::GameObject* child : gameObject->GetChildren()) {
        ExtractVisibleItems(child, cameraPosition, visibleItems);
    }
}

} // namespace Rendering
} // namespace XCEngine