scene.h

#ifndef OE_SCENE_MANAGER_H
#define OE_SCENE_MANAGER_H
 
#include <atomic>
#include <vector>
#include <map>
 
#include "node.h"
#include "node_ptr.h"
#include "camera.h"
 
namespace oe::scene
{
    class Scene
    {
        public:

            Scene();

            Scene(const Camera& camera);

            NodePtr addNode()
            {
                Node node({
                    .scene = this,
                    .id_node = _next_node_id++
                });
 
                _nodes.push_back(node);
 
                return node.scene_data;
            }

            NodePtr addNamedNode(const std::string& name)
            {
                NodePtr result = addNode();
                result->name = name;
 
                return result;
            }

            Node* getNodeById(uint64_t id_node)
            {
                // Search into the node vector
                // Todo ensure the node vector is always sorted
                for (auto& it : _nodes)
                {
                    if (it.scene_data.id_node == id_node)
                    {
                        return &it;
                    }
                }
 
                return nullptr;
            }

            const Node* getNodeById(uint64_t id_node) const
            {
                // Search into the node vector
                // Todo ensure the node vector is always sorted
                for (auto& it : _nodes)
                {
                    if (it.scene_data.id_node == id_node)
                    {
                        return &it;
                    }
                }
 
                return nullptr;
            }
 
            /*
             * @brief Remove a node and all of its children from the scene
             *
             * @param node the node to remove
             */
            void deleteNode(NodePtr node)
            {
                // Check if the node belong to this scene
                if (node.scene != this) [[unlikely]]
                {
                    throw std::invalid_argument("Node not part of the current scene!");
                }
 
                // Remove all node children
                for (const auto child : node->children)
                {
                    deleteNode(child);
                }
 
                removeNodeFromAllGroups(node);
 
                _nodes.erase(std::remove_if(
                    _nodes.begin(),
                    _nodes.end(),
                    [&node](Node& n) { return n.scene_data == node; }
                ), _nodes.end());
            }

            const std::vector<NodePtr> getAllNodes() const
            {
                std::vector<NodePtr> result;
 
                result.reserve(_nodes.size());
 
                for (auto& it: _nodes)
                {
                    result.push_back(it.scene_data);
                }
 
                return result;
            }

            const std::vector<NodePtr> getRootNodes() const
            {
                std::vector<NodePtr> result;
 
                for (const Node& node : _nodes)
                {
                    if (!node.parent)
                    {
                        result.push_back(node.scene_data);
                    }
                }
 
                return result;
            }

            NodePtr search(const std::string path, const std::string separator = "/") const
            {
                if (path == "")
                {
                    return {};
                }
 
                auto root_nodes = getRootNodes();
 
                for (auto it : root_nodes)
                {
                    NodePtr result = it->searchFromThisNode(path, separator);
 
                    if (result != false)
                    {
                        return result;
                    }
                }
 
                return {};
            }

            template <typename ComponentType>
            void setCameraFromComponent(ComponentType& component)
            {
                setCamera(component.getCamera());
            }

            void resetCameraToDefault()
            {
                camera = &default_camera;
            }

            void addNodeInGroup(NodePtr node, const NodeType type)
            {
                if (node.scene != this) [[unlikely]]
                {
                    throw std::invalid_argument("Node not part of the current scene!");
                }
 
                if (_node_types.count(type) == 0)
                {
                    _node_types[type] = {};
                }
 
                _node_types[type].push_back(node);
            }

            std::vector<NodePtr> getNodesByType(const NodeType type) const
            {
                if (_node_types.count(type) == 0)
                {
                    return {};
                }
 
                return _node_types.at(type);
            }

            void removeNodeFromGroup(NodePtr node, const NodeType type)
            {
                if (node.scene != this) [[unlikely]]
                {
                    throw std::invalid_argument("Node not part of the current scene!");
                }
 
                if (_node_types.count(type) == 0)
                {
                    return;
                }
 
                auto& nodes_by_this_type = _node_types[type];
 
                auto it = std::find(nodes_by_this_type.begin(), nodes_by_this_type.end(), node);
 
                if (it == nodes_by_this_type.end())
                {
                    return;
                }
 
                nodes_by_this_type.erase(it);
            }

            void removeNodeFromAllGroups(NodePtr node)
            {
                for (auto& it : _node_types)
                {
                    removeNodeFromGroup(node, it.first);
                }
            }
 
            Camera default_camera;
 
            /* TODO: remove this pointer and rename default_camera to camera */
            Camera* camera = nullptr;

            void* user_data = 0;
 
        private:
            std::map<NodeType, std::vector<NodePtr>> _node_types;
            std::vector<Node> _nodes;
 
            std::atomic<uint64_t> _next_node_id = 1;
    };
}
 
#endif