manager.h

#ifndef OE_SCENE_MANAGER_H
#define OE_SCENE_MANAGER_H
 
#include "../common.h"
 
#include <vector>
#include <map>
 
#include "node.h"
#include "camera.h"
#include "component/scene.h"
 
namespace oe::scene
{
    class Manager : public oe::component::HasComponents<Manager, SceneComponent>
    {
        public:
 
            Manager();
 
            Manager(const Camera& camera);
 
            template <typename T = Node, typename... Args>
            T& addNode(Args&&... args)
            {
                std::shared_ptr<T> result = std::make_shared<T>(std::forward<Args>(args)...);
                result->_manager = this;
 
                _nodes.push_back(result);
 
                T* ptr = result.get();
 
                _root_nodes.push_back(ptr);
 
                _notify_components_of_node_add(*result);
 
                return *result;
            }
 
            template <typename T = Node, typename... Args>
            T& addNamedNode(const std::string& name, Args&&... args)
            {
                T& result = addNode<T>(std::forward<Args>(args)...);
                result.name = name;
 
                return result;
            }
 
            void addChildNodeToParent(Node& child, Node* parent);
 
            void deleteNode(Node& node);
 
            const std::vector<std::shared_ptr<Node>>& getAllNodes() const;
 
            const std::vector<Node*>& getRootNodes() const
            {
                return _root_nodes;
            }
 
            template <typename T = Node>
            T* search(const std::string path, const std::string separator = "/") const
            {
                for (auto it : _root_nodes)
                {
                    T* result = it->search<T>(path, separator);
 
                    if (result != nullptr)
                        return result;
                }
 
                return nullptr;
            }
 
            Camera& getCamera();
 
            void setCamera(Camera& camera);
 
            void setCamera(Node& node);
 
            void setCamera(Node& node, const std::string& component_name);
 
            template <typename ComponentType>
            void setCameraFromComponent(ComponentType& component)
            {
                setCamera(component.getCamera());
            }
 
            Camera& getDefaultCamera();
 
            void resetCameraToDefault();
 
            void addNodeInGroup(Node& node, const NodeType type);
 
            std::vector<Node*> getNodesByType(const NodeType type) const;
 
            void removeNodeFromGroup(Node& node, const NodeType type);
 
            void removeNodeFromAllGroups(Node& node);
 
            void update(const double delta, const int8_t flags = 0);
 
        private:
            std::map<NodeType, std::vector<Node*>> _node_types;
 
            std::vector<Node*> _root_nodes;
 
            std::vector<std::shared_ptr<Node>> _nodes;
 
            Camera _default_camera;
 
            std::reference_wrapper<Camera> _camera;
 
            void _notify_components_of_node_add(Node& node);
            void _notify_components_of_node_remove(Node& node);
    };
}
 
#endif