ParaEngineAppBase.h

#pragma once
#include "IParaEngineApp.h"
#include "CommandLineParams.h"

namespace ParaEngine
{
    class CParaEngineApp;
    class CObjectAutoReleasePool;

    /* base implementation of ParaEngine APP, shared by both mobile and pc version.  */
    class CParaEngineAppBase : public IParaEngineApp, public CCommandLineParams, public IObject
    {
    public:
        CParaEngineAppBase();
        CParaEngineAppBase(const char* sCmd);
        static CParaEngineApp* GetInstance();
        static void SetCurrentInstance(CParaEngineApp* pInstance);
        virtual LifetimeType    LifetimeControl();
        virtual BaseInterface*  AcquireInterface();
        virtual void            ReleaseInterface();
        virtual void DeleteInterface();
        virtual ~CParaEngineAppBase();


        virtual void OnFrameEnded();

        void DoTestCode();
    public:
        virtual void WriteToLog(const char* sFormat, ...);
        virtual void AppLog(const char* sFormat);
        virtual bool FindParaEngineDirectory(const char* sHint = NULL);

        void AutoSetLocale();

        virtual void Enable3DRendering(bool bEnable);

        virtual bool Is3DRenderingEnabled();

        virtual bool IsTouchInputting();
        virtual void SetTouchInputting(bool bTouchInputting);
        virtual bool IsSlateMode();
        virtual int32 GetTouchPointX()  { return 0; };
        virtual int32 GetTouchPointY()  { return 0; };

        virtual void GetCursorPosition(int* pX, int * pY, bool bInBackbuffer = true);

        virtual void GameToClient(int& inout_x, int & inout_y, bool bInBackbuffer = true) { };

        virtual void ClientToGame(int& inout_x, int & inout_y, bool bInBackbuffer = true){ };

        virtual void SetIgnoreWindowSizeChange(bool bIgnoreSizeChange){};

        virtual bool GetIgnoreWindowSizeChange(){ return false; };

        virtual HINSTANCE GetModuleHandle()  { return 0; };

        virtual void SetRefreshTimer(float fTimeInterval, int nFrameRateControl = 0) { };

        virtual float GetRefreshTimer()  { return 0; };

        virtual void ActivateApp(bool bActivate) { };

        virtual bool IsAppActive();

        virtual DWORD GetCoreUsage();

        virtual void SetCoreUsage(DWORD dwUsage) { };


        virtual void SetReturnCode(int nReturnCode);
        virtual int GetReturnCode();

        virtual void SystemMessageBox(const std::string& msg);

        virtual void SetAppCommandLine(const char* pCommandLine);

        virtual const char* GetAppCommandLine();

        virtual const char* GetAppCommandLineByParam(const char* pParam, const char* defaultValue);
    public:
        virtual HRESULT StartApp(const char* sCommandLine = 0)  { return S_OK; };

        virtual HRESULT StopApp()  { return S_OK; };

        virtual HRESULT Init(HWND* pHWND)  { return S_OK; };

        virtual void Exit(int nReturnCode = 0);

        virtual ParaEngine::PEAppState GetAppState();
        virtual void SetAppState(ParaEngine::PEAppState state);

        virtual HRESULT FrameMove(double fTime){ return S_OK; };
        virtual HRESULT FinalCleanup();

        // following contains null implementation
        virtual void SetMainWindow(HWND hWnd, bool bIsExternalWindow = true)  { };
        virtual HWND GetMainWindow()  { return 0; };

        virtual int Run(HINSTANCE hInstance){ return 0; };

        virtual HRESULT DoWork()  { return 0; };

        virtual HRESULT CreateFromD3D9Device(IDirect3DDevice9* pD3dDevice, IDirect3DSwapChain9* apSwapChain)  { return 0; };

        virtual HRESULT InitDeviceObjects() { return S_OK;}

        virtual HRESULT RestoreDeviceObjects() { return S_OK; }

        virtual HRESULT InvalidateDeviceObjects() { return S_OK; }
        virtual HRESULT DeleteDeviceObjects() { return S_OK; }

