core.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "modulemanager.h"
#include "resourcemanager.h"
#include "service.h"
#include "coreextension.h"
#include "projectinfo.h"
#include "timer.h"
 
// External Includes
#include <rtti/factory.h>
#include <rtti/rtti.h>
#include <rtti/deserializeresult.h>
#include <unordered_set>
#include <utility/dllexport.h>
#include <unordered_map>
#include <vector>
 
// Default name to use when writing the file that contains all the settings for the NAP services.
inline constexpr char DEFAULT_SERVICE_CONFIG_FILENAME[] = "config.json";
inline constexpr char PROJECT_INFO_FILENAME[] = "project.json";
 
// Build configuration eg. "Clang-Debug-x86_64"
#define STRINGIZE(x) #x
#define STRINGIZE_VALUE_OF(x) STRINGIZE(x)
inline constexpr char sBuildConf[] = STRINGIZE_VALUE_OF(NAP_BUILD_CONF);
inline constexpr char sBuildType[] = STRINGIZE_VALUE_OF(NAP_BUILD_TYPE);
inline constexpr char sBuildArch[] = STRINGIZE_VALUE_OF(NAP_BUILD_ARCH);
 
namespace nap
{
    using ServiceConfigMap = std::unordered_map<rtti::TypeInfo, ServiceConfiguration*>;
 
    class NAPAPI Core final
    {
        RTTI_ENABLE()
    public:
        // Unique services handle.
        // Ensures services are destroyed after being initialized.
        class Services;
        using ServicesHandle = std::unique_ptr<Services>;
 
        Core();
 
        Core(std::unique_ptr<CoreExtension> coreExtension);
 
        virtual ~Core();
 
        bool initializeEngine(utility::ErrorState& error);
 
        bool initializeEngine(const std::string& projectInfofile, ProjectInfo::EContext context, utility::ErrorState& error);
 
        Core::ServicesHandle initializeServices(utility::ErrorState& errorState);
 
        bool isInitialized() const;
 
        bool initializePython(utility::ErrorState& error);
 
        void start();
 
        double update(std::function<void(double)>& updateFunction);
 
        ResourceManager* getResourceManager()                           { return mResourceManager.get(); }
 
        const ModuleManager& getModuleManager() const                   { return *mModuleManager; }
 
        uint32 getTicks() const;
 
        double getElapsedTime() const;
 
        SteadyTimeStamp getStartTime() const;
 
        float getFramerate() const                                      { return mFramerate; }
 
        Service* getService(const rtti::TypeInfo& type);
 
        const Service* getService(const rtti::TypeInfo& type) const;
 
        Service* getService(const std::string& type);
 
        template <typename T>
        T* getService();
 
        template <typename T>
        const T* getService() const;
 
        template <typename T>
        const T& getExtension() const;
 
        template <typename T>
        bool hasExtension() const;
 
        bool findProjectFilePath(const std::string& filename, std::string& foundFilePath) const;
 
        const nap::ProjectInfo* getProjectInfo() const;
 
        bool loadPathMapping(nap::ProjectInfo& projectInfo, nap::utility::ErrorState& err);
 
        bool writeConfigFile(const std::string& path, utility::ErrorState& errorState, bool linkToProjectInfo = true);
 
        std::vector<const ServiceConfiguration*> getServiceConfigs() const;
 
        void setupPlatformSpecificEnvironment();
 
        class NAPAPI Services final
        {
        public:
            ~Services();
 
            bool initialized()  { return mInitialized;  }
 
        private:
            friend class Core;
            Services(Core& core, utility::ErrorState& error);
            nap::Core& mCore;
            bool mInitialized = false;
        };
 
    private:
        bool findProjectInfoFile(std::string& foundFilePath) const;
 
        bool createServices(const nap::ProjectInfo& projectInfo, utility::ErrorState& errorState);
 
        bool addService(const rtti::TypeInfo& type, ServiceConfiguration* configuration, std::vector<Service*>& outServices, utility::ErrorState& errorState);
 
        bool loadServiceConfigurations(nap::utility::ErrorState& err);
 
        bool loadServiceConfiguration(const std::string& filename, rtti::DeserializeResult& deserialize_result, utility::ErrorState& errorState);
 
        void preResourcesLoaded();
 
        void postResourcesLoaded();
 
        void calculateFramerate(double deltaTime);
 
        void setupPythonEnvironment();
 
        bool loadProjectInfo(std::string projectFilename, ProjectInfo::EContext context, nap::utility::ErrorState& error);
 
        nap::ServiceConfiguration* findServiceConfig(rtti::TypeInfo serviceType) const;
 
        bool addServiceConfig(std::unique_ptr<nap::ServiceConfiguration> serviceConfig);
 
        // Manages all the loaded modules
        std::unique_ptr<ModuleManager> mModuleManager = nullptr;
 
        // Manages all the objects in core
        std::unique_ptr<ResourceManager> mResourceManager = nullptr;
 
        // Holds on to the current project's configuration
        std::unique_ptr<nap::ProjectInfo> mProjectInfo = nullptr;
 
        // Sorted service nodes, set after init
        std::vector<std::unique_ptr<Service>> mServices;
 
        // All service configurations
        std::unordered_map<rtti::TypeInfo, std::unique_ptr<ServiceConfiguration>> mServiceConfigs;
 
        // Interface associated with this instance of core.
        std::unique_ptr<CoreExtension> mExtension = nullptr;
 
        // Frame reference point
        SteadyTimeStamp mTimeStamp;
 
        // Core timer
        SteadyTimer mTimer;
 
        // Current framerate
        float mFramerate = 0.0f;
 
        // Used to calculate framerate over time
        std::array<double, 20> mTicks = { 0 };
        double mTicksum = 0;
        uint32 mTickIdx = 0;
 
        // If the engine is initialized
        bool mInitialized = false;
 
        // Called before resources are loaded
        nap::Slot<> mPreResourcesLoadedSlot     = { [&]() -> void { preResourcesLoaded();  } };
 
        // Called after resources are loaded
        nap::Slot<> mPostResourcesLoadedSlot    = { [&]() -> void { postResourcesLoaded(); } };
    };
}
 
// Template definitions
 
template <typename T>
T* nap::Core::getService()
{
    return static_cast<T*>(getService(RTTI_OF(T)));
}
 
 
template <typename T>
const T* nap::Core::getService() const
{
    return static_cast<const T*>(getService(RTTI_OF(T)));
}
 
 
template <typename T>
const T& nap::Core::getExtension() const
{
    T* core_ext = rtti_cast<T>(mExtension.get());
    assert(core_ext != nullptr);
    return *core_ext;
}
 
 
template <typename T>
bool nap::Core::hasExtension() const
{
    return rtti_cast<T>(mExtension.get()) != nullptr;
}