mesh_skinned_renderer.h

#ifndef OE_RENDER_MESH_SKINNED_RENDERER_H
#define OE_RENDER_MESH_SKINNED_RENDERER_H
 
#include "mesh_renderer.h"
#include "../scene/skin.h"
 
#include "texture.h"
 
namespace oe::render
{
    struct MeshSkinnedRenderer : public MeshRenderer
    {
        constexpr const static oe::render::GeometryPass geometry_pass = oe::render::GeometryPass::SKINNED;
 
        template <typename BaseMeshType>
        MeshSkinnedRenderer(oe::scene::NodePtr& root_node, const BaseMeshType& scene_mesh, const oe::scene::skin::Armature& param_armature = {}):
            MeshRenderer(root_node, scene_mesh),
            armature(param_armature)
        {
            // If no armature or missing root node, use the one provided
            if (!param_armature.root_node)
            {
                armature.root_node = root_node;
            }
 
            _bones_count = armature.bones.size();
 
            _bones_texture = std::make_shared<Texture>(
                _bones_count * 16, 1, nullptr,
                4,
                GL_RGBA32F, GL_RGBA, GL_FLOAT
            );
        }

        bool fillRenderCommands(const scene::Camera& camera, const bool is_blending_pass, std::vector<render::DrawCommand>& result)
        {
            // Update the armature (also updates bones BBOX for frustum culling)
            armature.update();
 
            // Check if the mesh will be rendered (no need to uselessly fill bones / blendshapes if no render)
            bool has_rendering = MeshRenderer::fillRenderCommands(camera, is_blending_pass, result);
 
            if (has_rendering)
            {
                // Fill bones texture
                std::vector<glm::vec4> bones_lut;
 
                const auto& bones_matrices = armature.bones_matrices;
 
                for (const auto& mat : bones_matrices)
                {
                    bones_lut.push_back(mat[0]);
                    bones_lut.push_back(mat[1]);
                    bones_lut.push_back(mat[2]);
                    bones_lut.push_back(mat[3]);
                }
 
                ByteSpan encoded_bones_lut{reinterpret_cast<std::byte*>(bones_lut.data()), bones_lut.size() * 16};
 
                _bones_texture->fillTextureData(encoded_bones_lut, 0, 0);
            }
 
            return has_rendering;
        }

        void fillShader(ShaderBase* shader, const oe::scene::Camera& camera)
        {
            // Send Bones data
            _bones_texture->use(6);
            shader->setInt("uBonesMatrices", 6);
 
            MeshRenderer::fillShader(shader, camera);
        }
 
        oe::scene::skin::Armature armature;
 
        std::shared_ptr<Texture> _bones_texture;
 
        uint32_t _bones_count = 0;
 
    };
}
 
#endif