467 lines
17 KiB
C++
467 lines
17 KiB
C++
#ifndef CKRASTERIZERDX9_H
|
|
#define CKRASTERIZERDX9_H "$Id:$"
|
|
/*************************************************************************/
|
|
/* File : CKDX9Rasterizer.h */
|
|
/* Author : Romain Sididris */
|
|
/* */
|
|
/* + Direct X 9 Rasterizer declaration */
|
|
/* + Some methods of these classes are already implemented in the */
|
|
/* CKRasterizerLib library as they are common to all rasterizers */
|
|
/* */
|
|
/* Virtools SDK */
|
|
/* Copyright (c) Virtools 2004, All Rights Reserved. */
|
|
/*************************************************************************/
|
|
|
|
// Ensure we are using correct DirectDraw version
|
|
#define NBTEMPZBUFFER 256
|
|
|
|
#define _NOD3DX
|
|
|
|
|
|
#ifdef _DEBUG
|
|
#define D3D_DEBUG_INFO
|
|
#endif
|
|
|
|
#ifdef _XBOX
|
|
#include <xtl.h>
|
|
|
|
#if (_XBOX_VER>=200)
|
|
#define NO_FIXED_PIPELINE
|
|
#endif
|
|
|
|
#else
|
|
|
|
#include "d3d9.h"
|
|
#include "d3dx9.h"
|
|
//DDraw is included here only to get the Total Video memory and Free Video Memory
|
|
#include "ddraw.h"
|
|
|
|
#endif
|
|
|
|
|
|
#include "CKRasterizer.h"
|
|
#include "XBitArray.h"
|
|
|
|
//---Implemented in CKDX9PixelFormatUtils.cpp :
|
|
|
|
D3DFORMAT VxPixelFormatToD3DFormat9(VX_PIXELFORMAT pf);
|
|
VX_PIXELFORMAT D3DFormatToVxPixelFormat9(D3DFORMAT ddpf);
|
|
|
|
D3DFORMAT TextureDescToD3DFormat9(CKTextureDesc* desc);
|
|
void D3DFormatToTextureDesc9(D3DFORMAT ddpf,CKTextureDesc* desc);
|
|
|
|
|
|
//------
|
|
|
|
class CKDX9RasterizerDriver;
|
|
class CKDX9RasterizerContext;
|
|
class CKDX9Rasterizer;
|
|
|
|
typedef BOOL (*SetDXRenderStateFunc)(CKDX9RasterizerContext* ctx,CKDWORD Value);
|
|
typedef BOOL (*GetDXRenderStateFunc)(CKDX9RasterizerContext* ctx,CKDWORD* Value);
|
|
|
|
#define PREPAREDXSTRUCT(x) { memset(&x, 0, sizeof(x)); x.dwSize = sizeof(x); }
|
|
#define SAFERELEASE(x) { if (x) x->Release(); x = NULL; }
|
|
#define SAFELASTRELEASE(x) { int refCount= 0; if (x) refCount= x->Release(); x = NULL; XASSERT(refCount == 0); }
|
|
|
|
// Store texture operation required to perform blending between two texture stages
|
|
typedef struct CKStageBlend9 {
|
|
D3DTEXTUREOP Cop;
|
|
CKDWORD Carg1;
|
|
CKDWORD Carg2;
|
|
D3DTEXTUREOP Aop;
|
|
CKDWORD Aarg1;
|
|
CKDWORD Aarg2;
|
|
} CKStageBlend;
|
|
|
|
/*******************************************
|
|
A texture object for DX9 : contains the
|
|
texture surface pointer
|
|
*********************************************/
|
|
typedef struct CKDX9TextureDesc : public CKTextureDesc
|
|
{
|
|
public:
|
|
union {
|
|
LPDIRECT3DBASETEXTURE9 DxBaseTexture;
|
|
LPDIRECT3DTEXTURE9 DxTexture;
|
|
LPDIRECT3DCUBETEXTURE9 DxCubeTexture;
|
|
LPDIRECT3DVOLUMETEXTURE9 DxVolumeTexture;
|
|
};
|
|
//----- For render target textures...
|
|
LPDIRECT3DTEXTURE9 DxRenderTexture;
|
|
//----- For non managed surface to be locked (DX9 does not support direct locking anymore)
|
|
LPDIRECT3DSURFACE9 DxLockedSurface;
|
|
DWORD LockedFlags;
|
|
public:
|
|
CKDX9TextureDesc() { DxTexture=NULL; DxRenderTexture=NULL; DxLockedSurface = NULL;}
|
|
//
|
|
~CKDX9TextureDesc();
|
|
} CKDX9TextureDesc;
|
|
|
|
|
|
/********************************************
|
|
Same override for vertex buffers
|
|
*************************************************/
|
|
typedef struct CKDX9VertexBufferDesc : public CKVertexBufferDesc
|
|
{
|
|
public:
|
|
LPDIRECT3DVERTEXBUFFER9 DxBuffer;
|
|
public:
|
|
CKDX9VertexBufferDesc() { DxBuffer=NULL; }
|
|
~CKDX9VertexBufferDesc() { SAFERELEASE(DxBuffer); }
|
|
} CKDX9VertexBufferDesc;
|
|
|
|
/********************************************
|
|
Same override for index buffers
|
|
*************************************************/
|
|
typedef struct CKDX9IndexBufferDesc : public CKIndexBufferDesc
|
|
{
|
|
public:
|
|
LPDIRECT3DINDEXBUFFER9 DxBuffer;
|
|
public:
|
|
CKDX9IndexBufferDesc() { DxBuffer=NULL; }
|
|
~CKDX9IndexBufferDesc() { SAFERELEASE(DxBuffer); }
|
|
} CKDX9IndexBufferDesc;
|
|
|
|
|
|
/********************************************
|
|
Vertex Shaders....
|
|
*************************************************/
|
|
typedef struct CKDX9VertexShaderDesc : public CKVertexShaderDesc
|
|
{
|
|
public:
|
|
LPDIRECT3DVERTEXSHADER9 DxShader;
|
|
CKDX9RasterizerContext* Owner;
|
|
XArray<BYTE> m_FunctionData;
|
|
|
|
public:
|
|
|
|
BOOL Create(CKDX9RasterizerContext* Ctx,CKVertexShaderDesc* Format);
|
|
virtual ~CKDX9VertexShaderDesc();
|
|
CKDX9VertexShaderDesc() { DxShader = 0; Owner = 0; }
|
|
} CKDX9VertexShaderDesc;
|
|
|
|
|
|
/********************************************
|
|
Pixel Shaders....
|
|
*************************************************/
|
|
typedef struct CKDX9PixelShaderDesc : public CKPixelShaderDesc
|
|
{
|
|
public:
|
|
LPDIRECT3DPIXELSHADER9 DxShader;
|
|
CKDX9RasterizerContext* Owner;
|
|
|
|
public:
|
|
BOOL Create(CKDX9RasterizerContext* Ctx,CKDWORD* Function);
|
|
virtual ~CKDX9PixelShaderDesc();
|
|
CKDX9PixelShaderDesc() { DxShader = 0; Owner = 0; }
|
|
|
|
} CKDX9PixelShaderDesc;
|
|
|
|
|
|
/*****************************************************************
|
|
CKDX9RasterizerContext override
|
|
******************************************************************/
|
|
class CKDX9RasterizerContext : public CKRasterizerContext
|
|
{
|
|
public:
|
|
//--- Construction/destruction
|
|
CKDX9RasterizerContext(CKDX9RasterizerDriver* Driver);
|
|
virtual ~CKDX9RasterizerContext();
|
|
|
|
//--- Creation
|
|
virtual BOOL Create(WIN_HANDLE Window,int PosX=0,int PosY=0,int Width=0,int Height=0,int Bpp=-1,BOOL Fullscreen=0,int RefreshRate=0,int Zbpp=-1,int StencilBpp=-1);
|
|
virtual BOOL IsLost();
|
|
//---
|
|
virtual BOOL Resize(int PosX=0,int PosY=0,int Width=0,int Height=0,CKDWORD Flags=0);
|
|
virtual BOOL Clear(CKDWORD Flags=CKRST_CTXCLEAR_ALL,CKDWORD Ccol=0,float Z=1.0f,CKDWORD Stencil=0,int RectCount=0,CKRECT* rects=NULL);
|
|
virtual BOOL BackToFront();
|
|
|
|
//--- Scene
|
|
virtual BOOL BeginScene();
|
|
virtual BOOL EndScene();
|
|
|
|
//--- Lighting & Material States
|
|
virtual BOOL SetLight(CKDWORD Light,CKLightData* data);
|
|
virtual BOOL EnableLight(CKDWORD Light,BOOL Enable);
|
|
virtual BOOL SetMaterial(CKMaterialData* mat);
|
|
|
|
//--- Viewport State
|
|
virtual BOOL SetViewport(CKViewportData* data);
|
|
|
|
//--- Scissor rect
|
|
virtual BOOL SetScissorRect(const CKRECT* rect);
|
|
|
|
//--- Transform Matrix
|
|
virtual BOOL SetTransformMatrix(VXMATRIX_TYPE Type,const VxMatrix& Mat);
|
|
|
|
//--- Render states
|
|
virtual BOOL SetRenderState(VXRENDERSTATETYPE State,CKDWORD Value) ;
|
|
virtual BOOL GetRenderState(VXRENDERSTATETYPE State,CKDWORD* Value);
|
|
|
|
//--- Texture States
|
|
virtual BOOL SetTexture(CKDWORD Texture,int Stage=0);
|
|
virtual BOOL SetTextureStageState(int Stage,CKRST_TEXTURESTAGESTATETYPE Tss,CKDWORD Value);
|
|
|
|
//--- Vertex & Pixel shaders
|
|
virtual BOOL SetVertexShader(CKDWORD VShaderIndex);
|
|
virtual BOOL SetPixelShader(CKDWORD PShaderIndex);
|
|
virtual BOOL SetVertexShaderConstant(CKDWORD Register,const void* Data,CKDWORD CstCount);
|
|
virtual BOOL SetPixelShaderConstant(CKDWORD Register,const void* Data,CKDWORD CstCount);
|
|
|
|
|
|
//--- Drawing
|
|
virtual BOOL DrawPrimitive(VXPRIMITIVETYPE pType,WORD* indices,int indexcount,VxDrawPrimitiveData* data);
|
|
virtual BOOL DrawPrimitiveVB(VXPRIMITIVETYPE pType,CKDWORD VertexBuffer,CKDWORD StartIndex,CKDWORD VertexCount,WORD* indices=NULL,int indexcount=NULL);
|
|
virtual BOOL DrawPrimitiveVBIB(VXPRIMITIVETYPE pType,CKDWORD VB,CKDWORD IB,CKDWORD MinVIndex,CKDWORD VertexCount,CKDWORD StartIndex,int Indexcount);
|
|
|
|
virtual BOOL DrawPrimitive(VXPRIMITIVETYPE pType,DWORD* indices,int indexcount,VxDrawPrimitiveData* data);
|
|
virtual BOOL DrawPrimitiveVB(VXPRIMITIVETYPE pType,CKDWORD VertexBuffer,CKDWORD StartIndex,CKDWORD VertexCount,DWORD* indices=NULL,int indexcount=NULL);
|
|
|
|
//--- Creation of Textures, Sprites and Vertex Buffer
|
|
virtual BOOL CreateObject(CKDWORD ObjIndex,CKRST_OBJECTTYPE Type,void* DesiredFormat);
|
|
|
|
//--- Vertex Buffers
|
|
virtual void* LockVertexBuffer(CKDWORD VB,CKDWORD StartVertex,CKDWORD VertexCount,CKRST_LOCKFLAGS Lock = CKRST_LOCK_DEFAULT);
|
|
virtual BOOL UnlockVertexBuffer(CKDWORD VB);
|
|
|
|
//--- Textures
|
|
virtual BOOL LoadCubeMapTexture(CKDWORD Texture,const VxImageDescEx& SurfDesc,CKRST_CUBEFACE Face,int miplevel=-1);
|
|
virtual BOOL LoadTexture(CKDWORD Texture,const VxImageDescEx& SurfDesc,int miplevel=-1);
|
|
virtual BOOL CopyToTexture(CKDWORD Texture,VxRect* Src,VxRect* Dest,CKRST_CUBEFACE Face = CKRST_CUBEFACE_XPOS );
|
|
|
|
|
|
//--- Sprites
|
|
virtual BOOL DrawSprite(CKDWORD Sprite,VxRect* src,VxRect* dst);
|
|
|
|
virtual void* GetImplementationSpecificData() { return &m_DirectXData; }
|
|
|
|
//--- Utils
|
|
virtual int CopyToMemoryBuffer(CKRECT* rect,VXBUFFER_TYPE buffer,VxImageDescEx& img_desc);
|
|
virtual int CopyFromMemoryBuffer(CKRECT* rect,VXBUFFER_TYPE buffer,const VxImageDescEx& img_desc);
|
|
|
|
//-- Sets the rendering to occur on a texture (reset the texture format to match )
|
|
virtual BOOL SetTargetTexture(CKDWORD TextureObject,int Width = 0, int Height = 0,CKRST_CUBEFACE Face = CKRST_CUBEFACE_XPOS , BOOL GenerateMipMap = FALSE);
|
|
|
|
virtual BOOL SetUserClipPlane(CKDWORD ClipPlaneIndex,const VxPlane& PlaneEquation);
|
|
virtual BOOL GetUserClipPlane(CKDWORD ClipPlaneIndex,VxPlane& PlaneEquation);
|
|
|
|
virtual void* LockIndexBuffer(CKDWORD IB,CKDWORD StartIndex,CKDWORD IndexCount,CKRST_LOCKFLAGS Lock = CKRST_LOCK_DEFAULT);
|
|
virtual BOOL UnlockIndexBuffer(CKDWORD IB);
|
|
|
|
//---------------------------------------------------------------------
|
|
//---- New methods to lock video memory (DX only)
|
|
virtual BOOL LockTextureVideoMemory(CKDWORD Texture,VxImageDescEx& Desc,int MipLevel = 0,VX_LOCKFLAGS Flags = VX_LOCK_DEFAULT);
|
|
virtual BOOL UnlockTextureVideoMemory(CKDWORD Texture,int MipLevel = 0);
|
|
|
|
//---- To Enable more direct creation of system objects without
|
|
//---- CK2_3D holding a copy of the texture
|
|
virtual BOOL CreateTextureFromFile(CKDWORD Texture,const char* Filename,TexFromFile* param);
|
|
virtual BOOL CreateTextureFromFileInMemory(CKDWORD Texture,void*mem,DWORD sz,TexFromFile* param);
|
|
|
|
virtual BOOL CreateCubeTextureFromFile(CKDWORD Texture,const char* Filename,TexFromFile* param);
|
|
virtual BOOL CreateCubeTextureFromFileInMemory(CKDWORD Texture,void*mem,DWORD sz,TexFromFile* param);
|
|
|
|
virtual BOOL CreateVolumeTextureFromFile(CKDWORD Texture,const char* Filename,TexFromFile* param);
|
|
virtual BOOL CreateVolumeTextureFromFileInMemory(CKDWORD Texture,void*mem,DWORD sz,TexFromFile* param);
|
|
|
|
virtual BOOL LoadVolumeMapTexture(CKDWORD Texture,const VxImageDescEx& SurfDesc,DWORD Depth,int miplevel);
|
|
|
|
virtual void EnsureVBBufferNotInUse(CKVertexBufferDesc* desc);
|
|
virtual void EnsureIBBufferNotInUse(CKIndexBufferDesc* desc);
|
|
virtual float GetSurfacesVideoMemoryOccupation(int* NbTextures,int* NbSprites,float* TextureSize,float* SpriteSize);
|
|
virtual BOOL FlushPendingGPUCommands();
|
|
|
|
virtual DWORD SetMaxAnisotropy(DWORD iMaxAnisotropy);
|
|
|
|
virtual BOOL ResolveMultisampling(CKBOOL resolveColorBuffer, CKBOOL resolveDepthStencilBuffer);
|
|
virtual BOOL ResumeMultisampling();
|
|
virtual BOOL IsMultisamplingResolved() const;
|
|
|
|
virtual CKRST_STRETCHRECT_ERROR StretchRect(CKDWORD destTexture, CKRECT* destRect, CKRST_CUBEFACE destFace,
|
|
CKDWORD srcTexture, CKRECT* srcRect, CKRST_CUBEFACE srcFace,
|
|
CKBOOL filter);
|
|
|
|
|
|
virtual BOOL BeginOcclusionQuery();
|
|
virtual CKDWORD WaitOcclusionQueryResult();
|
|
|
|
protected:
|
|
//-----------------------
|
|
void UpdateDirectXData();
|
|
BOOL InternalDrawPrimitiveVB(VXPRIMITIVETYPE pType,CKDX9VertexBufferDesc* VB,CKDWORD StartIndex,CKDWORD VertexCount,void* indices,int indexcount,BOOL Clip,BOOL iDwordIndices);
|
|
BOOL InternalDrawPrimitive(VXPRIMITIVETYPE pType,void* indices,int indexcount,VxDrawPrimitiveData* data,BOOL iDwordIndices);
|
|
void SetupStreams(LPDIRECT3DVERTEXBUFFER9 Buffer,CKDWORD VFormat,CKDWORD VSize);
|
|
|
|
//--- Objects creation
|
|
BOOL CreateTexture(CKDWORD Texture,CKTextureDesc* DesiredFormat);
|
|
BOOL CreateVertexShader(CKDWORD VShader,CKVertexShaderDesc* DesiredFormat);
|
|
BOOL CreatePixelShader(CKDWORD PShader,CKPixelShaderDesc* DesiredFormat);
|
|
BOOL CreateVertexBuffer(CKDWORD VB,CKVertexBufferDesc* DesiredFormat);
|
|
BOOL CreateIndexBuffer(CKDWORD IB,CKIndexBufferDesc* DesiredFormat);
|
|
|
|
BOOL TextureCanUseAutoGenMipMap( D3DFORMAT TextureFormat, CKTextureDesc* iTextureDesc=NULL );
|
|
|
|
void UpdateTextureBPL(CKDWORD Texture);
|
|
|
|
//---- Cleanup
|
|
void FlushNonManagedObjects();
|
|
void ReleaseIndexBuffers();
|
|
void ClearStreamCache();
|
|
void ReleaseScreenBackup();
|
|
void ResetDevice();
|
|
CKDWORD DX9PresentInterval(DWORD PresentInterval);
|
|
#ifdef _NOD3DX
|
|
BOOL LoadSurface(const D3DSURFACE_DESC& ddsd,const D3DLOCKED_RECT& LockRect,const VxImageDescEx& SurfDesc);
|
|
#endif
|
|
|
|
//--- Temp Z-Buffers for texture rendering...
|
|
void ReleaseTempZBuffers() {
|
|
for (int i=0;i<256;++i) {
|
|
SAFELASTRELEASE(m_TempZBuffers[i]);
|
|
}
|
|
}
|
|
|
|
//--- Temp rgba8 buffers for hardware shadow map rendering
|
|
void ReleaseTempRGBA8Buffers() {
|
|
for (int i=0;i<256;++i) {
|
|
SAFELASTRELEASE(m_TempRGBA8Buffers[i]);
|
|
}
|
|
}
|
|
|
|
LPDIRECT3DSURFACE9 GetTempZBuffer(int Width,int Height);
|
|
LPDIRECT3DSURFACE9 GetTempRGBA8Buffer(int Width, int Height);
|
|
|
|
public:
|
|
LPDIRECT3DDEVICE9 m_Device;
|
|
D3DPRESENT_PARAMETERS m_PresentParams;
|
|
VxDirectXData m_DirectXData;
|
|
BOOL m_SoftwareVertexProcessing;
|
|
BOOL m_SoftwareShader;
|
|
BOOL m_ResetLastFrame;
|
|
|
|
//----------------------------------------------------
|
|
//--- Index buffer filled when drawing primitives
|
|
CKDX9IndexBufferDesc* m_IndexBuffer[2]; // Clip/unclipped
|
|
|
|
//-----------------------------------------------------
|
|
//--- Render Target if rendering is redirected to a texture
|
|
LPDIRECT3DSURFACE9 m_DefaultBackBuffer; // Backup pointer of previous back buffer
|
|
LPDIRECT3DSURFACE9 m_DefaultDepthBuffer; // Backup pointer of previous depth buffer
|
|
|
|
volatile BOOL m_InCreateDestroy;
|
|
|
|
//--- For web content the render context can be transparent (no clear of backbuffer but instead
|
|
//--- a copy of what is currently on screen)
|
|
LPDIRECT3DSURFACE9 m_ScreenBackup;
|
|
|
|
//-------------------------------------------------
|
|
//--- to avoid redoundant calls to SetVertexShader & SetStreamSource :
|
|
//--- a cache with the current vertex format and source VB
|
|
CKDWORD m_CurrentVertexShaderCache;
|
|
CKDWORD m_CurrentVertexFormatCache;
|
|
LPDIRECT3DVERTEXBUFFER9 m_CurrentVertexBufferCache;
|
|
CKDWORD m_CurrentVertexSizeCache;
|
|
|
|
//--------------------------------------------------
|
|
// Render states which must be disabled or which values must be translated...
|
|
CKDWORD* m_TranslatedRenderStates[VXRENDERSTATE_MAXSTATE];
|
|
|
|
//-----------------------------------------------------
|
|
// + To do texture rendering, Z-buffers are created when
|
|
// needed for any given size (power of two)
|
|
// These Z buffers are stored in the rasterizer context
|
|
// TempZbuffers array and are attached when doing
|
|
// texture rendering
|
|
LPDIRECT3DSURFACE9 m_TempZBuffers[NBTEMPZBUFFER];
|
|
LPDIRECT3DSURFACE9 m_TempRGBA8Buffers[NBTEMPZBUFFER]; // dummy color buffers for hw shadow maps rendering
|
|
|
|
#ifdef _XBOX
|
|
XHashTable<D3DVertexDeclaration *,CKDWORD> m_VDeclHash;
|
|
#endif
|
|
|
|
D3DMULTISAMPLE_TYPE ComputeValidD3DMultiSampleType(D3DFORMAT backbufferFormat, BOOL windowed, CKDWORD numWantedSamples);
|
|
|
|
void CreateOffscreenMultiSampledFramebuffer(int width, int height, int sampleCount);
|
|
void ReleaseOffscreenMultiSampledFramebuffer();
|
|
CKBOOL TurnTextureIntoRenderTarget(CKDWORD texture);
|
|
|
|
IDirect3DSurface9* _GetStretchRectSurface(CKDWORD texture,
|
|
CKRST_CUBEFACE cubeFace,
|
|
CKBOOL* mustRelease,
|
|
CKBOOL* isInDefaultPool,
|
|
CKBOOL ensureRenderTarget
|
|
);
|
|
|
|
CKBOOL _StretchRectWithDP(IDirect3DSurface9* destSurf, CKRECT* destRect,
|
|
IDirect3DSurface9* srcSurf, CKDWORD srcTexture, CKRECT* srcRect, CKRST_CUBEFACE srcFace,
|
|
CKBOOL filter
|
|
);
|
|
|
|
// offscreen multisampled framebuffer
|
|
IDirect3DSurface9* m_OffsceenMultiSampledColorBuffer;
|
|
IDirect3DSurface9* m_OffsceenMultiSampledDepthStencil;
|
|
CKBOOL m_UseMultiSampledOffscreenFrameBuffer;
|
|
|
|
|
|
IDirect3DSurface9* m_MainDepthStencilSurface;
|
|
|
|
IDirect3DQuery9* m_OcclusionQuery;
|
|
|
|
};
|
|
|
|
/*****************************************************************
|
|
CKDX9RasterizerDriver overload
|
|
******************************************************************/
|
|
class CKDX9RasterizerDriver : public CKRasterizerDriver
|
|
{
|
|
public:
|
|
CKDX9RasterizerDriver(CKDX9Rasterizer* rst);
|
|
virtual ~CKDX9RasterizerDriver();
|
|
|
|
//--- Contexts
|
|
virtual CKRasterizerContext* CreateContext();
|
|
|
|
BOOL InitializeCaps(int AdapterIndex,D3DDEVTYPE DevType);
|
|
BOOL IsTextureFormatOk( D3DFORMAT TextureFormat, D3DFORMAT AdapterFormat, DWORD Usage = 0 );
|
|
|
|
D3DFORMAT FindNearestTextureFormat(CKTextureDesc* desc);
|
|
D3DFORMAT FindNearestRenderTargetFormat(int Bpp,BOOL Windowed);
|
|
D3DFORMAT FindNearestDepthFormat(D3DFORMAT pf,int ZBpp,int StencilBpp);
|
|
|
|
|
|
public:
|
|
BOOL m_Inited;
|
|
UINT m_AdapterIndex;
|
|
D3DDEVTYPE m_DevType;
|
|
D3DCAPS9 m_D3DCaps;
|
|
D3DADAPTER_IDENTIFIER9 m_D3DIdentifier;
|
|
XArray<D3DFORMAT> m_RenderFormats;
|
|
BOOL m_IsHTL; // Transfom & Lighting
|
|
};
|
|
|
|
|
|
/*****************************************************************
|
|
CKDX9Rasterizer overload
|
|
******************************************************************/
|
|
class CKDX9Rasterizer : public CKRasterizer
|
|
{
|
|
public:
|
|
CKDX9Rasterizer();
|
|
virtual ~CKDX9Rasterizer();
|
|
|
|
virtual BOOL Start(WIN_HANDLE AppWnd);
|
|
virtual void Close(void);
|
|
|
|
public:
|
|
BOOL m_Init;
|
|
LPDIRECT3D9 m_D3D9;
|
|
|
|
// Stage Blends
|
|
void InitBlendStages();
|
|
CKStageBlend* m_BlendStages[256];
|
|
};
|
|
|
|
|
|
#endif
|