apprunner.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 "app.h"
#include "appeventhandler.h"
 
// External Includes
#include <rtti/typeinfo.h>
#include <nap/core.h>
#include <nap/timer.h>
#include <nap/logger.h>
#include <thread>
 
namespace nap
{
    template<typename APP, typename HANDLER>
    class AppRunner
    {
        RTTI_ENABLE()
    public:
        AppRunner(nap::Core& core);
 
        AppRunner(nap::Core& core, const std::string& projectInfo, ProjectInfo::EContext context);
        
        virtual ~AppRunner();
 
        AppRunner(AppRunner&) = delete;
        AppRunner& operator=(const AppRunner&) = delete;
 
        AppRunner(AppRunner&&) = delete;
        AppRunner& operator=(AppRunner&&) = delete;
 
        bool start(utility::ErrorState& error);
 
        void stop();
 
        APP& getApp();
 
        HANDLER& getHandler();
 
        int exitCode() const                                { return mExitCode; }
 
    private:
        nap::Core&                  mCore;                  // Core
        std::unique_ptr<APP>        mApp = nullptr;         // App this runner works with
        std::unique_ptr<HANDLER>    mHandler = nullptr;     // App handler this runner works with
        std::atomic<bool>           mStop = { false };      // If the runner should stop
        int                         mExitCode = 0;          // Application exit code* Call update() to force an update.
        std::string                 mProjectInfo;           // Optional application project information
        ProjectInfo::EContext       mProjectContext;        // Optional application context information
    };
 
 
    // Template definitions
 
    template<typename APP, typename HANDLER>
    APP& nap::AppRunner<APP, HANDLER>::getApp()
    {
        return *mApp;
    }
 
 
    template<typename APP, typename HANDLER>
    HANDLER& nap::AppRunner<APP, HANDLER>::getHandler()
    {
        return *mHandler;
    }
 
 
    template<typename APP, typename HANDLER>
    nap::AppRunner<APP, HANDLER>::AppRunner(nap::Core& core) : mCore(core)
    {
        // Create app and handler
        mApp = std::make_unique<APP>(core);
        mHandler = std::make_unique<HANDLER>(*mApp);
    }
 
 
 
    template<typename APP, typename HANDLER>
    nap::AppRunner<APP, HANDLER>::AppRunner(nap::Core& core, const std::string& projectInfo, ProjectInfo::EContext context) :
        nap::AppRunner<APP, HANDLER>(core)
    {
        this->mProjectInfo = projectInfo;
        this->mProjectContext = context;
    }
 
 
    template<typename APP, typename HANDLER>
    bool nap::AppRunner<APP, HANDLER>::start(utility::ErrorState& error)
    {
        nap::BaseApp& app = getApp();
        nap::AppEventHandler& app_event_handler = getHandler();
 
        // Initialize engine
        bool initialized = !this->mProjectInfo.empty() ?
            mCore.initializeEngine(this->mProjectInfo, this->mProjectContext, error) :
            mCore.initializeEngine(error);
 
        if (!error.check(initialized, "Unable to initialize engine"))
            return false;
 
        // Initialize the various services
        // Bail if handle is invalid, this means service initialization failed
        Core::ServicesHandle handle = mCore.initializeServices(error);
        if (handle == nullptr)
            return false;
 
        // Change current working directory to directory that contains the data file
        // TODO: Remove! setting cwd is not thread safe - make thread local or resolve local
        std::string data_dir = mCore.getProjectInfo()->getDataDirectory();
        utility::changeDir(data_dir);
        nap::Logger::info("Current working directory: % s", data_dir.c_str());
 
        // Ensure project data is available
        if (!error.check(!mCore.getProjectInfo()->mDefaultData.empty(), "Missing project data, %s 'Data' field is empty",
            mCore.getProjectInfo()->getProjectDir().c_str()))
            return false;
 
        // Load project data
        std::string data_file = utility::getFileName(mCore.getProjectInfo()->getDataFile());
        nap::Logger::info("Loading data: %s", data_file.c_str());
        if (!error.check(mCore.getResourceManager()->loadFile(data_file, error), "Failed to load data: %s", data_file.c_str()))
            return false;
 
        // Watch the data directory
        mCore.getResourceManager()->watchDirectory(data_dir);
 
        // Initialize application
        if(!error.check(app.init(error), "Unable to initialize application"))
            return false;
 
        // Start event handler
        app_event_handler.start();
 
        // Pointer to function used inside update call by core
        std::function<void(double)> update_call = std::bind(&APP::update, mApp.get(), std::placeholders::_1);
 
        // Start core
        mCore.start();
 
        // Begin running
        SteadyTimer timer; timer.start();
        Milliseconds frame_time, delay_time, zero_delay(0);
        while (!app.shouldQuit() && !mStop)
        {
            // Get point in time when frame is requested to be completed
            frame_time = timer.getMillis() + (app.framerateCapped() ? 
                Milliseconds(static_cast<long>(1000.0 / static_cast<double>(app.getRequestedFramerate()))) :
                zero_delay);
             
            // Process app specific messages
            app_event_handler.process();
 
            // Update services & application
            mCore.update(update_call);
 
            // Render
            app.render();
 
            // Only sleep when there is at least 1 millisecond that needs to be compensated for
            // The actual outcome of the sleep call can vary greatly from system to system
            // And is more accurate with lower framerate limitations
            delay_time = frame_time - timer.getMillis();
            if(delay_time.count() > 0)
                std::this_thread::sleep_for(delay_time);
        }
 
        // Stop handling events
        app_event_handler.shutdown();
 
        // Shutdown
        mExitCode = app.shutdown();
 
        // Message successful exit
        return true;
    }
 
 
    template<typename APP, typename HANDLER>
    void nap::AppRunner<APP, HANDLER>::stop()
    {
        mStop = true;
    }
 
 
    template<typename APP, typename HANDLER>
    nap::AppRunner<APP, HANDLER>::~AppRunner()
    {
        // First clear the handler as it points to our app
        mHandler.reset();
 
        // Now clear the app
        mApp.reset();
    }
}