SystemManager.h

Go to the documentation of this file.

/*
    Author : Tobias Stein
    Date   : 13th July, 2016
    File   : SystemManager.h
    
    Manager class for systems
 
    All Rights Reserved. (c) Copyright 2016.
*/
 
#pragma once
#ifndef ECS__SYSTEM_MANAGER_H__
#define ECS__SYSTEM_MANAGER_H__
 
#include "API.h"
#include "Engine.h"
 
#include "ISystem.h"
 
#include "Memory/Allocator/LinearAllocator.h"
#include "util/FamilyTypeID.h"
 
 
 
namespace ECS
{
    using SystemWorkStateMask   = eastl::vector<bool>;
 
 
    class ECS_API SystemManager : Memory::GlobalMemoryUser
    {
        friend ECSEngine;
 
        DECLARE_LOGGER
 
    private:
 
        using SystemDependencyMatrix = eastl::vector<eastl::vector<bool>>;
 
        using SystemRegistry    = eastl::unordered_map<u64, ISystem*>;
        using SystemAllocator   = Memory::Allocator::LinearAllocator;
 
        using SystemWorkOrder   = eastl::vector<ISystem*>;
 
        SystemAllocator*        m_SystemAllocator;
 
        SystemRegistry          m_Systems;
 
        SystemDependencyMatrix  m_SystemDependencyMatrix;
 
        SystemWorkOrder         m_SystemWorkOrder;
 
        // This class is not inteeded to be initialized
        SystemManager(const SystemManager&) = delete;
        SystemManager& operator=(SystemManager&) = delete;  
 
 
        void PreUpdate(f32 dt_ms);
        void Update(f32 dt_ms);
        void PostUpdate(f32 dt_ms);
        void OnFrameStart();
        void OnFrameEnd();
 
    public:
 
        SystemManager();
        ~SystemManager() override;
 
        template<class Predicate>
        void ForEachSystem(Predicate&& pred)
        {
            for (ISystem* system : this->m_SystemWorkOrder)
            {
                pred(system);
            }
        }
 
 
        template<class T, class... ARGS>
        T* AddSystem(ECSEngine& engine, ARGS&&... systemArgs)
        {
            const u64 STID = T::STATIC_SYSTEM_TYPE_ID;
 
 
            // avoid multiple registrations of the same system
            auto it = this->m_Systems.find(STID);
            if ((this->m_Systems.find(STID) != this->m_Systems.end()) && (it->second != nullptr))
                return (T*)it->second;
 
            T* system = nullptr;
            void* pSystemMem = this->m_SystemAllocator->allocate(sizeof(T), alignof(T));
            if (pSystemMem != nullptr)
            {
 
                ((T*)pSystemMem)->m_SystemManagerInstance = this;
 
                // create new system
                system = new (pSystemMem)T(engine, std::forward<ARGS>(systemArgs)...);
                this->m_Systems[STID] = system;
 
                LOG_INFO("System \'{}\' ({} bytes) created.", typeid(T).name(), sizeof(T));
            }
            else
            {
                LOG_ERROR("Unable to create system \'{}\' ({} bytes).", typeid(T).name(), sizeof(T));
                assert(true);
            }
 
            // resize dependency matrix
            if (STID + 1 > this->m_SystemDependencyMatrix.size())
            {
                this->m_SystemDependencyMatrix.resize(STID + 1);
                for (size_t i = 0u; i < this->m_SystemDependencyMatrix.size(); ++i)
                    this->m_SystemDependencyMatrix[i].resize(STID + 1);
            }
 
            // add to work list
            this->m_SystemWorkOrder.push_back(system);
            
            return system;
        }
 
 
        template<class System_, class Dependency_>
        void AddSystemDependency(System_ target, Dependency_ dependency)
        {
            const u64 TARGET_ID = target->GetStaticSystemTypeID();
            const u64 DEPEND_ID = dependency->GetStaticSystemTypeID();
 
            if (this->m_SystemDependencyMatrix[TARGET_ID][DEPEND_ID] != true)
            {
                this->m_SystemDependencyMatrix[TARGET_ID][DEPEND_ID] = true;
                LOG_INFO("added '{}' as dependency to '{}'", dependency->GetSystemTypeName(), target->GetSystemTypeName());
            }
 
            //this->UpdateSystemWorkOrder();
        }
 
