#ifndef CKRASTERIZERDX8_H
#define CKRASTERIZERDX8_H "$Id:$"
/*************************************************************************/
/*	File : CKDX8Rasterizer.h											 */
/*	Author : Romain Sididris											 */	
/*																		 */	
/*	+ Direct X 8 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 2000, All Rights Reserved.					 */	
/*************************************************************************/

// Ensure we are using correct DirectDraw version
#define DIRECTDRAW_VERSION 0x0801

#ifdef _XBOX
	#define D3DCOMPILE_PUREDEVICE 1
	#include <Xtl.h>
#else
	#define _NOD3DX

	#include <d3d8.h>
	#include <d3dx8.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 CKDX8PixelFormatUtils.cpp :

D3DFORMAT		VxPixelFormatToD3DFormat8(VX_PIXELFORMAT pf);
VX_PIXELFORMAT	D3DFormatToVxPixelFormat8(D3DFORMAT ddpf);

D3DFORMAT	TextureDescToD3DFormat8(CKTextureDesc* desc);
void		D3DFormatToTextureDesc8(D3DFORMAT ddpf,CKTextureDesc* desc);


//------

class CKDX8RasterizerDriver;
class CKDX8RasterizerContext;
class CKDX8Rasterizer;

typedef BOOL (*SetDXRenderStateFunc)(CKDX8RasterizerContext* ctx,CKDWORD Value);
typedef BOOL (*GetDXRenderStateFunc)(CKDX8RasterizerContext* 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 CKStageBlend8 {	
	D3DTEXTUREOP Cop;
	CKDWORD		 Carg1;
	CKDWORD		 Carg2;
	D3DTEXTUREOP Aop;
	CKDWORD		 Aarg1;
	CKDWORD		 Aarg2;
} CKStageBlend;

/*******************************************
 A texture object for DX8 : contains the
 texture surface pointer
*********************************************/
typedef struct CKDX8TextureDesc : public CKTextureDesc 
{
public:
	union {
		LPDIRECT3DTEXTURE8		DxTexture;
		LPDIRECT3DCUBETEXTURE8	DxCubeTexture;
		LPDIRECT3DVOLUMETEXTURE8	DxVolumeTexture;
	};
//----- For render target textures...
	LPDIRECT3DTEXTURE8		DxRenderTexture;
//----- For non managed surface to be locked (DX8 does not support direct locking anymore)
	LPDIRECT3DSURFACE8		DxLockedSurface;
	DWORD					LockedFlags;
public:
	CKDX8TextureDesc() { DxTexture=NULL; DxRenderTexture=NULL; DxLockedSurface = NULL;}
	~CKDX8TextureDesc() { 

#ifdef _XBOX
		int refcount;
#define FREE_RESOURCE(p)	if(p->Common & 0x01000000){ /*D3DCREATED*/\
									refcount = p->Release();\
							}else{\
								D3D_FreeContiguousMemory((void*)(p->Data | 0x80000000));\
								delete p;\
							}
		if(DxTexture){
			DxTexture->BlockUntilNotBusy();
			FREE_RESOURCE(DxTexture);	
		}

		if(DxRenderTexture){
			DxRenderTexture->BlockUntilNotBusy();
			FREE_RESOURCE(DxRenderTexture);
		}

		if(DxLockedSurface){
			DxLockedSurface->BlockUntilNotBusy();
			FREE_RESOURCE(DxLockedSurface);
		}
#else
		SAFERELEASE(DxTexture);
		SAFERELEASE(DxRenderTexture);
		SAFERELEASE(DxLockedSurface);
#endif
	}
} CKDX8TextureDesc;


/********************************************
Same override for vertex buffers
*************************************************/
typedef struct CKDX8VertexBufferDesc : public CKVertexBufferDesc 
{
public:
	LPDIRECT3DVERTEXBUFFER8 DxBuffer;
public:
	CKDX8VertexBufferDesc() { 
		DxBuffer=NULL; 
	} 
	~CKDX8VertexBufferDesc() {	

#ifdef _XBOX
		int refcount = 0;
		if(DxBuffer){
			BYTE* Data=NULL;
			DxBuffer->Lock(0,0,(LPBYTE*)&Data,0);
			DxBuffer->Unlock();
			refcount = DxBuffer->Release();
		}
		if(refcount)
			int j = 0;
#else
		SAFERELEASE(DxBuffer);
#endif

	}
} CKDX8VertexBufferDesc;

