d3dapp.h

#pragma once
//-----------------------------------------------------------------------------
// File: D3DApp.h
//
// Desc: Base application class based on the Direct3D samples framework library.
//
//-----------------------------------------------------------------------------
#include "IParaEngineApp.h"

class CD3DApplication
{
public:
    virtual         ~CD3DApplication()                         { }

protected:
    // Internal error handling function
    HRESULT DisplayErrorMsg( HRESULT hr, DWORD dwType );

    // Internal functions to manage and render the 3D scene
    static bool ConfirmDeviceHelper( D3DCAPS9* pCaps, VertexProcessingType vertexProcessingType, D3DFORMAT adapterFormat, D3DFORMAT backBufferFormat );
    bool    FindBestWindowedMode( bool bRequireHAL, bool bRequireREF );
    bool    FindBestFullscreenMode( bool bRequireHAL, bool bRequireREF );
    HRESULT LaunchReadme();
    HRESULT ChooseInitialD3DSettings();
    HRESULT Initialize3DEnvironment();
    HRESULT HandlePossibleSizeChange(bool bUpdateSizeOnly = false);
    HRESULT Reset3DEnvironment();
    HRESULT ToggleFullscreen();
    HRESULT ForceWindowed();
    HRESULT UserSelectNewDevice();
    void    Cleanup3DEnvironment();
    HRESULT Render3DEnvironment(bool bForceRender=false);
    virtual void BuildPresentParamsFromSettings();
    virtual HRESULT AdjustWindowForChange();
    virtual void UpdateStats();

    // Overridable functions for the 3D scene created by the app
    virtual HRESULT ConfirmDevice(D3DCAPS9*,DWORD,D3DFORMAT,D3DFORMAT) { return S_OK; }
    virtual HRESULT OneTimeSceneInit()                         { return S_OK; }
    virtual HRESULT InitDeviceObjects()                        { return S_OK; }
    virtual HRESULT RestoreDeviceObjects()                     { return S_OK; }
    virtual HRESULT FrameMove()                                { return S_OK; }
    virtual HRESULT Render()                                   { return S_OK; }
    virtual HRESULT InvalidateDeviceObjects()                  { return S_OK; }
    virtual HRESULT DeleteDeviceObjects()                      { return S_OK; }
    virtual HRESULT FinalCleanup()                             { return S_OK; }
    virtual bool UpdateViewPort();

    virtual HRESULT DoWork();

    
public:
    virtual void    Pause( bool bPause );
    virtual bool    IsPaused();
    
    HRESULT PresentScene();

    void    EnablePassiveRendering( bool bEnable ) { m_bPassiveRendering = bEnable;};
    bool    IsPassiveRenderingEnabled( ) { return m_bPassiveRendering; };

    void Enable3DRendering(bool bEnable) {m_bEnable3DRendering = bEnable;};

    bool Is3DRenderingEnabled() {return m_bEnable3DRendering;};

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

    float GetRefreshTimer() const;
    
    // Functions to create, run, pause, and clean up the application
    virtual HRESULT Create();
    virtual HRESULT CreateFromD3D9Device(IDirect3DDevice9* pD3dDevice, IDirect3DSwapChain9* apSwapChain);

    virtual int     Run(HINSTANCE hInstance);

    ParaEngine::PEAppState GetAppState() {return m_nAppState;}
    void SetAppState(ParaEngine::PEAppState state) {m_nAppState = state;}

    bool IsExternalD3DDevice(){return m_bIsExternalD3DDevice;}
protected:
    // Internal constructor
    CD3DApplication();

    CD3DEnumeration   m_d3dEnumeration;
    CD3DSettings      m_d3dSettings;

    // Internal variables for the state of the app
    bool              m_bWindowed;
    bool              m_bActive;
    bool              m_bDeviceLost;
    bool              m_bMinimized;
    bool              m_bMaximized;
    bool              m_bIgnoreSizeChange;
    bool              m_bDeviceObjectsInited;
    bool              m_bDeviceObjectsRestored;

    // Internal variables used for timing
    bool              m_bFrameMoving;
    bool              m_bSingleStep;
    bool              m_bDisableD3D;

    bool              m_bPassiveRendering;

    bool              m_bEnable3DRendering;

    // Main objects used for creating and rendering the 3D scene
    D3DPRESENT_PARAMETERS m_d3dpp;         // Parameters for CreateDevice/Reset
    HWND              m_hWnd;              // The main app window
    HWND              m_hWndFocus;         // The D3D focus window (usually same as m_hWnd)
    HMENU             m_hMenu;             // App menu bar (stored here when fullscreen)
    LPDIRECT3D9       m_pD3D;              // The main D3D object
    LPDIRECT3DDEVICE9 m_pd3dDevice;        // The D3D rendering device
    IDirect3DSwapChain9* m_pd3dSwapChain;
    D3DCAPS9          m_d3dCaps;           // Caps for the device
    D3DSURFACE_DESC   m_d3dsdBackBuffer;   // Surface desc of the backbuffer
    DWORD             m_dwCreateFlags;     // Indicate sw or hw vertex processing
    DWORD             m_dwWindowStyle;     // Saved window style for mode switches
    RECT              m_rcWindowBounds;    // Saved window bounds for mode switches
    RECT              m_rcWindowClient;    // Saved client area size for mode switches
    int               m_nClientWidth;
    int               m_nClientHeight;

    // Variables for timing
    double            m_fTime;             // Current time in seconds
    double            m_fElapsedTime;      // Time elapsed since last frame
    FLOAT             m_fFPS;              // Instanteous frame rate
    TCHAR             m_strDeviceStats[90];// string to hold D3D device stats
    TCHAR             m_strFrameStats[90]; // string to hold frame stats
    float             m_fRefreshTimerInterval; //  in seconds. 
    int               m_nFrameRateControl;

    // Overridable variables for the app
    TCHAR*            m_strWindowTitle;    // Title for the app's window
    DWORD             m_dwCreationWidth;   // Width used to create window
    DWORD             m_dwCreationHeight;  // Height used to create window
    bool              m_bShowCursorWhenFullscreen; // Whether to show cursor when fullscreen
    bool              m_bClipCursorWhenFullscreen; // Whether to limit cursor pos when fullscreen
    bool              m_bStartFullscreen;  // Whether to start up the app in fullscreen mode
    bool              m_bCreateMultithreadDevice; // Whether to create a multithreaded device
    bool              m_bAllowDialogBoxMode; // If enabled the framework will try to enable GDI dialogs while in fullscreen

    bool              m_bIsExternalWindow;

    bool m_bIsExternalD3DDevice;
    ParaEngine::PEAppState m_nAppState;

};