ParaEngineApp.h

#pragma once


#ifdef PLATFORM_MAC
    #include "platform/mac/ParaEngineApp.h"
#else


#include "ParaEngineAppBase.h"
#include "common/d3dapp.h"
#include "ITouchInputTranslator.h"

#include <map>

// forward declare
namespace ParaEngine
{
    struct SpriteFontEntity;
    class CDirectKeyboard;
    class CGUIRoot;
    class CSceneObject;
    class CAISimulator;
    class CParaWorldAsset;
    class CAudioEngine;
    class CWinRawMsgQueue;
    class CViewportManager;
    struct CWinRawMsg;
}

namespace ParaEngine
{
    class CParaEngineApp : public CD3DApplication, public CParaEngineAppBase
    {
    public:
        CParaEngineApp(const char* lpCmdLine);
        CParaEngineApp();
        virtual ~CParaEngineApp();

        virtual int Run(HINSTANCE hInstance);

        bool IsDebugBuild();

        virtual HRESULT DoWork();

        virtual void    EnablePassiveRendering( bool bEnable );
        virtual bool    IsPassiveRenderingEnabled( );

        virtual void Enable3DRendering(bool bEnable);

        virtual bool Is3DRenderingEnabled();


        virtual void SetFullScreenMode(bool bFullscreen);
        virtual bool IsFullScreenMode();

        virtual void BringWindowToTop();

        virtual void SetAllowWindowClosing(bool bAllowClosing);
        virtual bool IsWindowClosingAllowed();

        virtual void ShowMenu(bool bShow);

        virtual void GetScreenResolution(Vector2* pOut);
        virtual void SetScreenResolution(const Vector2& vSize);

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

        virtual int GetMultiSampleType();
        virtual void SetMultiSampleType(int nType);

        virtual int GetMultiSampleQuality();
        virtual void SetMultiSampleQuality(int nType);

        virtual bool UpdateScreenMode();

        // ParaEngine pipeline routines
        virtual bool SetWindowedMode(bool bWindowed);

        virtual bool IsWindowedMode();
        virtual void SetWindowText(const char* pChar);
        virtual const char* GetWindowText();
        virtual void FixWindowSize(bool fixed);

        virtual void GetStats(string& output, DWORD dwFields=0);

        bool WriteRegStr(const string& root_key, const string& sSubKey, const string& name, const string& value);
        const char* ReadRegStr(const string& root_key, const string& sSubKey, const string& name);

        bool WriteRegDWORD(const string& root_key, const string& sSubKey, const string& name, DWORD value);

        DWORD ReadRegDWORD(const string& root_key, const string& sSubKey, const string& name);

        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 WriteConfigFile(const char* sFileName);

        virtual bool HasNewConfig();

        virtual void SetHasNewConfig(bool bHasNewConfig);

        virtual void SetIgnoreWindowSizeChange(bool bIgnoreSizeChange);

        virtual bool GetIgnoreWindowSizeChange();

        virtual bool ForceRender();
    public:
        HRESULT OnCreateWindow();

        HRESULT ConfirmDevice( LPDIRECT3D9 pD3d, D3DCAPS9*, DWORD, D3DFORMAT, D3DFORMAT );

        HRESULT Init(HWND* pHWND);

        HRESULT OneTimeSceneInit();

        virtual HRESULT InitDeviceObjects();

        virtual HRESULT RestoreDeviceObjects();


        virtual HRESULT Render();

        void GenerateD3DDebugString();

        virtual HRESULT FrameMove();
        virtual HRESULT FrameMove(double fTime);

        virtual HRESULT InvalidateDeviceObjects();
        virtual HRESULT DeleteDeviceObjects();

        virtual HRESULT FinalCleanup();

    public:
        void HandleUserInput();

        virtual void SetMainWindow(HWND hWnd, bool bIsExternalWindow=true);
        virtual HWND GetMainWindow();

        virtual HRESULT StartApp(const char* sCommandLine = 0);

        void InitSystemModules();

        void InitWin3DSettings();

        void InitLogger();

        void BootStrapAndLoadConfig();

        void InitApp(const char* sCommandLine);

        bool CheckClientLicense();

        void LoadAndApplySettings();

        virtual HRESULT StopApp();

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