/********************************************
Same override for index buffers
*************************************************/
typedef struct CKDX8IndexBufferDesc : public CKIndexBufferDesc 
{
public:
	LPDIRECT3DINDEXBUFFER8	DxBuffer;
public:
	CKDX8IndexBufferDesc() { DxBuffer=NULL;  }
	~CKDX8IndexBufferDesc() {
		
#ifdef _XBOX
		int refcount = 0;
		if(DxBuffer){
			BYTE* Data=NULL;
			DxBuffer->Lock(0,0,(LPBYTE*)&Data,0);
			DxBuffer->Unlock();
			refcount = DxBuffer->Release();
		}
		if(refcount)
			int j = 0;
#else
		SAFERELEASE(DxBuffer);
#endif

	}
} CKDX8IndexBufferDesc;


/********************************************
Vertex Shaders....
*************************************************/
typedef struct CKDX8VertexShaderDesc : public CKVertexShaderDesc 
{
public:
	CKDWORD						DxShader;
	CKDX8RasterizerContext*		Owner;
	XArray<BYTE>				m_FunctionData;
	
public:

	BOOL Create(CKDX8RasterizerContext* Ctx,CKVertexShaderDesc* Format);
	virtual ~CKDX8VertexShaderDesc();
	CKDX8VertexShaderDesc() { DxShader = 0; Owner = 0; }
} CKDX8VertexShaderDesc;


/********************************************
Pixel Shaders....
*************************************************/
typedef struct CKDX8PixelShaderDesc : public CKPixelShaderDesc 
{
public:
	CKDWORD						DxShader;
	CKDX8RasterizerContext*		Owner;

public:
	BOOL Create(CKDX8RasterizerContext* Ctx,CKDWORD* Function);
	virtual ~CKDX8PixelShaderDesc();
	CKDX8PixelShaderDesc() { DxShader = 0; Owner = 0; }
	
} CKDX8PixelShaderDesc;


/*****************************************************************
 CKDX8RasterizerContext override
******************************************************************/
class CKDX8RasterizerContext : public CKRasterizerContext
{
	friend class RCKRenderContext;
public:
//--- Construction/destruction
	CKDX8RasterizerContext(CKDX8RasterizerDriver* Driver);
	virtual ~CKDX8RasterizerContext();

//--- 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);

//--- 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);
	

//--- 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);

//--- For web content the render context can be transparent (no clear of backbuffer but instead
//--- a copy of what is currently on screen)
#ifndef _XBOX
	virtual void SetTransparentMode(BOOL Trans);
	virtual void RestoreScreenBackup();
#endif
	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);

#ifdef _XBOX
	void SetViewZone(const VxRect& Zone); 
	BOOL DrawSolidRect(const VxRect& Zone,DWORD Color);
	BOOL CreateTextureFromXpr(CKDWORD Texture,const char* Filename,TexFromFile* param);
	BOOL CreateTextureFromXprInMemory(CKDWORD Texture,void*mem,DWORD sz,TexFromFile* param);
#endif

protected:
//-----------------------	
	void	UpdateDirectXData();
	BOOL	InternalDrawPrimitiveVB(VXPRIMITIVETYPE pType,CKDX8VertexBufferDesc* VB,CKDWORD StartIndex,CKDWORD VertexCount,WORD* indices,int indexcount,BOOL Clip);
	void	SetupStreams(LPDIRECT3DVERTEXBUFFER8 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);


//---- Cleanup
	void FlushNonManagedObjects();
	void ReleaseIndexBuffers();
	void ClearStreamCache();
	void ReleaseScreenBackup();
	void ResetDevice();
	CKDWORD DX8PresentInterval(DWORD PresentInterval);

