---

GXGraphicsEngine.h

Go to the documentation of this file.

#ifndef __GXENGINE
#define __GXENGINE



#include "GXStandardDefines.h"
#include "GXVector.h"


#include "GXLandRenderer.h"
#include "GXSky.h"
#include "GXLandGenerator.h"
#include "GXMutex.h"
#include "GXWindow.h"
#include "GXDeviceContainer.h"
#include "GXFirstPersonMovement.h"
#include "GXModelManager.h"
#include "GXEntityList.h"
#include "GXEntityWaypoint.h"
#include "GXSpriteManager.h"









class CGXGraphicsEngine
{
public:
        CGXGraphicsEngine();
        ~CGXGraphicsEngine();

        //todo, get rid of often-called virtuals        
        //Initialization
        bool Cleanup();

        bool Init(UINT uWindowWidth, UINT uWindowHeight,
                         UINT uBBWidth, UINT uBBHeight,
                                bool bFullScreen,
                                HWND hWnd, HINSTANCE hInstance);



        //Display Params
        bool SetCameraPos(CGXVector<3>* pPos);
        bool GetCameraPos(CGXVector<3>* pPos);
        bool MoveCamera(GXMOVEDIR Direction, float fAmt);

        inline void SetCameraVelocity(const float fAmt)
        {
                m_fCameraVelocity=fAmt;
        }

        inline float GetCameraVelocity() const
        {
                return m_fCameraVelocity;
        }

        inline void RotateCamera(const float fX, const float fY)
        {
                m_Mover.Look(fX, fY);
        }

        inline void GetCameraDirection(CGXVector<3>* pOut) 
        {
                m_Mover.GetCameraDirection((D3DXVECTOR3*)pOut);
        }


        bool ToggleWindowConfig(bool bFullScreen, UINT uWidth, UINT uHeight);


        //todo, inline some of these
        //Timing
        inline UINT GetTime()
        {
                return m_uCurrentTime;
        }

        bool SetTime(UINT uNewTime);

        bool IncrementTime();

        //Land
        bool LoadLand(char* szFileName);
        bool SaveLand(char* szFileName);
        bool GenerateLand(const UINT uRandSeed, char* szColorSpline);

        bool ToggleWireFrame();



        //Entity Management
        int             PrecacheModel(char* szFileName);//-1 on error, else model id
        int             CreateEntity(UINT uModel);//-1 on error
        bool    DeleteEntity(UINT uEntityID);

        bool    GetEntityWaypoint(UINT uID, SGXEntityWaypoints* pOut);
        bool    SetEntityWaypoint(UINT uID, SGXEntityWaypoints* pIn);

        bool    GetEntityPosition(UINT uID, CGXVector<3>* pOut);



        //Sprites
        inline int      PrecacheSprite(char* szFileName)
        {
                if(!m_RenderMutex.Lock(-1))
                {
                    return -1;
                }
                

                int nRet=m_SpriteManager.PrecacheSprite(szFileName);

                m_RenderMutex.Unlock();

                return nRet;
        }

        inline int      AddSpriteInstance(SGXSpriteInfo* pInfo)
        {
                if(!m_RenderMutex.Lock(-1))
                {
                    return -1;
                }
                

                int nRet=m_SpriteManager.AddSpriteInstance(pInfo);

                m_RenderMutex.Unlock();

                return nRet;
        }

        inline bool DeleteSpriteInstance(UINT uIndex)
        {
                if(!m_RenderMutex.Lock(-1))
                {
                    return false;
                }
                

                bool bRet=m_SpriteManager.DeleteSpriteInstance(uIndex);

                m_RenderMutex.Unlock();

                return bRet;
        }

        inline bool     GetSpriteInfo(UINT uIndex, SGXSpriteInfo* pOut)
        {
                if(!m_RenderMutex.Lock(-1))
                {
                    return false;
                }
                

                bool bRet=m_SpriteManager.GetSpriteInfo(uIndex, pOut);

                m_RenderMutex.Unlock();
                
                return bRet;
        }


        inline bool     SetSpriteInfo(UINT uIndex, SGXSpriteInfo* pIn)
        {
                if(!m_RenderMutex.Lock(-1))
                {
                    return false;
                }
                

                bool bRet=m_SpriteManager.SetSpriteInfo(uIndex, pIn);

                m_RenderMutex.Unlock();

                return bRet;
        }





        //to be called by worker thread
        bool    RenderStuff();
        bool    ShouldThreadExit();
        HANDLE  GetThreadDeathEvent();
        bool    WakeUpThread();

        inline  HANDLE GetWorkerThreadHandle()
        {
                return m_hWorkerThread;
        }




        inline  HWND GetHWND()
        {
                return m_hWnd;
        }

        bool    ValidateWindow();

        void    DisplayStats(bool bStats);


protected:
        bool    OnDeviceLost();

        bool    KillWorkerThread();
        bool    CreateWorkerThread();

        bool    SetupMatrices();//todo, cache stuff here
        bool    CheckForLostDevice();//todo, profile this guy, returns true if we are good to go


        bool    SetRenderStates();



protected:
        CGXDeviceContainer              m_Device;
        //CGXWindow                             m_Window;
        CGXLandRenderer                 m_LandRenderer;
        CGXSky                                  m_Sky;
        CGXMutex                                m_RenderMutex;//Locked for RenderStuff, and anything that could affect it
        CGXFirstPersonMovement  m_Mover;
        CGXModelManager                 m_ModelManager;
        CGXEntityList                   m_EntityList;
        CGXSpriteManager                m_SpriteManager;


        HANDLE                                  m_hWorkerThread;//calls RenderStuff
        HANDLE                                  m_hThreadHasDiedEvent;          

        bool                                    m_bShouldThreadExit;

        UINT                                    m_uCurrentTime;

        D3DXMATRIX                              m_mViewMatrix;
        D3DXMATRIX                              m_mProjectionMatrix;

        bool                                    m_bReadyToRender;//land etc

        HWND                                    m_hWnd;

        float                                   m_fCameraVelocity;

        RECT                                    m_WindowRect;//for going between full screen and windowed mode
};






DWORD WINAPI GXEngineRenderThread(
  LPVOID lpParameter   // thread data
);



void GXDeviceErrorCallBack(char*);



#endif

---