SceneManager.hpp

#pragma once
#ifndef __H__OCULAR_CORE_SCENE_MANAGER__H__
#define __H__OCULAR_CORE_SCENE_MANAGER__H__

#include "Scene.hpp"
#include "SceneObject.hpp"
#include "SceneTreeType.hpp"
#include "Renderer/Renderer.hpp"
#include "ComponentFactory.hpp"
#include "FileIO/File.hpp"
#include "Math/Geometry/Frustum.hpp"

#include <unordered_map>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    // Forward Declaration

    class Engine;

    namespace Core
    {
        class SceneManager
        {
            friend class Engine;
            friend class SceneObject;
            friend class ARoutine;

        public:

            SceneManager();
            ~SceneManager();

            //------------------------------------------------------------------------------
            // SceneObject Methods

            SceneObject* createObject(std::string const& name = "Unnamed", SceneObject* parent = nullptr);

            template<class T>
            T* createObject(std::string const& name = "Unnamed", SceneObject* parent = nullptr)
            {
                T* result = new T(name, parent);
                addObject(result);

                return result;
            }

            SceneObject* createObjectOfType(std::string const& type, std::string const& name = "Unnamed", SceneObject* parent = nullptr);

            SceneObject* duplicateObject(SceneObject const* object);

            void destroyObject(SceneObject* object);

            void destroyObject(std::string const& name, bool removeAll = false);

            void destroyObject(UUID const& uuid);

            SceneObject* findObject(std::string const& name) const;

            void findObjects(std::string const& name, std::vector<SceneObject*>& objects) const;
            
            SceneObject* findObject(UUID const& uuid) const;

            void findTopObjects(std::vector<SceneObject*>& object) const;

            void updateUUID(UUID const& uuid);

            void getVisibleSceneObjects(std::vector<SceneObject*>& objects, Math::Frustum const& frustum);

            void triggerObjectDirty(UUID const& uuid, bool staticObject);

            //------------------------------------------------------------------------------
            // Scene Methods

            void createScene(std::string const& name, SceneTreeType staticType = SceneTreeType::BoundingVolumeHierarchyCPU, SceneTreeType dynamicType = SceneTreeType::BoundingVolumeHierarchyCPU);

            bool loadScene(File const& file);

            bool saveScene(File const& file);

            bool isSceneActive() const;

            ComponentFactory<ARoutine>& getRoutineFactory();

            ComponentFactory<ARenderable>& getRenderableFactory();

            ComponentFactory<SceneObject>& getSceneObjectFactory();

            ComponentFactory<Renderer>& getRendererFactory();

        protected:

            void loadPersistentObjects();

            void addObject(SceneObject* object, SceneObject* parent = nullptr);

            void unloadScene();

            void update();

            void render();

            void objectActiveChanged(SceneObject* object);

            void objectVisibleChanged(SceneObject* object);

            void objectStaticChanged(SceneObject* object);

            void objectAddedRoutine(ARoutine* routine);

            void objectRemovedRoutine(ARoutine* routine);

            void objectParentChanged(SceneObject* object, SceneObject* oldParent);

        private:

            void deleteObject(SceneObject* object);

            std::unordered_map<std::string, SceneObject*> m_Objects;    
            Scene* m_Scene;

            ComponentFactory<ARoutine>    m_RoutineFactory;
            ComponentFactory<ARenderable> m_RenderableFactory;
            ComponentFactory<SceneObject> m_SceneObjectFactory;
            ComponentFactory<Renderer>    m_RendererFactory;
        };
    }
}
//------------------------------------------------------------------------------------------

#endif