node.h

#ifndef OE_SCENE_NODE_H
#define OE_SCENE_NODE_H
 
#include <stdexcept>
#include <string>
#include <vector>
 
#include <algorithm>
#include "aabb.h"
#include "transform.h"
 
#include "node_ptr.h"
 
namespace oe::util::str
{
    std::vector<std::string> split(const std::string &input, const std::string& separator);
}
 
namespace oe::scene
{
    using NodeType = uint64_t;
    const NodeType NodeTypeALL = 0;
 
    class Node : public Transform
    {
        public:
            Node(const NodePtr& identifier):
                scene_data(identifier)
            {}
 
            void setChild(const NodePtr& child)
            {
                if (child.scene != scene_data.scene) [[unlikely]]
                {
                    throw std::invalid_argument("Node parent is not in the current scene!");
                }
 
                // child already a child of this node
                if (child->parent == scene_data)
                {
                    return;
                }
 
                if (child->parent)
                {
                    child->parent->_remove_child(child);
                }
 
                child->parent = scene_data;
                children.push_back(child);
 
                forceDirty(true);
                child->forceDirty(true);
            }
 
            void setParent(const NodePtr& new_parent)
            {
                if (new_parent.scene != scene_data.scene) [[unlikely]]
                {
                    throw std::invalid_argument("Node parent is not in the current scene!");
                }
 
                if (new_parent == parent)
                {
                    return;
                }
 
                if (parent)
                {
                    parent->_remove_child(scene_data);
                }
 
                new_parent->setChild(scene_data);
 
                forceDirty(true);
            }
 
            void moveToRoot() noexcept
            {
                parent->_remove_child(scene_data);
                parent = {};
 
                forceDirty(true);
            }
 
            /*
             * @brief Do actions on children
             */
            //void foreachChildren(void (*func)(const NodePtr&, void*), const bool recursion = false, void* user_data = nullptr);
 
            /*
             * @brief Do actions on children
             * @note same as above but with a lambda, might be slower
             */
            //void foreachChildren(std::function<void(const NodePtr&)> func, const bool recursion = false);
 
            const std::string getAbsoluteName(const std::string& separator = "/") const noexcept
            {
                return (parent ? parent->getAbsoluteName(separator) + separator : "") + name;
            }
 
            NodePtr search(const std::string path, const std::string separator = "/")
            {
                if (path == "")
                    return {};
 
                return searchFromThisNode(name + separator + path, separator);
            }
 
            NodePtr searchFromThisNode(const std::string& path, const std::string& separator) noexcept;
 
            const AABB& getBoundingBox() const;
 
            const AABB getEnglobingBoundingBox() const;
 
            /*
             * @brief Get all node parents hierarchy of the node
             * @return first element is direct parent, second element is parent of parent, ..., last element is the root parent
             *
             * @note Will be empty for root nodes
             */
            //std::vector<NodePtr> getParentHierarchy() const;
 
            Transform getAbsoluteTransform() const
            {
                return {getAbsoluteModelMatrix()};
            }
 
            glm::vec3 getAbsolutePosition() const
            {
                return glm::vec3(getAbsoluteModelMatrix() * glm::vec4(0, 0, 0, 1));
            }
 
            const glm::mat4& getAbsoluteModelMatrix() const;
 
            const glm::mat4 getAbsoluteInverseModelMatrix() const
            {
                return glm::inverse(getAbsoluteModelMatrix());
            }
 
            /*
             * @brief Get the rotation needed to orient the node at a specified target
             *
             * @param target Target Position
             * @param up Desired upward direction (change it if you want roll effects)
             *
             * @todo maybe deprecated and put in trandform?
             */
            //glm::quat getRotationNeededToLookAt(const glm::vec3& target, const glm::vec3& up = glm::vec3(0.f, 1.f, 0.f)) const;
 
            /*
             * @brief Orient the node to stare at a specified target
             *
             * @param target Target Position
             * @param up Desired upward direction (change it if you want roll effects)
             */
            //void lookAt(const glm::vec3& target, const glm::vec3& up = glm::vec3(0.f, 1.f, 0.f));
 
            void generateModel(const bool recursive = true) const;
 
            NodePtr scene_data;
 
            void* user_data = 0;
 
            bool is_active = true;
 
            std::string name = "";
 
            AABB raw_aabb;
 
            NodePtr parent;
 
            std::vector<NodePtr> children;
 
            mutable AABB aabb;
        private:
            void _remove_child(const NodePtr& child) noexcept
            {
                // Remove child from children list
                auto it = find(children.begin(), children.end(), child);
 
                if (it != children.end())
                {
                    children.erase(it);
                }
 
                child->forceDirty(true);
            }
 
            mutable glm::mat4 _model_matrix = glm::mat4(1.0f);
 
            mutable glm::mat4 _absolute_model_matrix = glm::mat4(1.0f);
 
            NodePtr _internal_search(
                const std::vector<std::string>::iterator& begin,
                const std::vector<std::string>::iterator& end
            ) noexcept;
 
            bool _has_dirty_parents() const;
 
            NodePtr _fetch_dirty_parent() const;
    };
 
    //using Node = GenericNode<?>;
 
}
 
#endif