.. _program_listing_file_PrismEngine_src_scene.h:

Program Listing for File scene.h
================================

|exhale_lsh| :ref:`Return to documentation for file <file_PrismEngine_src_scene.h>` (``PrismEngine/src/scene.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #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;  
           };
       }
   }