#ifdef _NOD3DX
	BOOL LoadSurface(const D3DSURFACE_DESC& ddsd,const D3DLOCKED_RECT& LockRect,const VxImageDescEx& SurfDesc);
#endif
public:
//--- Temp Z-Buffers for texture rendering...
	void ReleaseTempZBuffers() {
		for (int i=0;i<256;++i) {
			SAFELASTRELEASE(m_TempZBuffers[i]);
		}
	}

	LPDIRECT3DSURFACE8 GetTempZBuffer(int Width,int Height);


	LPDIRECT3DDEVICE8		m_Device;
	D3DPRESENT_PARAMETERS	m_PresentParams;
	VxDirectXData			m_DirectXData;
	BOOL					m_SoftwareVertexProcessing;
	BOOL					m_SoftwareShader;

//----------------------------------------------------
//--- Index buffer filled when drawing primitives
	CKDX8IndexBufferDesc*   m_IndexBuffer[2]; // Clip/unclipped	

//-----------------------------------------------------	
//--- Render Target if rendering is redirected to a texture
	LPDIRECT3DSURFACE8		m_DefaultBackBuffer;	// Backup pointer of previous back buffer
	LPDIRECT3DSURFACE8		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)
	LPDIRECT3DSURFACE8		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;
	LPDIRECT3DVERTEXBUFFER8		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 
	LPDIRECT3DSURFACE8	m_TempZBuffers[256];

#ifdef _XBOX
	VxRect					 m_ViewZone;
	CKViewportData			 m_DeviceViewport;

	int m_RealWidth;
	int	m_RealHeight;
	
	DWORD m_StageTextureInfo;
	VxMatrix m_TextureScaleMatrix[4];
	VxMatrix m_TextureMatrix[4];
#endif

};
#ifdef _XBOX

#define STAGE_LINEAR_MASK	0x0000000f
#define STAGE_YUV_MASK		0x000000f0
#define STAGE_YUV_DECAL		4

#define IS_STAGE_LINEAR(stage)		(m_StageTextureInfo&(1<<stage))
#define SET_STAGE_LINEAR(stage)		(m_StageTextureInfo|=(1<<stage))
#define REMOVE_STAGE_LINEAR(stage)	(m_StageTextureInfo&=~(1<<stage))

#define IS_STAGE_YUV(stage)		(m_StageTextureInfo& ((1<<stage)<<STAGE_YUV_DECAL))
#define SET_STAGE_YUV(stage)	(m_StageTextureInfo |=((1<<stage)<<STAGE_YUV_DECAL))
#define REMOVE_STAGE_YUV(stage)	(m_StageTextureInfo &=~((1<<stage)<<STAGE_YUV_DECAL))

#endif  
/*****************************************************************
 CKDX8RasterizerDriver overload 
******************************************************************/
class CKDX8RasterizerDriver : public CKRasterizerDriver
{
public:
	CKDX8RasterizerDriver(CKDX8Rasterizer* rst);
	virtual ~CKDX8RasterizerDriver();

//--- Contexts
	virtual CKRasterizerContext* CreateContext();

	BOOL InitializeCaps(int AdapterIndex);
	BOOL IsTextureFormatOk( D3DFORMAT TextureFormat, D3DFORMAT AdapterFormat );
	
	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;
	D3DCAPS8				 m_D3DCaps;
	D3DADAPTER_IDENTIFIER8	 m_D3DIdentifier;
	XArray<D3DFORMAT>		 m_RenderFormats;
	BOOL					 m_IsHTL;	// Transfom & Lighting
};


/*****************************************************************
 CKDX8Rasterizer overload 
******************************************************************/
class CKDX8Rasterizer : public CKRasterizer
{
public:
	CKDX8Rasterizer();
	virtual ~CKDX8Rasterizer();

	virtual BOOL Start(WIN_HANDLE AppWnd);
	virtual void Close(void);

public:
	BOOL							m_Init;
	LPDIRECT3D8						m_D3D8;

// Stage Blends
	void InitBlendStages();
	CKStageBlend*			m_BlendStages[256];
};


#endif