        virtual LRESULT MsgProcWinThreadCustom( UINT uMsg, WPARAM wParam, LPARAM lParam);

        virtual LRESULT SendMessageToApp( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

        virtual bool PostWinThreadMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);

        virtual bool GetMessageFromApp(CWinRawMsg* pMsg);

        virtual LRESULT MsgProcApp( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

        virtual HRESULT Create( HINSTANCE hInstance = 0 );

        virtual HRESULT CreateFromD3D9Device(IDirect3DDevice9* pD3dDevice, IDirect3DSwapChain9* apSwapChain);

        virtual HRESULT Render3DEnvironment(bool bForceRender = false);
        virtual float GetFPS();
        void UpdateFrameStats(double fTime);

        //void UpdateRecordingState();

        virtual HINSTANCE GetModuleHandle();

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

        virtual float GetRefreshTimer();

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

        virtual PEAppState GetAppState();

        virtual void SetAppState(ParaEngine::PEAppState state);

        virtual void ActivateApp(bool bActivate);

        virtual bool IsAppActive();

        virtual DWORD GetCoreUsage();

        virtual void SetCoreUsage(DWORD dwUsage);

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

        virtual void Exit(int nReturnCode = 0);

        virtual bool HasFocus(HWND hWnd = 0);

        virtual bool IsTouchInputting(){ return m_isTouching; }
        virtual bool IsSlateMode();

        // deprecated:
        virtual int32 GetTouchPointX(){ return m_touchPointX; }
        virtual int32 GetTouchPointY(){ return m_touchPointY; }


        virtual bool IsServerMode();;
    public:
        void SetAutoLowerFrameRateWhenNotFocused(bool bEnabled);
        bool GetAutoLowerFrameRateWhenNotFocused();

        void SetToggleSoundWhenNotFocused(bool bEnabled);
        bool GetToggleSoundWhenNotFocused();

        bool AppHasFocus();

        CViewportManager* GetViewportManager();

    private:
        bool UpdateScreenDevice();

        const char* GetTouchEventSCodeFromMessage(const char * event_type, HWND hWnd, WPARAM wParam, LPARAM lParam);

        void SetAppWndRect(const RECT& rect);
    protected:
        HINSTANCE             m_hInstance;                // app instance

        ref_ptr<CGUIRoot> m_pGUIRoot;
        ref_ptr<CSceneObject>         m_pRootScene;
        ref_ptr<CViewportManager>     m_pViewportManager;
        ref_ptr<CParaWorldAsset>      m_pParaWorldAsset;

        CDirectKeyboard*      m_pKeyboard;
        float                 m_fAspectRatio;             // Aspect ratio used by the FPS camera
        CAudioEngine*        m_pAudioEngine;                   // audio engine class

        bool                  m_bDrawReflection:1;          // reflection-drawing option
        bool                  m_bDisplayText:1;             // whether to display text
        bool                  m_bDisplayHelp:1;             // whether to display help text
        bool    m_bServerMode:1;
        // whether we are loaded from config/config.new.txt.
        bool m_bHasNewConfig:1;
        bool m_bAllowWindowClosing:1;
        // default to false. if true, we will lower frame rate when the window is not focused.
        bool m_bAutoLowerFrameRateWhenNotFocused:1;
        // if true, sound volume will be set to 0, when not focused.
        bool m_bToggleSoundWhenNotFocused:1;

        int m_nInitialGameEffectSet;


        int                 m_nWindowedDesired;
        bool                m_bIsKeyEvent;
        bool                m_bUpdateScreenDevice; // whether to toggle screen in the next frame

        // for keeping command line arguments.
        std::string m_cmd;

        CWinRawMsgQueue*    m_pWinRawMsgQueue;

        DWORD m_dwWinThreadID;

        DWORD m_dwCoreUsage;

        bool m_bAppHasFocus;

        std::string m_sTitleString;

        HWND m_hwndTopLevelWnd;

        bool m_isSlateMode;
        // deprecated:
        int32 m_touchPointX;
        int32 m_touchPointY;

        float m_fFPS;

        ITouchInputTranslator* m_pTouchInput;

        ITouchInputTranslator* LoadTouchInputPlug();

    };

}

#endif