---

RainGraphics.h

Go to the documentation of this file.

#ifndef __RAINGRAPHX
#define __RAINGRAPHX



#include "RainDefines.h"
#include "RainCOMFactory.h"

#include "..\..\Graphics\GXCOMDLL\GXCOMDLL.h"//for IGXRenderer


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

        bool Init(CRainCOMFactory* pFactory,
                                UINT uWindowWidth, UINT uWindowHeight, 
                                bool bFullScreen, HWND hWnd);

        void ShutDown();

        inline void RotateCamera(const float fX, const float fY)
        {
                assert(m_pGraphics);
                m_pGraphics->RotateCamera(fX, fY);
        }

        inline void GetCameraVelocity(float* pOut)
        {
                assert(m_pGraphics);
                m_pGraphics->GetCameraVelocity(pOut);
        }

        inline void SetCameraVelocity(const float fVel)
        {
                assert(m_pGraphics);
                m_pGraphics->SetCameraVelocity(fVel);
        }


        inline bool LoadLand(BSTR szFileName)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->LoadLand(szFileName));
        }

        inline bool SaveLand(BSTR szFileName)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->SaveLand(szFileName));
        }

        inline bool GenerateLand(const UINT uRandSeed, BSTR szColorSpline)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->GenerateLand(uRandSeed, szColorSpline));
        }

        inline bool GetCameraPos(float* pOut)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->GetCameraPos(pOut));
        }

        inline bool SetCameraPos(float* pIn)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->SetCameraPos(pIn));
        }

        inline bool MoveCamera(GXMOVEDIR Direction, float fAmt)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->MoveCamera(Direction, fAmt));
        }

        inline bool ToggleWindowConfig(BOOL bFullScreen, UINT uWidth, UINT uHeight)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->ToggleWindowConfig(bFullScreen, uWidth, uHeight));
        }

        inline void GetTime(UINT* pOut)
        {
                assert(m_pGraphics);
                m_pGraphics->GetTime(pOut);
        }

        inline bool SetTime(UINT uNewTime)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->SetTime(uNewTime));
        }

        inline bool IncrementTime()
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->IncrementTime());
        }


        inline bool PrecacheModel(BSTR szFileName, UINT* pIndexOut)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->PrecacheModel(szFileName, pIndexOut));
        }

        inline bool CreateEntity(UINT uModel, UINT* pIDOut)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->CreateEntity(uModel, pIDOut));
        }

        inline bool DeleteEntity(UINT uID)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->DeleteEntity(uID));
        }

        inline bool GetEntityWaypoint(UINT uID, SGXEntityWaypoints* pOut)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->GetEntityWaypoint(uID, pOut));
        }

        inline bool SetEntityWaypoint(UINT uID, SGXEntityWaypoints* pIn)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->SetEntityWaypoint(uID, pIn));
        }


        inline bool ValidateWindow()
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->ValidateWindow());
        }


        inline void DisplayStats(BOOL bDisplay)
        {
                assert(m_pGraphics);
                m_pGraphics->DisplayStats(bDisplay);
        }


        inline bool PrecacheSprite(BSTR FileName, UINT* pOut)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->PrecacheSprite(FileName, pOut));
        }

        inline bool AddSpriteInstance(SGXSpriteInfo* pInfo)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->AddSpriteInstance(pInfo));
        }


        inline bool DeleteSpriteInstance(UINT uIndex)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->DeleteSpriteInstance(uIndex));
        }

        inline bool GetSpriteInfo(UINT uIndex, SGXSpriteInfo* pOut)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->GetSpriteInfo(uIndex, pOut));
        }

        inline bool SetSpriteInfo(UINT uIndex, SGXSpriteInfo* pIn)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->SetSpriteInfo(uIndex, pIn));
        }

        inline bool GetEntityPos(UINT uEntity, float* pOutPos)
        {
                assert(m_pGraphics);
                return SUCCEEDED(m_pGraphics->GetEntityPos(uEntity, pOutPos));
        }

        inline void GetCameraDirection(float* pOut)
        {
                assert(m_pGraphics);
                m_pGraphics->GetCameraDirection(pOut);
        }
        






























private:
        void Cleanup();
private:
        IGXRenderer*            m_pGraphics;
};




#endif

---