fsCAppCoreMain.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsCAppCoreMain.h
*
*       Purpose:        Main for an app
*
*********************************************************************/
 
#ifndef fsCAppCoreMainhdr
#define fsCAppCoreMainhdr
 
#include <memory>
 
#include <fsCore/fsBaseTypes.h>
#include <fsCore/fsStr.h>
 
#include "components/gui/fsCLocaleOptions.h"
 
class fsINode;
class fsStr;
class fsIScene;
class fsIDisplay;
class fsCEntity;
class fsCEntityFactory;
class fsCComponentFactory;
class fsCResourceName;
class fsCAppSettings;
class fsIHardware;
class fsCParticleDataManager;
class fsCAnimationDataManager;
class fsCScreenFade;
class fsCAppTimer;
class fsCRenderTexture;
class fsICursor;
class fsRect;
struct fsVec2d;
struct fsPoint;
 
#if defined fsReview
    class gfCNagManager;
#endif
 
class fsCAppCoreMain
{
public:
 
#if defined fsScreenTextureEffect
        fsCRenderTexture* mLevelRenderTarget = nullptr;         // not smart pointer due to include cycles?
        #ifdef fsDEBUG
                fsBool mTargetClearedThisFrame = false;
        #endif
#endif
 
 
        static const fsStr mRootEntityName;
 
#if defined fsScreenTextureEffect       
        void renderTargetResize();
        void renderTargetShadersCreate(const fsStr& pVertex, const fsStr& pFragment);
        void renderTargetScreenEffectParamsSet(const fsPoint& pFocusPos, fsF32 pRadius);
        void renderTargetScreenEffectParamsClear();
        void renderTargetCaptureRegionSaveRequest(const fsRect& pCaptureRect, const fsPoint& pOutputDimensions, const fsCResourceName& pFilename);
        void renderTargetCaptureFocusRegionSaveRequest(const fsPoint& pFocusPos, fsF32 pRadius, const fsPoint& pOutputDimensions, const fsCResourceName& pFilename);
                #if defined fsScreenShot
                        void screenshotRequest(const fsStr& pSceneName);
                #endif
#endif  
 
        void setRenderToTexture();
        void clearRenderToTexture();
 
#if defined fsReview
    gfCNagManager* nagManagerGet() const;
#endif
 
        fsCLocaleOptions* localeGet();
        void stateSave();
 
        void fadeIn();
        void fadeOut();
        // An auto test is driving - fades and waits meant for a watching player shorten.
        void autoTestSpeedUpSet(fsBool pSet);
        fsBool autoTestSpeedUpGet() const { return mAutoTestSpeedUp; }
 
        fsS32 appRunningTimeGet() const;
        fsCAnimationDataManager* animationManagerGet() const;
        fsCParticleDataManager* particleDataManagerGet() const;
        fsCAppSettings* settingsGet() const;
        fsIHardware* hardwareGet() const;
 
        fsBool update(fsS32 pDeltaMs);
        void render();
 
        static fsCAppCoreMain* instanceGet();
        static void create();
        static void destroy();
 
        fsF32 timeStepGet();
        void timeStepSet(fsF32 pVal);
 
        fsCEntity* sceneRootGet() const;
        fsIScene* sceneGet() const;
        fsIScene* appOverlaySceneGet() const;
        fsIDisplay* displayGet() const;
        fsCEntity* appOverlayEntityNamed(const fsStr& pName) const;
 
        void quitTheAppSet(fsBool pQuit);
 
        void childAddToAppScene(fsINode* pChild);
        void childAddToAppOverlay(fsINode* pChild);
        void splashScreenShow();
        void cursorPosSet(const fsVec2d& pPos);
        fsCComponentFactory* componentFactoryGet() const;
        fsCEntityFactory* entityFactoryGet() const;
 
protected:
 
        virtual void profileManagerCreateDo();
 
        void componentFactorySet(std::shared_ptr<fsCComponentFactory>);
        void entityFactorySet(std::shared_ptr<fsCEntityFactory> pEntityFactory);
 
        virtual void factoriesCreateDo();
 
        virtual void messageDispatchersDestroyDo(){}
 
        virtual void messageDispatchersCreateDo() {}
 
        virtual void preInitialiseDo() {}
 
        virtual void initialiseDo() {}
 
        virtual void postInitialiseDo();
 
        virtual void preUninitialiseDo() {}
 
        virtual void uninitialiseDo() {}
 
        virtual void postUninitialiseDo() {}
 
        virtual void updateDo(fsS32 pDeltaMs);
 
        virtual void stateSaveDo() {}
 
        fsBool launcherRunning();
        virtual fsBool launcherRunningDo() { return false; }
 
        void initialise();
        void uninitialise();
 
        void appSceneCreate();
 
        virtual void debugGuiCreate(){};
 
        // Delete copy operations
        fsCAppCoreMain(const fsCAppCoreMain&) = delete;
        fsCAppCoreMain& operator=(const fsCAppCoreMain&) = delete;
        // Declare move operations
        fsCAppCoreMain(fsCAppCoreMain&&);
        fsCAppCoreMain& operator=(fsCAppCoreMain&&);
        
        fsCAppCoreMain();
        virtual ~fsCAppCoreMain();
 
        static fsCAppCoreMain* mInstance;
 
private:
 
        struct fsSPendingRenderTargetCaptureRequest;
 
        void profileManagerCreate();
 
        void screenFadeCreate();
 
        void factoriesCreate();
 
        void messageDispatchersDestroy();
        void messageDispatchersCreate();
 
        void preInitialise();
        void postInitialise();
 
        void preUninitialise();
        void postUninitialise();
 
        void renderTargetCreate();
        void renderTargetCaptureRequestExecute();
 
        fsCScreenFade* mScreenFade; // ptr as added to display and will be cleaned up
        fsBool mAutoTestSpeedUp;
 
        fsIDisplay* mAppDisplay;
        fsIScene* mAppScene;
        fsIScene* mAppOverlayScene;
        fsICursor* mCursor;
 
        fsStr mLocaleStr;
 
        fsBool mQuitTheApp;
 
#if defined fsReview
    std::shared_ptr<gfCNagManager> mNagManager;
#endif
 
        std::shared_ptr<fsCEntityFactory> mEntityFactory;
        std::shared_ptr<fsCComponentFactory> mComponentFactory;
 
        std::unique_ptr<fsCAppSettings> mAppSettings;
        std::unique_ptr<fsIHardware> mHardware;
 
        std::unique_ptr<fsCParticleDataManager> mParticleManager;
        std::unique_ptr<fsCAnimationDataManager> mAnimationManager;
 
        std::unique_ptr<fsCAppTimer> mApptimer;
        std::unique_ptr<fsCLocaleOptions> mLocale;
        std::unique_ptr<fsSPendingRenderTargetCaptureRequest> mPendingRenderTargetCaptureRequest;
 
};
 
#endif