Scene.hpp

Go to the documentation of this file.

#pragma once

#include "TaskManager.hpp"

class SceneObject;
class Scene;

class SceneInstance : public ISceneObject
{
    struct AnimationStart
    {
        int animation;  
        float time;     
        AnimationStart(int _animation, float _time)
            : animation(_animation)
            , time(_time)
        { }
    };

    Scene*                  m_scene;                
    Transformation          m_transformation;       
    vector<mat4>            m_state;                
    AnimationStart          m_animation;            
    queue<AnimationStart>   m_animationQueue;       
    friend class Scene;

    public:
        Transformation& getTransform() { return m_transformation; }

    public:
        SceneInstance(Application* app, Scene* parent, bool pickable = true);
        virtual ~SceneInstance();

        virtual bool update(double time, double timeDelta);
        
        void queueAnimation(float time, uint animation);
        void queueAnimation(float time, string animation);
};

class Scene
{
    class Material
    {
        struct data
        {
            vec4    ambient;    
            vec4    diffuse;    
            vec4    specular;   
            float   shininess;  
        };

        GLuint      m_ubuffer;  
        Texture*    m_texture;  
        public:
            Material(vec4 const & ambient, vec4 const & diffuse, vec4 const & specular, float const shininess, Texture* texture);
            ~Material();

            void bindTo(Shader * shader, string const uniform);
    };

    class Mesh
    {
        Scene*          m_scene;            
        string          m_name;             
        vector<int>     m_nodeIndices;      
        GLuint          m_baseIndex;        
        GLuint          m_indexCount;       
        Material*       m_material;         
        friend class Scene;

        public:
            Mesh(Scene* scene, string const & name, GLuint const baseIdx, GLuint const idxCount, Material* material);

            void drawInstances(Shader* shader, set<SceneInstance*> const & instances);
    };

    class NodeAnimation
    {
        public:
            template<typename T>
            struct Frame
            {
                float time; 
                T value;    
            };

        private:            
            vector<Frame<vec3>> m_positions;    
            vector<Frame<vec3>> m_scalings;     
            vector<Frame<quat>> m_rotations;    
            friend class Scene;

        public:
            bool transformationByTime(float const time, OUT mat4& result);

        private:
            template<typename T>
            T interpolate(vector<Frame<T>> const & frames, float const time)
            {
                if (frames.size() == 1)
                    return frames.front().value;

                Frame<T> const * prev;
                Frame<T> const * next;

                nearestFrames(frames, time, OUT prev, OUT next);

                float t = 0;
                
                if (next->time != prev->time)
                    t = (time - prev->time) / (next->time - prev->time);

                return glm::mix(prev->value, next->value, glm::clamp(t,0.0f,1.0f));
            }

            template<typename T>
            void nearestFrames(vector<Frame<T>> const & frames, float const time, OUT Frame<T> const * & prev, OUT Frame<T> const * & next)
            {
                auto it = frames.rbegin();

                while (it != frames.rend())
                {
                    if (it->time < time) break;
                    it++;
                }

                 if (it == frames.rend())
                 {
                     next = &(frames.front());
                     prev = &(frames.front());
                     return;
                 }

                 prev = &(*it);
                 it--;

                 if (it == frames.rbegin())
                 {
                     next = &(frames.back());
                     return;
                 }

                 next = &(*it);
            }
    };

    class Node
    {
        Scene*                      m_scene;        
        vector<unique_ptr<Node>>    m_children;     
        vector<Mesh*>               m_meshes;       
        mat4                        m_local;        
        int                         m_idx;          
        bool                        m_isBone;       
        map<uint, NodeAnimation>    m_animations;   
        friend class Scene;

        public:
            Node(Scene* scene, mat4 const & local);
            
            mat4 transformationByTime(uint const animation, float const time);

            void updateInstance(SceneInstance& instance, float time, mat4 const & parentTransformation);
    };

    auto_reset_event                                m_parallelEvent;            
    string                                          m_name;                     
    vector<unique_ptr<Material>>                    m_materials;                
    vector<unique_ptr<Mesh>>                        m_meshes;                   
    unique_ptr<Node>                                m_root;                     
    set<SceneInstance*>                             m_instances;                
    Application*                                    m_app;                      
    map<string,int>                                 m_animationsByName;         
    vector<float>                                   m_animationsDuration;       
    size_t                                          m_boneCount;                
    size_t                                          m_drawNodeCount;            
    vector<mat4>                                    m_boneOffsets;              
    mat4                                            m_inverseRootTransform;     
    size_t                                          m_instancesInBuffer;        
    bool                                            m_needToUpdateIdBuffer;     
    GLuint                                          m_positionsBuffer;          
    GLuint                                          m_uvBuffer;                 
    GLuint                                          m_normalsBuffer;            
    GLuint                                          m_boneIdBuffer;             
    GLuint                                          m_boneWeightBuffer;         
    GLuint                                          m_indicesBuffer;            
    GLuint                                          m_vao;                      
    GLuint                                          m_stateTBO;                 
    GLuint                                          m_stateBuffer;              
    GLuint                                          m_idTBO;                    
    GLuint                                          m_idBuffer;                 
    friend class SceneInstance;

    public:
        Scene(Application* app, string const & name);
        ~Scene();
        
        void updateInstance(SceneInstance* instance, float const time);
        void updateAllInstances(float const time);
        void drawAllInstances(DrawArgs& args, Shader* shader);
        void updateNdraw(DrawArgs& args, Shader* shader);
        
        SceneInstance* createInstance(bool pickable = true);
        void unregisterInstance(SceneInstance* obj);
};

class Scenes
{
    typedef map<string,unique_ptr<Scene>> mesh_map;

    mesh_map        m_scenes;   
    Application*    m_app;      
    Shader*         m_shader;   
    public:
        Scenes(Application* app);

        Scene* get(string const & name);
        
        void drawAll(DrawArgs& args);
};