RenderTasks.hpp

#pragma once
 
#include <Common/HashedString.hpp>
#include <Common/Rendering/AssetRendererFilter.hpp>
#include <Common/Rendering/GeometryRenderingStats.hpp>
#include <Grindstone.Renderables.3D/include/Assets/Mesh3dAsset.hpp>
#include <Grindstone.Renderables.3D/include/FrustumCulling.hpp>
#include <Grindstone.Renderables.3D/include/Components/MeshRendererComponent.hpp>
 
namespace Grindstone::Renderer {
    struct RenderableBufferPair {
        glm::mat4 matrix;
        uint32_t entityId;
    };
 
    template<typename MeshComponentType, typename RenderTask>
    std::vector<RenderTask> GenerateTaskList(
        Grindstone::Rendering::GeometryRenderStats& renderingStats,
        Grindstone::HashedString renderQueueHash,
        entt::registry& registry,
        const Grindstone::Rendering::AssetRendererFilter& filter,
        const Grindstone::Renderer::CullingFrustum& frustum,
        const glm::mat4& viewMatrix,
        std::function<void(
            std::vector<RenderTask>&,
            const Grindstone::HashedString,
            const Mesh3dAsset::Submesh&,
            const Mesh3dAsset*,
            const MeshComponentType&,
            const MeshRendererComponent&
        )> submeshCallback
    ) {
        std::vector<RenderTask> renderTasks;
        renderTasks.reserve(1000);
 
        if (filter.useWhitelist) {
            GS_ASSERT_ENGINE_WITH_MESSAGE(filter.blacklist.GetSize() == 0, "You can only use the blacklist if the whitelist is empty");
 
            for (entt::entity& entity : filter.whitelist) {
                auto [transformComponent, meshComponent, meshRendererComponent] = registry.try_get<const TransformComponent, const MeshComponentType, MeshRendererComponent>(entity);
                if (transformComponent == nullptr || meshComponent == nullptr || meshRendererComponent == nullptr) {
                    continue;
                }
 
                const Mesh3dAsset* meshAsset = meshComponent->mesh.Get();
 
                if (meshAsset == nullptr) {
                    continue;
                }
 
                Math::Matrix4 transform = TransformComponent::GetWorldTransformMatrix(entity, registry);
                glm::mat4 viewTransformTransform = viewMatrix * transform;
 
                Grindstone::Renderer::AABB aabb{ meshAsset->boundingData.minAABB, meshAsset->boundingData.maxAABB };
                if (!IsInFrustum(frustum, viewTransformTransform, aabb)) {
                    renderingStats.objectsCulled += 1;
                    continue;
                }
 
                renderingStats.objectsRendered += 1;
 
                RenderableBufferPair renderableData{
                    .matrix = transform,
                    .entityId = static_cast<uint32_t>(entity)
                };
                meshRendererComponent->perDrawUniformBuffer->UploadData(&renderableData);
 
                std::vector<Grindstone::AssetReference<Grindstone::MaterialAsset>>& materials = meshRendererComponent->materials;
                for (const Grindstone::Mesh3dAsset::Submesh& submesh : meshAsset->submeshes) {
                    submeshCallback(
                        renderTasks,
                        renderQueueHash,
                        submesh,
                        meshAsset,
                        *meshComponent,
                        *meshRendererComponent
                    );
                }
            }
        }
        else {
            GS_ASSERT_ENGINE_WITH_MESSAGE(filter.blacklist.GetSize() == 0, "Blacklist support not implemented yet!");
            GS_ASSERT_ENGINE_WITH_MESSAGE(filter.whitelist.GetSize() == 0, "You can only use the whitelist if useWhitelist is true");
 
            auto view = registry.view<const entt::entity, const TransformComponent, const MeshComponentType, MeshRendererComponent>();
            view.each(
                [&submeshCallback, &renderingStats, &registry, &renderTasks, &viewMatrix, frustum, renderQueueHash](
                    entt::entity entity,
                    const TransformComponent& transformComponent,
                    const MeshComponentType& meshComponent,
                    MeshRendererComponent& meshRenderComponent
                ) {
                    const Mesh3dAsset* meshAsset = meshComponent.mesh.Get();
 
                    if (meshAsset == nullptr) {
                        return;
                    }
 
                    Math::Matrix4 transform = TransformComponent::GetWorldTransformMatrix(entity, registry);
                    glm::mat4 viewTransformTransform = viewMatrix * transform;
 
                    Grindstone::Renderer::AABB aabb{ meshAsset->boundingData.minAABB, meshAsset->boundingData.maxAABB };
                    if (!IsInFrustum(frustum, viewTransformTransform, aabb)) {
                        renderingStats.objectsCulled += 1;
                        return;
                    }
 
                    renderingStats.objectsRendered += 1;
 
                    RenderableBufferPair renderableData{
                        .matrix = transform,
                        .entityId = static_cast<uint32_t>(entity)
                    };
                    meshRenderComponent.perDrawUniformBuffer->UploadData(&renderableData);
 
                    std::vector<Grindstone::AssetReference<Grindstone::MaterialAsset>>& materials = meshRenderComponent.materials;
                    for (const Grindstone::Mesh3dAsset::Submesh& submesh : meshAsset->submeshes) {
                        submeshCallback(
                            renderTasks,
                            renderQueueHash,
                            submesh,
                            meshAsset,
                            meshComponent,
                            meshRenderComponent
                        );
                    }
                }
            );
        }
 
        return renderTasks;
    }
 
    template<typename RenderTask>
    void RenderAllTasks(
        Grindstone::Rendering::GeometryRenderStats& renderingStats,
        GraphicsAPI::DescriptorSet* engineDescriptorSet,
        GraphicsAPI::CommandBuffer* commandBuffer,
        const std::vector<RenderTask>& renderTasks
    ) {
        const GraphicsAPI::PipelineLayout* pipelineLayout = nullptr;
        const GraphicsAPI::GraphicsPipeline* graphicsPipeline = nullptr;
        const GraphicsAPI::DescriptorSet* materialDescriptorSet = nullptr;
 
        for (const RenderTask& renderTask : renderTasks) {
            if (graphicsPipeline != renderTask.pipeline) {
                graphicsPipeline = renderTask.pipeline;
                pipelineLayout = graphicsPipeline->pipelineLayout;
                commandBuffer->BindGraphicsPipeline(renderTask.pipeline);
                renderingStats.pipelineBinds += 1;
            }
 
            commandBuffer->BindVertexArrayObject(renderTask.vertexArrayObject);
 
            if (renderTask.materialDescriptorSet != materialDescriptorSet) {
                std::array<GraphicsAPI::DescriptorSet*, 3> descriptors = {
                    engineDescriptorSet,
                    renderTask.materialDescriptorSet,
                    renderTask.perDrawDescriptorSet,
                };
                commandBuffer->BindGraphicsDescriptorSet(
                    pipelineLayout,
                    descriptors.data(),
                    0,
                    static_cast<uint32_t>(descriptors.size())
                );
                renderingStats.materialBinds += 1;
            }
 
            renderingStats.drawCalls += 1;
            renderingStats.vertices += renderTask.indexCount;
            renderingStats.triangles += renderTask.indexCount / 3;
 
            commandBuffer->DrawIndices(
                renderTask.baseIndex,
                renderTask.indexCount,
                0,
                1,
                renderTask.baseVertex
            );
        }
    }
}