        template<class Target_, class Dependency_, class... Dependencies>
        void AddSystemDependency(Target_ target, Dependency_ dependency, Dependencies&&... dependencies)
        {
            const u64 TARGET_ID = target->GetStaticSystemTypeID();
            const u64 DEPEND_ID = dependency->GetStaticSystemTypeID();
 
            if (this->m_SystemDependencyMatrix[TARGET_ID][DEPEND_ID] != true)
            {
                this->m_SystemDependencyMatrix[TARGET_ID][DEPEND_ID] = true;
                LOG_INFO("added '{}' as dependency to '{}'", dependency->GetSystemTypeName(), target->GetSystemTypeName());
            }
 
            this->AddSystemDependency(target, FWD(dependencies)...);
        }
 
 
        void UpdateSystemWorkOrder();
 
 
        template<class T>
        inline T* GetSystem() const
        {
            auto it = this->m_Systems.find(T::STATIC_SYSTEM_TYPE_ID);
 
            return it != this->m_Systems.end() ? (T*)it->second : nullptr;
        }
 
 
        template<class T>
        void EnableSystem()
        {
            const SystemTypeId STID = T::STATIC_SYSTEM_TYPE_ID;
 
            // get system
            auto it = this->m_Systems.find(STID);
            if (it != this->m_Systems.end())
            {   
                if (it->second->m_Enabled == true)
                    return;
 
                // enable system
                it->second->m_Enabled = true;
            }
            else
            {
                LOG_WARNING("Trying to enable system [{}], but system is not registered yet.", STID);
            }
        }
 
 
        template<class T>
        void DisableSystem()
        {
            const SystemTypeId STID = T::STATIC_SYSTEM_TYPE_ID;
 
            // get system
            auto it = this->m_Systems.find(STID);
            if (it != this->m_Systems.end())
            {
                if (it->second->m_Enabled == false)
                    return;
 
                // enable system
                it->second->m_Enabled = false;
            }
            else
            {
                LOG_WARNING("Trying to disable system [{}], but system is not registered yet.", STID);
            }
        }
 
        template<class T>
        void SetSystemUpdateInterval(f32 interval_ms)
        {
            const SystemTypeId STID = T::STATIC_SYSTEM_TYPE_ID;
 
            // get system
            auto it = this->m_Systems.find(STID);
            if (it != this->m_Systems.end())
            {
                it->second->m_UpdateInterval = interval_ms;
            }
            else
            {
                LOG_WARNING("Trying to change system's [{}] update interval, but system is not registered yet.", STID);
            }
        }
 
        template<class T>
        void SetSystemPriority(SystemPriority newPriority)
        {
            const SystemTypeId STID = T::STATIC_SYSTEM_TYPE_ID;
 
            // get system
            auto it = this->m_Systems.find(STID);
            if (it != this->m_Systems.end())
            {
                SystemPriority oldPriority = it->second->m_Priority;
 
                if (oldPriority == newPriority)
                    return;
                
                it->second->m_Priority = newPriority;
 
                // re-build system work order
                //this->UpdateSystemWorkOrder();
            }
            else
            {
                LOG_WARNING("Trying to change system's [{}] priority, but system is not registered yet.", STID);
            }
        }
 
 
        SystemWorkStateMask GetSystemWorkState() const;
 
 
        void SetSystemWorkState(SystemWorkStateMask mask);
 
        template<class... ActiveSystems>
        SystemWorkStateMask GenerateActiveSystemWorkState(ActiveSystems&&... activeSystems)
        {
            SystemWorkStateMask mask(this->m_SystemWorkOrder.size(), false);
 
            eastl::list<ISystem*> AS = { activeSystems... };
            for (auto s : AS)
            {
                for (int i = 0; i < this->m_SystemWorkOrder.size(); ++i)
                {
                    if (this->m_SystemWorkOrder[i]->GetStaticSystemTypeID() == s->GetStaticSystemTypeID())
                    {
                        mask[i] = true;
                        break;
                    }
                }
            }
 
            return mask;
        }
    };
 
} // namespace ECS
 
#endif // ECS__SYSTEM_MANAGER_H__