vimix/Scene.h

#ifndef SCENE_H
#define SCENE_H

#include <vector>
#include <glm/glm.hpp>

glm::mat4 transform(glm::vec3 translation, glm::vec3 rotation, glm::vec3 scale);

// Forward declare classes referenced
class Shader;
class Visitor;

// Base virtual class for all Node types
// Manages modelview transformations and culling
class Node {

public:
    Node();
    virtual ~Node() {}    
    inline int id() { return id_; }

    virtual void init() = 0;
    virtual void draw( glm::mat4 modelview,  glm::mat4 projection) = 0;
    virtual void accept(Visitor& v);
    virtual void update( float dt );
    virtual bool initialized() { return initialized_; }
    virtual glm::mat4 getWorldToLocalMatrix() { return worldToLocal_; }
    virtual glm::mat4 getLocalToWorldMatrix() { return localToWorld_; }

    Node*     parent_;
    bool      visible_;
    bool      initialized_;
    int       id_;
    glm::mat4 worldToLocal_;
    glm::mat4 localToWorld_;
    glm::mat4 transform_;
    glm::vec3 scale_, rotation_, translation_;
};


// Leaf Nodes are primitives that can be rendered
class Primitive : public Node {

public:
    Primitive() : Node(), shader_(nullptr), vao_(0), drawingPrimitive_(0) {}
    virtual ~Primitive();

    virtual void init () override;
    virtual void draw ( glm::mat4 modelview, glm::mat4 projection) override;
    virtual void accept(Visitor& v) override;

    Shader *getShader() { return shader_; }
    void setShader( Shader* e ) { shader_ = e; }

protected:
    Shader*   shader_;
    uint vao_;
    uint drawingPrimitive_;
    std::vector<glm::vec3>     points_;
    std::vector<glm::vec3>     colors_;
    std::vector<glm::vec2>     texCoords_;
    std::vector<uint>  indices_;
    virtual void deleteGLBuffers_();
};

// Other Nodes establish hierarchy with a group of nodes
class Group : public Node {

public:
    Group() : Node() {}
    virtual ~Group();

    virtual void init () override;
    virtual void update ( float dt ) override;
    virtual void draw ( glm::mat4 modelview, glm::mat4 projection) override;
    virtual void accept(Visitor& v) override;

    void addChild ( Node *child );
    Node* getChild ( uint i );
    uint numChildren() const;

protected:
    std::vector< Node* > children_;
};

class Switch : public Group {

public:
    Switch() : Group(), active_(0) {}

    virtual void update ( float dt ) override;
    virtual void draw ( glm::mat4 modelview, glm::mat4 projection) override;
    virtual void accept(Visitor& v) override;

    void setActiveIndex(uint index);
    uint activeIndex() const { return active_; }
    Node* activeNode();

protected:
    uint active_;
};

// A scene contains a root node and gives a simplified API to add nodes
class Scene  {

public:
    Scene() {}

    Group *getRoot() { return &root_; }

    void accept(Visitor& v);

    Group root_;

};



#endif // SCENE_H