Program Listing for File scene.h

↰ Return to documentation for file (PrismEngine/src/scene.h)

#pragma once
#pragma once
#include <cstdint>
#include <memory>
#include <unordered_map>
#include <vector>
#include <typeindex>
#include <set>
#include <queue>
#include "entityManager.h"
#include "componentManager.h"
#include "systemManager.h"
#include "resourceManager.h"


namespace prism {
    namespace scene {
        class Scene
        {
        public:
            Scene() = default;

            Entity createEntity();

            bool destroyEntity(Entity entityId);

            void enableSystem(SystemId systemId);

            void disableSystem(SystemId systemId);

            void update() {
                systemManager.update();
            }

            // шаблонные методы определены здесь в .h (по-другому не компилится)

            template<typename T>
            bool addComponent(Entity entityId, T&& component) {
                return componentManager.addComponent(entityId, std::forward<T>(component));
            };

            template<typename T>
            bool removeComponent(Entity entityId) {
                return componentManager.removeComponent<T>(entityId);
            };

            template<typename T>
            T* getComponent(Entity entityId) {
                return componentManager.getComponent<T>(entityId);
            };

            template<typename T>
            const std::vector<Entity>& getEntitiesWith() const {
                return componentManager.getEntitiesWith<T>();
            };

            template<typename... ComponentTypes>
            std::vector<Entity> getEntitiesWithAll() const {
                return componentManager.getEntitiesWithAll<ComponentTypes...>();
            };

            template<typename T, typename... Args>
            SystemId registerSystem(Args&&... args) {
                return systemManager.registerSystem<T>(std::forward<Args>(args)...);
            };

            template<typename T>
            void setResource(T resource) {
                resourceManager.set<T>(resource);
            }

            template<typename T>
            T* getResource() {
                return resourceManager.get<T>();
            }

            template<typename T>
            const T* getResource() const {
                return resourceManager.get<T>();
            }

            template<typename T>
            bool hasResource() const {
                return resourceManager.has<T>();
            }

            template<typename T>
            bool removeResource() {
                return resourceManager.remove<T>();
            }
        private:
            EntityManager entityManager;
            ComponentManager componentManager;
            SystemManager systemManager;
            ResourceManager resourceManager;
        };
    }
}