mesh_renderer.h

#ifndef OE_RENDER_MESH_RENDERER_H
#define OE_RENDER_MESH_RENDERER_H
 
#include "../scene/node.h" // IWYU pragma: keep (Required for NodePtr)
 
#include "../scene/material.h"
#include "../scene/camera.h"
 
#include "mesh.h"
#include "shader_base.h"
 
namespace oe::render
{
    struct DrawCommand
    {
        std::vector<bool> enabled_primitives;
        scene::Material* material;
    };

    struct MeshRenderer
    {
        constexpr const static oe::render::GeometryPass geometry_pass = oe::render::GeometryPass::SOLID;
 
        template <typename BaseMeshType>
        MeshRenderer(oe::scene::NodePtr& node, const BaseMeshType& scene_mesh):
            node(node),
            render_mesh(scene_mesh)
        {
            node->raw_aabb = scene_mesh.getBoundingBox();
 
            // By default, we consider the mesh to have only one material applied on all primitives
            addMaterial(true);
        }

        void addMaterial(bool assign_to_primitives = false)
        {
            const auto primitives_count = render_mesh.primitives.size();
            assert(primitives_count > 0);
 
            materials.reserve(materials.size() + 1);
            materials.push_back({});
 
            primitives_by_material.push_back(std::vector<bool>(primitives_count, assign_to_primitives));
        }

        bool fillRenderCommands(const scene::Camera& camera, const bool is_blending_pass, std::vector<render::DrawCommand>& result)
        {
            const size_t material_count = materials.size();
 
            if (material_count == 0 || !camera.isInFrustum(node->getBoundingBox()))
            {
                return false;
            }
 
            assert(primitives_by_material.size() == material_count);
 
            result.reserve(material_count);
 
            for (auto id_material = 0u; id_material < material_count; ++id_material)
            {
                auto* material = &materials.at(id_material);
 
                if (material->is_blend != is_blending_pass)
                {
                    continue;
                }
 
                assert(primitives_by_material.size() > id_material);
                assert(render_mesh.primitives.size() == primitives_by_material.at(id_material).size());
 
                result.push_back({
                    .enabled_primitives = primitives_by_material.at(id_material),
                    .material = material
                });
            }
 
            return true;
        }

        void fillShader(ShaderBase* shader, const oe::scene::Camera& camera)
        {
            auto model_matrix = node->getAbsoluteModelMatrix();
            auto normal_matrix = glm::transpose(glm::mat3(glm::inverse(camera.getView() * model_matrix)));
 
            shader->setMat4("uModel", model_matrix);
            shader->setMat3("uNormalMatrix", normal_matrix);
        }

        oe::scene::NodePtr node;

        Mesh render_mesh;

        std::vector<scene::Material> materials;

        std::vector<std::vector<bool>> primitives_by_material;
    };
}
 
#endif