app.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
 
// External includes
#include <rtti/typeinfo.h>
#include <inputevent.h>
#include <utility/errorstate.h>
#include <nap/core.h>
#include <windowevent.h>
#include <mathutils.h>
 
namespace nap
{
    class NAPAPI BaseApp
    {
        RTTI_ENABLE()
    public:
        // Default Constructor
        BaseApp(nap::Core& core);
 
        // Default Destructor
        virtual ~BaseApp() = default;
 
        BaseApp(BaseApp&) = delete;
        BaseApp& operator=(const BaseApp&) = delete;
 
        BaseApp(BaseApp&&) = delete;
        BaseApp& operator=(BaseApp&&) = delete;
 
        virtual bool init(utility::ErrorState& error)                   { return true; }
        
        virtual void update(double deltaTime)                           { }
 
 
        virtual void render()                                           { }
 
        virtual bool shutdownRequested()                                { return true; }
 
        virtual int shutdown()                                          { return 0; }
 
        void quit()                                                     { mQuit = true; }
 
        const nap::Core& getCore() const                                { return mCore; }
 
        nap::Core& getCore()                                            { return mCore; }
 
        bool shouldQuit() const                                         { return mQuit; }
 
        void capFramerate(bool value)                                   { mCapFramerate = value; }
 
        void setFramerate(float framerate)                              { mRequestedFramerate = math::max<float>(framerate, 1.0f); }
 
        float getRequestedFramerate() const                             { return mRequestedFramerate; }
 
        float getActualFramerate() const                                { return mCore.getFramerate(); }
 
        bool framerateCapped() const                                    { return mCapFramerate; }
 
    private:
        bool mQuit = false;                                             // When set to true the application will exit
        nap::Core& mCore;                                               // Core
        float mRequestedFramerate = 60.0f;                              // Requested framerate, only applied when mCapFramerate is enabled.
        bool mCapFramerate = false;                                     // If the framerate should be capped.
    };
 
 
    class NAPAPI App : public BaseApp
    {
        RTTI_ENABLE(BaseApp)
    public:
        App(Core& core);
 
        virtual void inputMessageReceived(InputEventPtr inputEvent)     { }
 
        virtual void windowMessageReceived(WindowEventPtr windowEvent)  { }
    };
}