node.hpp

#pragma once
 
#include <functional>
#include <glm/glm.hpp>
#include <vector>
#include <unordered_map>
 
#include "cat3d/util/clock.hpp"
#include "cat3d/util/transform.hpp"
#include "cat3d/window.hpp"
 
namespace cat3d::scene {
 
enum node_bind_loc {
    PRE_UPDATE,
    POST_UPDATE,
    PRE_RENDER,
    POST_RENDER,
};
 
class node {
public:
    node();
 
    static node* new_root();
 
    virtual ~node();
 
    void delete_child(node* child);
 
    util::transform global_transform() const;
 
    util::transform local_transform() const;
 
    util::transform& transform();
 
    void update(window& win);
 
    void render(window& win);
 
    node* parent() const;
 
    node* create_node();
 
    template <typename Obj, typename... Args>
    Obj* create(Args... args) {
        Obj* o      = new Obj(args...);
        o->m_root   = false;
        o->m_parent = this;
        m_children.push_back((node*)o);
        return o;
    }
 
    size_t bind(node_bind_loc loc, std::function<void()> fn);
 
    void unbind(size_t id);
 
protected:
    virtual void update_self(window& win);
 
    virtual void render_self(window& win);
 
private:
    bool m_root = false;
 
    node* m_parent = nullptr;
 
    std::vector<node*> m_children;
 
    std::unordered_map<size_t, std::pair<node_bind_loc, std::function<void()>>> m_hooks;
 
    size_t m_next_hook_id = 0;
 
    void run_hooks(node_bind_loc l);
 
    util::transform m_transform;
 
    void push_transform(window& win);
};
 
}