SimpleMesh.hpp

Go to the documentation of this file.

#pragma once

#include "Scene.hpp"

class SimpleMesh;

class SimpleMeshInstance : public ISceneObject
{
    SimpleMesh*                         m_mesh;                 
    Transformation                      m_transformation;       
    map<string,function<void(Shader*)>> m_uniforms;             
    public:
        Transformation& getTransform() { return m_transformation; }

    public:
        SimpleMeshInstance(Application* app, SimpleMesh* mesh, bool pickable = true);
        virtual ~SimpleMeshInstance();
        
        void prepareDraw(DrawArgs& args, Shader* shader);

        virtual bool update(double time, double timeDelta);


        template<typename t>
        void uniform(string const & name, t value)
        {
            m_uniforms[name] = [value, name]
                               (Shader* shader)
                               {
                                   shader->uniform(name,value);
                               };
        }
};


class SimpleMesh
{
    Application* m_app;             
    string m_name;                  
    vector<vec3> m_positions;       
    vector<vec2> m_uvs;             
    vector<vec3> m_normals;         
    vector<uint> m_indices;         
    GLuint m_positionsBuffer;       
    GLuint m_uvBuffer;              
    GLuint m_normalsBuffer;         
    GLuint m_indicesBuffer;         
    GLuint m_vao;                   
    set<SimpleMeshInstance*> m_instances; 
    public:
        template<typename t_fnc>
        SimpleMesh(Application* app, string const & name, t_fnc fnc)
            : m_name(name)
            , m_app(app)
        {
            fnc(&m_positions, &m_normals, &m_uvs, &m_indices);
            create();
        }

        ~SimpleMesh();

        void drawAllInstances(DrawArgs& args, Shader* shader);

        SimpleMeshInstance* createInstance(bool pickable = true);

        void unregisterInstance(SimpleMeshInstance* obj);

    private:

        void create();
};

class SimpleMeshes
{
    typedef map<string,unique_ptr<SimpleMesh>> mesh_map;

    mesh_map        m_meshes;       
    Application*    m_app;          
    Shader*         m_shader;       
    public:
        SimpleMeshes(Application* app);
        
        template<typename t_fnc>
        SimpleMesh* create(string const & name, t_fnc fnc)
        {
            auto mesh = new SimpleMesh(m_app, name, fnc);
            m_meshes[name].reset(mesh);
            return mesh;
        }

        SimpleMesh* get(string const & name);

        void drawAll(DrawArgs& args);
};