        virtual HRESULT Create(HINSTANCE hInstance = 0)  { return 0; };

        virtual HRESULT Render3DEnvironment(bool bForceRender = false) { return S_OK; }

        virtual LRESULT MsgProcWinThread(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool bCallDefProcedure = true)  { return 0; };

        /*** process win thread messages without a hWnd. Such messages are usually invoked by PostWinThreadMessage() from other threads. */
        virtual LRESULT MsgProcWinThreadCustom(UINT uMsg, WPARAM wParam, LPARAM lParam)  { return 0; };

        virtual LRESULT SendMessageToApp(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)  { return 0; };

        virtual bool PostWinThreadMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)  { return false; };

        virtual bool GetMessageFromApp(CWinRawMsg* pMsg)  { return false; };

        virtual LRESULT MsgProcApp(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)  { return 0; };

        virtual void    EnablePassiveRendering(bool bEnable) { };

        virtual bool    IsPassiveRenderingEnabled()  { return false; };

        virtual void BringWindowToTop() { };

        virtual void SetAllowWindowClosing(bool bAllowClosing) { };
        virtual bool IsWindowClosingAllowed()  { return false; };

        virtual void SetFullScreenMode(bool bFullscreen){};
        virtual bool IsFullScreenMode(){ return false; };

        virtual void ShowMenu(bool bShow){};

        virtual void GetScreenResolution(Vector2* pOut)  { *pOut = Vector2::ZERO; };
        virtual void SetScreenResolution(const Vector2& vSize){};

        virtual int GetMultiSampleType(){ return 0; };
        virtual void SetMultiSampleType(int nType){};

        virtual int GetMultiSampleQuality(){ return 0; };
        virtual void SetMultiSampleQuality(int nType){};

        virtual bool UpdateScreenMode(){ return false; };

        // ParaEngine pipeline routines
        virtual bool SetWindowedMode(bool bWindowed){ return false; };
        virtual bool IsWindowedMode(){ return true; };
        virtual void SetWindowText(const char* pChar) {};
        virtual const char* GetWindowText() { return ""; };
        /* */
        virtual void FixWindowSize(bool fixed) {};


        virtual void WriteConfigFile(const char* sFileName) {};

        virtual bool HasNewConfig() { return false; };

        virtual void SetHasNewConfig(bool bHasNewConfig) {};


        virtual void GetWindowCreationSize(int * pWidth, int * pHeight) {};

        virtual void SetMinUIResolution(int nWidth, int nHeight, bool bAutoUIScaling = true) { };

        virtual void GetResolution(float* pX, float* pY) {};
        virtual void SetResolution(float x, float y) {};

        virtual NPL::INPLRuntime* GetNPLRuntime();

        virtual CRefCounted* AddToSingletonReleasePool(CRefCounted* pObject);

        virtual bool HasClosingRequest();
        virtual void SetHasClosingRequest(bool val);

        virtual bool LoadNPLPackage(const char* sFilePath, std::string * pOutMainFile = NULL);

        virtual bool FindBootStrapper();

        virtual bool InitCommandLineParams();


        virtual bool ForceRender();

        virtual const char* GetModuleDir();;
    public:
        CViewportManager* GetViewportManager() { return NULL; };

        virtual void VerifyCommandLine(const char* sCommandLine, std::string &strCmd);

    protected:
        void InitCommon();
        void DestroySingletons();

        void LoadPackages();
        void LoadPackagesInFolder(const std::string& sPkgFolder);
        
        void RegisterObjectClass(IAttributeFields* pObject);

        void RegisterObjectClasses();
    protected:
        static CParaEngineApp* g_pCurrentApp;
        bool m_bEnable3DRendering;
        bool m_isTouching;
        bool m_hasClosingRequest;
        int m_nReturnCode;
        CObjectAutoReleasePool* m_pSingletonReleasePool;
        std::string m_sPackagesDir;
        std::string m_sModuleDir;
        std::string m_sInitialWorkingDir;
        PEAppState m_nAppState;
    };
}