---

GXDeviceWrapper.h

Go to the documentation of this file.

#ifndef __GXDEVICEWRAPPER_H
#define __GXDEVICEWRAPPER_H

#include "GXStandardDefines.h"
#include "GXTextureManager.h"
#include "GXSizeableArray.h"
#include "GXMutex.h"

D3DRENDERSTATETYPE

struct SGXRenderStateCache
{
        DWORD rgdwRenderStates[175];
        DWORD dwVertexShader;
        DWORD dwPixelShader;

        int iBackBuffer;//-1 for default
        int iDepthStencil;//-1 for default

        int rciTextures[8];

        int iVertexBufferIndex;

        int iIndexBufferIndex;
};



class CGXDeviceWrapper
{
public:
        CGXDeviceWrapper();
        virtual ~CGXDeviceWrapper();

        virtual bool CreateDevice(HWND hWnd, UINT uMultiSampleCount);

        virtual void GetBackBufferFormat(D3DFORMAT* pOut);
        virtual void GetDepthStencilFormat(D3DFORMAT* pOut);

        virtual bool Clear();
        virtual bool Present();

        virtual void SetBackgroundColor(DWORD dwColor);
        virtual DWORD GetBackgroundColor();


        virtual bool SetStreamSource(UINT uStream, int iIndex);
        virtual bool SetIndexBuffer(int iIndex);

        virtual bool DrawIndexedPrimitive(D3DPRIMITIVETYPE Type,
                                                                          UINT MinIndex,
                                                                          UINT NumVertices,
                                                                          UINT StartIndex,
                                                                          UINT PrimitiveCount);
        
        virtual bool SetRenderState(D3DRENDERSTATETYPE State,
                                                                DWORD Value);

        virtual void EnablePolygonCounting(bool bVal);
        virtual void EnableRenderStateCaching(bool bVal);


        virtual bool SetPixelShader(UINT uIndex);
        virtual bool SetVertexShader(UINT uIndex);

        virtual bool SetVertexShaderConstant(DWORD Register, 
                                                                                void* pConstantData, 
                                                                                DWORD  ConstantCount);



        virtual bool CreatePixelShader(char* szShader, 
                                                                        UINT* pHandleOut);

        virtual bool CreateVertexShader(char* szShader, 
                                                                        UINT* pHandle);

        virtual bool SetRenderTarget(int iBackBuffer, 
                                                                int iDepthStencil);//-1 for defaults

        virtual bool LoadGXModelFromStream(CGXModel* pOut, 
                                                                IStream* pStream);

        virtual bool LoadGXModelFromData(CGXModel* pOut,
                                                                GXVertex* pVerts,
                                                                UINT* pIndices,
                                                                DWORD dwVertCount,
                                                                DWORD dwIndexCount,
                                                                char* szTextureName,
                                                                char* szBumpName);
        
        virtual bool CreateTextureFromFile(char* szTextureName, int* pOut);
        virtual bool CreateEmptyTexture(UINT uSideSize, bool bRenderTarget,
                                                                        int* pOut);


        virtual bool LockPipeline(int uMiliSec);//-1 for infinity
        virtual void UnlockPipeline();

        virtual bool CreateVertexBuffer(UINT uVertexCount,
                                                                        bool bDynamic,
                                                                        bool bWriteOnly,
                                                                        int* pOut);
        
        virtual bool CreateIndexBuffer(UINT uIndexCount,
                                                                        bool bDynamic,
                                                                        bool bWriteOnly,
                                                                        int* pOut);

        
        virtual bool SetTextureStageState(DWORD Stage,
                                                                        D3DTEXTURESTAGESTATETYPE Type,
                                                                        DWORD Value);


protected:
        virtual bool CheckCaps(D3DCAPS8* pCaps);
        virtual bool CheckFormat(D3DFORMAT* pOut);
        virtual bool GetAnyFormat(D3DFORMAT* pOut);

        virtual void Cleanup();

protected:
        bool                            m_bInSceneAlready;
        bool                            m_bCountPolygons;
        bool                            m_bCacheRenderStates;

        CGXMutex                        m_PipelineMutex;

        DWORD                           m_dwBackgroundColor;

        IDirect3D8*                     m_pD3D;
        IDirect3DDevice8*       m_pDevice;

        IDirect3DSurface8*  m_pBackBuffer;
        IDirect3DSurface8*  m_pDepthStencilBuffer;

        CGXTextureManager       m_TextureManager;
        CGXSizeableArray<IDirect3DVertexBuffer8*>       m_VertexBuffers;
        CGXSizeableArray<IDirect3DIndexBuffer8*>        m_IndexVertexBuffers;
        CGXSizeableArray<IDirect3DTexture8*>            m_TextureMaps;
        CGXSizeableArray<DWORD>                                         m_VertexShaders;
        CGXSizeableArray<DWORD>                                         m_PixelShaders;


        SGXRenderStateCache                                                     m_RenderStateCache;
};





#endif

---