node.h

#ifndef OE_SCENE_NODE_H
#define OE_SCENE_NODE_H
 
#include "../common.h"
 
#include <optional>
#include <functional>
#include <string>
#include <list>
#include <memory>
#include <vector>
 
#include "../util/non_copyable.h"
#include "component/node.h"
#include "material.h"
#include "aabb.h"
#include "transform.h"
 
namespace oe::scene
{
    class Camera;
    class Manager;
 
    using NodeType = uint64_t;
    const NodeType NodeTypeALL = 0;
 
    class Node : public Transform, public util::NonCopyable, public oe::component::HasComponents<Node, NodeComponent>
    {
        public:
            explicit Node();
            virtual ~Node() {}
 
            inline const Node* getParentNode() const noexcept
            {
                return _parent_node;
            }
 
            inline Node* getParentNode() noexcept
            {
                return _parent_node;
            }
 
            inline Manager* getSceneManager()
            {
                return _manager;
            }
 
            void addChild(Node& child);
 
            inline const std::vector<oe::scene::Node*>& getChildren() noexcept
            {
                return _children;
            }
 
            inline const std::vector<oe::scene::Node*>& getChildren() const noexcept
            {
                return _children;
            }
 
            void setParent(Node& parent) noexcept;
 
            void moveToRoot() noexcept;
 
            void foreachChildren(void (*func)(Node&, void*), const bool recursion = false, void* user_data = nullptr);
 
            void foreachChildren(std::function<void(Node&)> func, const bool recursion = false);
 
            const std::string getAbsoluteName(const std::string& separator = "/") const noexcept;
 
            template <typename T = Node>
            T* search(const std::string path, const std::string separator = "/")
            {
                Node* rawresult = _internalSearch(path, separator);
 
                return dynamic_cast<T*>(rawresult);
            }
 
            inline bool isVisible() const
            {
                return _is_visible;
            }
 
            void setVisible(const bool& is_visible = true)
            {
                _is_visible = is_visible;
            }
 
            bool canRender(const scene::Camera& camera) const;
 
            const AABB& getBoundingBox() const;
 
            const AABB getEnglobingBoundingBox() const;
 
            std::vector<Node*> getAllParents() const;
 
            Transform getAbsoluteTransform() const;
 
            glm::vec3 getAbsolutePosition() const;
 
            const glm::mat4& getAbsoluteModelMatrix() const;
 
            const glm::mat4 getAbsoluteInverseModelMatrix() const;
 
            glm::quat getRotationNeededToLookAt(const glm::vec3& target, const glm::vec3& up = glm::vec3(0.f, 1.f, 0.f)) const;
 
            void lookAt(const glm::vec3& target, const glm::vec3& up = glm::vec3(0.f, 1.f, 0.f));
 
            virtual void update(const double& delta, const int8_t flags = 0);
 
            void generateModel(const bool recursive = true) const;
 
            std::string name = "";
 
            AABB raw_aabb;
 
        protected:
            mutable AABB _aabb;
 
        private:
 
            bool _is_visible = true;
 
            Manager* _manager = nullptr;
            Node* _parent_node = nullptr;
 
            std::vector<oe::scene::Node*> _children;
 
            void _remove_child(Node&) noexcept;
 
            mutable glm::mat4 _model_matrix;
 
            mutable glm::mat4 _absolute_model_matrix;
 
            Node* _internalSearch(const std::string& path, const std::string& separator) noexcept;
 
            Node* _internalSearch(
                const std::vector<std::string>::iterator& begin,
                const std::vector<std::string>::iterator& end
            ) noexcept;
 
            bool _has_dirty_parents() const;
 
            Node* _fetch_dirty_parent() const;
 
        // Only used to set '_manager', todo use the 'Passkey' design pattern
        friend class Manager;
    };
}
 
#endif