spk_mesh_painter.hpp

#pragma once
 
#include "structure/geometry/spk_mesh.hpp"
#include "structure/lumina/spk_pipeline.hpp"
 
#include <iostream>
 
namespace spk
{
    template <typename TMeshType>
    class MeshPainter
    {
    public:
        using Mesh = TMeshType;
 
    private:
        Lumina::Pipeline &_pipeline;
        Lumina::Pipeline::Object _object;
        const Mesh *_mesh = nullptr;
 
    protected:
        explicit MeshPainter(Lumina::Pipeline &p_pipeline) :
            _pipeline(p_pipeline),
            _object(_pipeline.createObject())
        {
        }

        Lumina::Pipeline::Object &_objectHandle()
        {
            return (_object);
        }

        const Lumina::Pipeline::Object &_objectHandle() const
        {
            return (_object);
        }
 
    public:
        virtual void setMesh(const Mesh *p_mesh)
        {
            _mesh = p_mesh;
 
            if (_mesh == nullptr)
            {
                return;
            }
 
            _object.setBufferSet(_mesh->bufferSet());
        }

        const Mesh *mesh() const
        {
            return (_mesh);
        }

        void render()
        {
            if (_mesh == nullptr)
            {
                return;
            }
 
            if (_mesh->indexes().size() == 0)
            {
                return;
            }
 
            _mesh->synchronize();
            _object.render();
        }
    };
}