/*==========================================================================; * * Copyright (C) 1995-1997 Microsoft Corporation. All Rights Reserved. * * File: d3di.hpp * Content: Direct3D internal include file * * ***************************************************************************/ #ifndef _D3DI_HPP #define _D3DI_HPP // Allow fast path #define FAST_PATH #include "ddrawp.h" #include "d3d8p.h" #include "d3dmem.h" #if !defined(BUILD_DDDDK) extern "C" { #include "ddrawi.h" }; #include "lists.hpp" #include #include #include #include #include #include #include "ddi.h" //-------------------------------------------------------------------- const DWORD __INIT_VERTEX_NUMBER = 1024;// Initial number of vertices in TL and // clip flag buffers //-------------------------------------------------------------------- /* * Registry defines */ #define RESPATH "Software\\Microsoft\\Direct3D\\Drivers" #define RESPATH_D3D "Software\\Microsoft\\Direct3D" #define STATS_FONT_FACE "Terminal" #define STATS_FONT_SIZE 9 extern HINSTANCE hGeometryDLL; /* * CPU family and features flags */ extern DWORD dwCPUFamily, dwCPUFeatures; extern char szCPUString[]; // MMX available #define D3DCPU_MMX 0x00000001L // FCOMI and CMOV are both supported #define D3DCPU_FCOMICMOV 0x00000002L // Reads block until satisfied #define D3DCPU_BLOCKINGREAD 0x00000004L // Extended 3D support available #define D3DCPU_X3D 0x00000008L // Pentium II CPU #define D3DCPU_PII 0x000000010L // Streaming SIMD Extensions (aka Katmai) CPU #define D3DCPU_SSE 0x000000020L // Streaming SIMD2 Extensions (aka Willamete) CPU #define D3DCPU_WLMT 0x000000040L #define DEFAULT_GAMMA DTOVAL(1.4) /* INDEX_BATCH_SCALE is the constant which is used by DrawIndexedPrim to deterimine if the number of primitives being drawn is small relative to the number of vertices being passed. If it is then the prims are dereferenced in batches and sent to DrawPrim. */ #define INDEX_BATCH_SCALE 2 #endif // BUILD_DDDDK #if !defined(BUILD_DDDDK) class CD3DHal; class CStateSets; class CVertexVM; class CBaseTexture; class CD3DDDI; typedef CD3DDDI* LPD3DDDI; typedef class CD3DHal *LPD3DHAL; typedef class DIRECT3DLIGHTI *LPDIRECT3DLIGHTI; BOOL ValidatePixelShaderInternal( const DWORD* pCode, const D3DCAPS8* pCaps ); BOOL ValidateVertexShaderInternal( const DWORD* pCode, const DWORD* pDecl, const D3DCAPS8* pCaps ); #include "d3dhalp.h" //----------------------------------------------------------------------------- // Helper class to hold vertex element pointers and strides // class CVertexPointer { public: BYTE* pData[__NUMELEMENTS]; static UINT Stride[__NUMELEMENTS]; static UINT NumUsedElements; static UINT DataType[__NUMELEMENTS]; CVertexPointer() {} // Copy constructor CVertexPointer(CVertexPointer& vp) { for (UINT i=0; i < NumUsedElements; i++) { pData[i] = vp.pData[i]; } } // Copy constructor void operator=(CVertexPointer& vp) { for (UINT i=0; i < NumUsedElements; i++) { pData[i] = vp.pData[i]; } } void SetVertex(CVertexPointer& base, UINT index) { for (UINT i=0; i < NumUsedElements; i++) pData[i] = base.pData[i] + index * Stride[i]; } CVertexPointer& operator++(int) { for (UINT i=0; i < NumUsedElements; i++) pData[i] += Stride[i]; return *this; } }; //----------------------------------------------------------------------------- // Class to convert NPatches to RTPatches // class CNPatch2TriPatch { public: CNPatch2TriPatch(); ~CNPatch2TriPatch(); void MakeRectPatch(const CVertexPointer& pV0, const CVertexPointer& pV1, const CVertexPointer& pV2); CVStream m_InpStream[__NUMELEMENTS]; // Original vertex streams CTLStream* m_pOutStream[__NUMELEMENTS]; // Computed output vertex streams BYTE* m_pInpStreamMem[__NUMELEMENTS]; // Input stream memory BYTE* m_pOutStreamMem[__NUMELEMENTS]; // Output stream memory CVertexPointer m_InpVertex; // Pointers to elements of the first input vertex CVertexPointer m_OutVertex; // Pointers to elements of the first output vertex UINT m_PositionIndex; // Index in vertex element array UINT m_NormalIndex; // Index in vertex element array D3DORDERTYPE m_PositionOrder; D3DORDERTYPE m_NormalOrder; UINT m_FirstVertex; // Index of the first vertex in the // output buffer DWORD m_bNormalizeNormals; }; //----------------------------------------------------------------------------- // Function to compute lighting // typedef struct _LIGHT_VERTEX_FUNC_TABLE { LIGHT_VERTEX_FUNC pfnDirectional; LIGHT_VERTEX_FUNC pfnPointSpot; // Used in multi-loop pipeline PFN_LIGHTLOOP pfnDirectionalFirst; PFN_LIGHTLOOP pfnDirectionalNext; PFN_LIGHTLOOP pfnPointSpotFirst; PFN_LIGHTLOOP pfnPointSpotNext; } LIGHT_VERTEX_FUNC_TABLE; //--------------------------------------------------------------------- class DIRECT3DLIGHTI : public CD3DBaseObj { public: DIRECT3DLIGHTI() {m_LightI.flags = 0;} // VALID bit is not set HRESULT SetInternalData(); BOOL Enabled() {return (m_LightI.flags & D3DLIGHTI_ENABLED);} // TRUE is we need to send the light to the driver when switching // to the hardware vertex processing mode BOOL DirtyForDDI() {return (m_LightI.flags & D3DLIGHTI_UPDATEDDI);} void SetDirtyForDDI() {m_LightI.flags |= D3DLIGHTI_UPDATEDDI;} void ClearDirtyForDDI() {m_LightI.flags &= ~D3DLIGHTI_UPDATEDDI;} // TRUE is we need to send the "enable" state of the light to the driver // when switching to the hardware vertex processing mode BOOL EnableDirtyForDDI() {return (m_LightI.flags & D3DLIGHTI_UPDATE_ENABLE_DDI);} void SetEnableDirtyForDDI() {m_LightI.flags |= D3DLIGHTI_UPDATE_ENABLE_DDI;} void ClearEnableDirtyForDDI() {m_LightI.flags &= ~D3DLIGHTI_UPDATE_ENABLE_DDI;} LIST_MEMBER(DIRECT3DLIGHTI) m_List; // Active light list member D3DLIGHT8 m_Light; D3DI_LIGHT m_LightI; }; //--------------------------------------------------------------------- struct CPalette : public CD3DBaseObj { CPalette() { m_dirty = TRUE; } BOOL m_dirty; PALETTEENTRY m_pEntries[256]; }; #if DBG //--------------------------------------------------------------------- struct CRTPatchValidationInfo : public CD3DBaseObj { CRTPatchValidationInfo() { m_ShaderHandle = __INVALIDHANDLE; } DWORD m_ShaderHandle; }; #endif // DBG //--------------------------------------------------------------------- // // Bits for Runtime state flags (m_dwRuntimeFlags in CD3DBase) // // This bit set if UpdateManagedTextures() needs to be called const DWORD D3DRT_NEED_TEXTURE_UPDATE = 1 << 1; // We are in recording state set mode const DWORD D3DRT_RECORDSTATEMODE = 1 << 2; // We are in execution state set mode // In this mode the front-and executes recorded states but does not pass // them to the driver (the states will be passed using a set state handle) const DWORD D3DRT_EXECUTESTATEMODE = 1 << 3; // const DWORD D3DRT_LOSTSURFACES = 1 << 4; // Set when D3DRS_SOFTWAREVERTEXPROCESSING is TRUE const DWORD D3DRT_RSSOFTWAREPROCESSING = 1 << 5; // Set when device does not support point sprites const DWORD D3DRT_DOPOINTSPRITEEMULATION = 1 << 6; // Set when input stream has point size. It is computed in the SetVertexShaderI const DWORD D3DRT_POINTSIZEINVERTEX = 1 << 7; // Set when D3DRS_POINTSIZE != 1.0 const DWORD D3DRT_POINTSIZEINRS = 1 << 8; // Set when // - shader has been changed. // - when ForceFVFRecompute has been called const DWORD D3DRT_SHADERDIRTY = 1 << 9; // This bit set if UpdateDirtyStreams() needs to be called const DWORD D3DRT_NEED_VB_UPDATE = 1 << 11; // This bit set if we need to update vertex shader constants in the driver const DWORD D3DRT_NEED_VSCONST_UPDATE = 1 << 12; // Set if device can handle only 2 floats per texture coord set const DWORD D3DRT_ONLY2FLOATSPERTEXTURE = 1 << 13; // Set if device cannot handle projected textures, so we need to emulate them const DWORD D3DRT_EMULATEPROJECTEDTEXTURE = 1 << 14; // Set if a directional light is present in the active light list const DWORD D3DRT_DIRECTIONALIGHTPRESENT = 1 << 15; // Set if a point/spot light is present in the active light list const DWORD D3DRT_POINTLIGHTPRESENT = 1 << 16; // Set if current primitive is user memory primitive const DWORD D3DRT_USERMEMPRIMITIVE = 1 << 17; // Set if reg key to disallow Non-Versioned (FF.FF) pixel shaders was set on device create const DWORD D3DRT_DISALLOWNVPSHADERS = 1 << 18; // Set when MaxPointSize in the device is greater than 1.0 const DWORD D3DRT_SUPPORTSPOINTSPRITES = 1 << 19; // Set when we need to do NPatch to RTPatch conversion const DWORD D3DRT_DONPATCHCONVERSION = 1 << 20; const DWORD D3DRT_POINTSIZEPRESENT = D3DRT_POINTSIZEINRS | D3DRT_POINTSIZEINVERTEX; //--------------------------------------------------------------------- // // Bits for D3DFRONTEND flags (dwFEFlags in CD3DHal) // const DWORD D3DFE_WORLDMATRIX_DIRTY = 1 << 0; // World matrix dirty bits const DWORD D3DFE_TLVERTEX = 1 << 5; const DWORD D3DFE_PROJMATRIX_DIRTY = 1 << 8; const DWORD D3DFE_VIEWMATRIX_DIRTY = 1 << 9; // Set when we need to check world-view matrix for orthogonality const DWORD D3DFE_NEEDCHECKWORLDVIEWVMATRIX = 1 << 10; // Set when some state has been changed and we have to go through the slow path // to update state. // Currently the bit is set when one of the following bits is set: // D3DFE_PROJMATRIX_DIRTY // D3DFE_VIEWMATRIX_DIRTY // D3DFE_WORLDMATRIX_DIRTY // D3DFE_VERTEXBLEND_DIRTY // D3DFE_LIGHTS_DIRTY // D3DFE_MATERIAL_DIRTY // D3DFE_FVF_DIRTY // D3DFE_CLIPPLANES_DIRTY // OutputFVF has been changed // const DWORD D3DFE_FRONTEND_DIRTY = 1 << 11; const DWORD D3DFE_NEED_TRANSFORM_LIGHTS = 1 << 14; const DWORD D3DFE_MATERIAL_DIRTY = 1 << 15; const DWORD D3DFE_CLIPPLANES_DIRTY = 1 << 16; const DWORD D3DFE_LIGHTS_DIRTY = 1 << 18; // This bit is set when vertex blending state is dirty const DWORD D3DFE_VERTEXBLEND_DIRTY = 1 << 19; // Set if the Current Transformation Matrix has been changed // Reset when frustum planes in the model space have been computed const DWORD D3DFE_FRUSTUMPLANES_DIRTY = 1 << 20; const DWORD D3DFE_WORLDVIEWMATRIX_DIRTY = 1 << 21; const DWORD D3DFE_FVF_DIRTY = 1 << 22; // This bit set if mapping DX6 texture blend modes to renderstates is desired const DWORD D3DFE_MAP_TSS_TO_RS = 1 << 24; const DWORD D3DFE_INVWORLDVIEWMATRIX_DIRTY = 1 << 25; // This bit set if texturing is disabled const DWORD D3DFE_DISABLE_TEXTURES = 1 << 28; // Clip matrix is used to transform user clipping planes // to the clipping space const DWORD D3DFE_CLIPMATRIX_DIRTY = 1 << 29; // HAL supports Transformation and Lighting const DWORD D3DFE_TLHAL = 1 << 30; const DWORD D3DFE_TRANSFORM_DIRTY = D3DFE_PROJMATRIX_DIRTY | D3DFE_VIEWMATRIX_DIRTY | D3DFE_WORLDMATRIX_DIRTY | D3DFE_VERTEXBLEND_DIRTY; // Are we in a scene? const DWORD D3DDEVBOOL_HINTFLAGS_INSCENE = 1 << 0; // Means the FPU is already in preferred state. const DWORD D3DDEVBOOL_HINTFLAGS_FPUSETUP = 1 << 3; //--------------------------------------------------------------------- // Bits for transform.dwFlags // //--------------------------------------------------------------------- typedef struct _D3DFE_TRANSFORM { D3DMATRIXI proj; D3DMATRIXI mPC; // Mproj * Mclip D3DMATRIXI mVPCI; // Inverse Mview * PC, used to transform clipping planes D3DVECTORH userClipPlane[D3DMAXUSERCLIPPLANES]; } D3DFE_TRANSFORM; typedef void (*D3DFEDestroyProc)(LPD3DHAL lpD3DDevI); //--------------------------------------------------------------------- #ifdef _IA64_ // Removes IA64 compiler alignment warnings #pragma pack(16) #endif #ifdef _AXP64_ // Removes AXP64 compiler alignment warnings #pragma pack(16) #endif // We modify the compiler generated VTable for CD3DHal object. To make // life easy, all virtual functions are defined in CD3DHal. Also since // DEVICEI has multiple inheritance, there are more than 1 VTable. // Currently we assume that it only inherits from IDirect3DDevice7 and // D3DFE_PROCESSVERTICES and, in that order! Thus IDirect3DDevice7 and // CD3DHal share the same vtable. This is the VTable we copy and // modify. The define below is the total entries in this vtable. It is the // sum of the methods in IDirect3DDevice7 (incl. IUnknown) (49) and all the // virtual methods in CD3DHal () #define D3D_NUM_API_FUNCTIONS (49) #define D3D_NUM_VIRTUAL_FUNCTIONS (D3D_NUM_API_FUNCTIONS+38) // These constants are based on the assumption that rsVec array is an array // of 32-bit intergers const D3D_RSVEC_SHIFT = 5; // log2(sizeof(DWORD)*8); const D3D_RSVEC_MASK = sizeof(DWORD) * 8 - 1; //----------------------------------------------------------------------------- // The class is used to maintain a packed array of bits // class CPackedBitArray { public: CPackedBitArray() {m_pArray = NULL;} ~CPackedBitArray() {delete m_pArray;} // This function could be called to re-allocate the array. All data from the // previous array is copied into new array HRESULT Init(UINT size) { // Size in bytes UINT allocsize = ((size + D3D_RSVEC_MASK) >> D3D_RSVEC_SHIFT) << 2; DWORD* pNew = (DWORD*)new BYTE[allocsize]; if (pNew == NULL) return E_OUTOFMEMORY; memset(pNew, 0, allocsize); if (m_pArray) { // User asks to re-allocate the array memcpy(pNew, m_pArray, m_sizeInBytes); delete m_pArray; } m_pArray = pNew; m_size = size; m_sizeInBytes = allocsize; return S_OK; } UINT GetSize() {return m_size;} void ClearBit(DWORD index) { #if DBG CheckIndex(index); #endif m_pArray[index >> D3D_RSVEC_SHIFT] &= ~(1 << (index & D3D_RSVEC_MASK)); } void SetBit(DWORD index) { #if DBG CheckIndex(index); #endif m_pArray[index >> D3D_RSVEC_SHIFT] |= 1 << (index & D3D_RSVEC_MASK); } BOOL IsBitSet(DWORD index) { #if DBG CheckIndex(index); #endif return (m_pArray[index >> D3D_RSVEC_SHIFT] & (1ul << (index & D3D_RSVEC_MASK))) != 0; } private: DWORD* m_pArray; UINT m_sizeInBytes; UINT m_size; // Number of elements (bits) in the array #if DBG void CheckIndex(UINT index); #endif // DBG }; //----------------------------------------------------------------------------- // Map DX8 texture filter enum to D3DTEXTUREMAGFILTER const texf2texfg[] = { D3DTFG_POINT, // D3DTEXF_NONE = 0, D3DTFG_POINT, // D3DTEXF_POINT = 1, D3DTFG_LINEAR, // D3DTEXF_LINEAR = 2, D3DTFG_ANISOTROPIC, // D3DTEXF_ANISOTROPIC = 3, D3DTFG_FLATCUBIC, // D3DTEXF_FLATCUBIC = 4, D3DTFG_GAUSSIANCUBIC, // D3DTEXF_GAUSSIANCUBIC = 5, }; // Map DX8 texture filter enum to D3DTEXTUREMINFILTER const texf2texfn[] = { D3DTFN_POINT, // D3DTEXF_NONE = 0, D3DTFN_POINT, // D3DTEXF_POINT = 1, D3DTFN_LINEAR, // D3DTEXF_LINEAR = 2, D3DTFN_ANISOTROPIC, // D3DTEXF_ANISOTROPIC = 3, D3DTFN_LINEAR, // D3DTEXF_FLATCUBIC = 4, D3DTFN_LINEAR, // D3DTEXF_GAUSSIANCUBIC = 5, }; // Map DX8 texture filter enum to D3DTEXTUREMIPFILTER const texf2texfp[] = { D3DTFP_NONE, // D3DTEXF_NONE = 0, D3DTFP_POINT, // D3DTEXF_POINT = 1, D3DTFP_LINEAR, // D3DTEXF_LINEAR = 2, D3DTFP_LINEAR, // D3DTEXF_ANISOTROPIC = 3, D3DTFP_LINEAR, // D3DTEXF_FLATCUBIC = 4, D3DTFP_LINEAR, // D3DTEXF_GAUSSIANCUBIC = 5, }; ///////////////////////////////////////////////////////////////////////////// // // // CD3DBase // // // ///////////////////////////////////////////////////////////////////////////// class CD3DBase : public CBaseDevice { public: // IDirect3DDevice8 Methods HRESULT D3DAPI ResourceManagerDiscardBytes(DWORD cbBytes); // 5 HRESULT D3DAPI SetRenderTarget(IDirect3DSurface8 *pRenderTarget, IDirect3DSurface8 *pZStencil); // 31 HRESULT D3DAPI GetRenderTarget(IDirect3DSurface8 **ppRenderTarget); // 32 HRESULT D3DAPI GetDepthStencilSurface(IDirect3DSurface8 **ppZStencil); // 33 HRESULT D3DAPI BeginScene(); // 34 HRESULT D3DAPI EndScene(); // 35 HRESULT D3DAPI Clear( DWORD dwCount, CONST D3DRECT* rects, DWORD dwFlags, D3DCOLOR dwColor, D3DVALUE dvZ, DWORD dwStencil); // 36 HRESULT D3DAPI SetTransform(D3DTRANSFORMSTATETYPE, CONST D3DMATRIX*); // 37 HRESULT D3DAPI GetTransform(D3DTRANSFORMSTATETYPE, LPD3DMATRIX); // 38 HRESULT D3DAPI MultiplyTransform(D3DTRANSFORMSTATETYPE, CONST D3DMATRIX*); // 39 HRESULT D3DAPI SetViewport(CONST D3DVIEWPORT8*); // 40 HRESULT D3DAPI GetViewport(D3DVIEWPORT8*); // 41 HRESULT D3DAPI SetMaterial(CONST D3DMATERIAL8*); // 42 HRESULT D3DAPI GetMaterial(D3DMATERIAL8*); // 43 HRESULT D3DAPI SetLight(DWORD, CONST D3DLIGHT8*); // 44 HRESULT D3DAPI GetLight(DWORD, D3DLIGHT8*); // 45 HRESULT D3DAPI LightEnable(DWORD dwLightIndex, BOOL); // 46 HRESULT D3DAPI GetLightEnable(DWORD dwLightIndex, BOOL*); // 47 HRESULT D3DAPI SetClipPlane(DWORD dwPlaneIndex, CONST D3DVALUE* pPlaneEquation); // 48 HRESULT D3DAPI GetClipPlane(DWORD dwPlaneIndex, D3DVALUE* pPlaneEquation); // 49 HRESULT D3DAPI SetRenderState(D3DRENDERSTATETYPE, DWORD); // 50 HRESULT D3DAPI GetRenderState(D3DRENDERSTATETYPE, LPDWORD); // 51 HRESULT D3DAPI BeginStateBlock(); // 52 HRESULT D3DAPI EndStateBlock(LPDWORD); // 53 HRESULT D3DAPI ApplyStateBlock(DWORD); // 54 HRESULT D3DAPI CaptureStateBlock(DWORD Handle); // 55 HRESULT D3DAPI DeleteStateBlock(DWORD); // 56 HRESULT D3DAPI CreateStateBlock(D3DSTATEBLOCKTYPE sbt, LPDWORD pdwHandle); // 57 HRESULT D3DAPI SetClipStatus(CONST D3DCLIPSTATUS8*); // 58 HRESULT D3DAPI GetClipStatus(D3DCLIPSTATUS8*); // 59 HRESULT D3DAPI GetTexture(DWORD, IDirect3DBaseTexture8**); // 60 HRESULT D3DAPI SetTexture(DWORD, IDirect3DBaseTexture8*); // 61 HRESULT D3DAPI GetTextureStageState(DWORD, D3DTEXTURESTAGESTATETYPE, LPDWORD); // 62 HRESULT D3DAPI SetTextureStageState(DWORD dwStage, D3DTEXTURESTAGESTATETYPE dwState, DWORD dwValue); // 63 HRESULT D3DAPI ValidateDevice(LPDWORD lpdwNumPasses); // 64 HRESULT D3DAPI GetInfo(DWORD dwDevInfoID, LPVOID pDevInfoStruct, DWORD dwSize); // 65 HRESULT D3DAPI SetPaletteEntries(UINT PaletteNumber, CONST PALETTEENTRY *pEntries); // 66 HRESULT D3DAPI GetPaletteEntries(UINT PaletteNumber, PALETTEENTRY *pEntries); // 67 HRESULT D3DAPI SetCurrentTexturePalette(UINT PaletteNumber); // 68 HRESULT D3DAPI GetCurrentTexturePalette(UINT *PaletteNumber); // 69 HRESULT D3DAPI DrawPrimitive(D3DPRIMITIVETYPE PrimType, UINT StartVertex, UINT VertexCount); // 70 HRESULT D3DAPI DrawIndexedPrimitive(D3DPRIMITIVETYPE, UINT minIndex, UINT maxIndex, UINT startIndex, UINT count); // 71 HRESULT D3DAPI DrawPrimitiveUP( D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST VOID *pVertexStreamZeroData, UINT VertexStreamZeroStride); // 72 HRESULT D3DAPI DrawIndexedPrimitiveUP( D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertexIndices, UINT PrimitiveCount, CONST VOID *pIndexData, D3DFORMAT IndexDataFormat, CONST VOID *pVertexStreamZeroData, UINT VertexStreamZeroStride); // 73 HRESULT D3DAPI ProcessVertices(UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer8 *pDestBuffer, DWORD Flags); // 74 HRESULT D3DAPI CreateVertexShader(CONST DWORD* pdwDeclaration, CONST DWORD* pdwFunction, DWORD* pdwHandle, DWORD dwUsage); // 75 HRESULT D3DAPI SetVertexShader(DWORD dwHandle); // 76 HRESULT D3DAPI GetVertexShader(LPDWORD pdwHandle); // 77 HRESULT D3DAPI DeleteVertexShader(DWORD dwHandle); // 78 HRESULT D3DAPI SetVertexShaderConstant(DWORD dwRegisterAddress, CONST VOID* lpvConstantData, DWORD dwConstantCount); // 79 HRESULT D3DAPI GetVertexShaderConstant(DWORD dwRegisterAddress, LPVOID lpvConstantData, DWORD dwConstantCount); // 80 HRESULT D3DAPI GetVertexShaderDeclaration(DWORD dwHandle, void *pData, DWORD *pSizeOfData); // 81 HRESULT D3DAPI GetVertexShaderFunction(DWORD dwHandle, void *pData, DWORD *pSizeOfData); // 82 HRESULT D3DAPI SetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer8 *pStreamData, UINT Stride); // 83 HRESULT D3DAPI GetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer8 **ppStreamData, UINT* pStride); // 84 HRESULT D3DAPI SetIndices(IDirect3DIndexBuffer8 *pIndexData, UINT BaseVertexIndex); // 85 HRESULT D3DAPI GetIndices(IDirect3DIndexBuffer8 **ppIndexData, UINT* pBaseVertexIndex); // 86 HRESULT D3DAPI CreatePixelShader(CONST DWORD* pdwFunction, LPDWORD pdwHandle); // 87 HRESULT D3DAPI SetPixelShader(DWORD dwHandle); // 88 HRESULT D3DAPI GetPixelShader(LPDWORD pdwHandle); // 89 HRESULT D3DAPI DeletePixelShader(DWORD dwHandle); // 90 HRESULT D3DAPI SetPixelShaderConstant(DWORD dwRegisterAddress, CONST VOID* lpvConstantData, DWORD dwConstantCount); // 91 HRESULT D3DAPI GetPixelShaderConstant(DWORD dwRegisterAddress, LPVOID lpvConstantData, DWORD dwConstantCount); // 92 HRESULT D3DAPI GetPixelShaderFunction(DWORD dwHandle, void *pData, DWORD *pSizeOfData); // 93 HRESULT D3DAPI DrawRectPatch(UINT Handle, CONST FLOAT *pNumSegs, CONST D3DRECTPATCH_INFO *pSurf); // 94 HRESULT D3DAPI DrawTriPatch(UINT Handle, CONST FLOAT *pNumSegs, CONST D3DTRIPATCH_INFO *pSurf); // 95 HRESULT D3DAPI DeletePatch(UINT Handle); // 96 public: // Flags to indicate runtime state DWORD m_dwRuntimeFlags; // D3DDEVBOOL flags DWORD m_dwHintFlags; // This should only be accessed through // CurrentBatch and IncrementBatchCount ULONGLONG m_qwBatch; // The object encapsulating the DDI styles // At the minimum this is a DX6 driver. LPD3DDDIDX6 m_pDDI; #if DBG // Debug Monitor D3DDebugMonitor* m_pDbgMonBase; // base class only RTDebugMonitor* m_pDbgMon; // runtime monitor BOOL m_bDbgMonConnectionEnabled; void DebugEvent( UINT32 EventType ) { if (m_pDbgMon) m_pDbgMon->NextEvent( EventType ); } void DebugStateChanged( UINT32 StateType ) { if (m_pDbgMon) m_pDbgMon->StateChanged( StateType ); } #else void DebugEvent( UINT32 ) { }; void DebugStateChanged( UINT32 ) { }; #endif // Pointer to texture objects for currently installed textures. // NULL indicates that the texture is either not set (rstate NULL) or that // the handle to tex3 pointer mapping is not done. This mapping is // expensive, so it is deferred until needed. This is needed for finding // the WRAPU,V mode for texture index clipping (since the WRAPU,V state is // part of the device). CBaseTexture* m_lpD3DMappedTexI[D3DHAL_TSS_MAXSTAGES]; DWORD m_dwDDITexHandle[D3DHAL_TSS_MAXSTAGES]; // Max number of blend stages supported by a driver DWORD m_dwMaxTextureBlendStages; DWORD m_dwStageDirty, m_dwStreamDirty; // Object to record state sets CStateSets* m_pStateSets; // // The following is for validation only // // Max TSS that can be passed to the driver D3DTEXTURESTAGESTATETYPE m_tssMax; // Max RS that can be passed to the driver, used for CanHandleRenderState D3DRENDERSTATETYPE m_rsMax; #if defined(PROFILE4) || defined(PROFILE) DWORD m_dwProfStart, m_dwProfStop; #endif // This bit array is used to tell if a light has been created or not CPackedBitArray* m_pCreatedLights; // DX8 related stuff from here ------------------------------------- // The current shader handle. It is initialized to Zero. // Zero means that there is no current shader. User always has to // initialize the shader. // It is used only by non-pure device DWORD m_dwCurrentShaderHandle; // The current pixel shader handle. It is initialized to zero, and // is set to zero for legacy pixel processing // It is used only by non-pure device DWORD m_dwCurrentPixelShaderHandle; // This object gives us pixel shader handles CHandleFactory* m_pPShaderArray; // This object gives us vertex shader handles CVShaderHandleFactory* m_pVShaderArray; // Vertex sctreams CVStream* m_pStream; // Index stream CVIndexStream* m_pIndexStream; // Max number of streams allowed. For D3D software it is __NUMSTREAMS // For hardware T&L it could be smaller DWORD m_dwNumStreams; // Max number of user clipping streams supported DWORD m_dwMaxUserClipPlanes; // Currently set palette DWORD m_dwPalette; // Palette array CHandleArray *m_pPaletteArray; #if DBG // Needed for RT-Patch validation CHandleArray *m_pRTPatchValidationInfo; // Needed for VB warnings DWORD m_SceneStamp; #endif // DBG // Function pointers for DrawPrimitive processing PFN_DRAWPRIMFAST m_pfnDrawPrim; PFN_DRAWINDEXEDPRIMFAST m_pfnDrawIndexedPrim; // Function pointers for DrawPrimitive processing from NPatch // conversion function in case of point or line primitives PFN_DRAWPRIMFAST m_pfnDrawPrimFromNPatch; PFN_DRAWINDEXEDPRIMFAST m_pfnDrawIndexedPrimFromNPatch; // Number of constant register. This could be different for software and // hardware vertex processing UINT m_MaxVertexShaderConst; #ifdef FAST_PATH #define NUMVTBLENTRIES 135 VOID **m_pOrigVtbl; VOID *m_pVtbl[NUMVTBLENTRIES]; void FastPathSetRenderStateExecute() { if((BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0) { m_pVtbl[50] = m_pVtbl[98]; } else { DXGASSERT(m_pVtbl[50] == m_pOrigVtbl[50]); } } void FastPathSetRenderStateRecord() { m_pVtbl[50] = m_pOrigVtbl[50]; } void FastPathSetTextureStageStateExecute() { if((BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0) { m_pVtbl[63] = m_pVtbl[99]; } else { DXGASSERT(m_pVtbl[63] == m_pOrigVtbl[63]); } } void FastPathSetTextureStageStateRecord() { m_pVtbl[63] = m_pOrigVtbl[63]; } void FastPathSetTextureExecute() { if((BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0) { m_pVtbl[61] = m_pVtbl[100]; } else { DXGASSERT(m_pVtbl[61] == m_pOrigVtbl[61]); } } void FastPathSetTextureRecord() { m_pVtbl[61] = m_pOrigVtbl[61]; } void FastPathApplyStateBlockExecute() { if((BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0) { m_pVtbl[54] = m_pVtbl[101]; } else { DXGASSERT(m_pVtbl[54] == m_pOrigVtbl[54]); } } void FastPathApplyStateBlockRecord() { m_pVtbl[54] = m_pOrigVtbl[54]; } void FastPathSetVertexShaderFast() { if((m_dwRuntimeFlags & (D3DRT_RECORDSTATEMODE | D3DRT_RSSOFTWAREPROCESSING)) == 0 && (BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0) { m_pVtbl[76] = m_pVtbl[102]; } else { DXGASSERT(m_pVtbl[76] == m_pOrigVtbl[76]); } } void FastPathSetVertexShaderSlow() { m_pVtbl[76] = m_pOrigVtbl[76]; } void FastPathSetStreamSourceFast() { if((m_dwRuntimeFlags & (D3DRT_RECORDSTATEMODE | D3DRT_RSSOFTWAREPROCESSING)) == 0 && (BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0) { m_pVtbl[83] = m_pVtbl[103]; } else { DXGASSERT(m_pVtbl[83] == m_pOrigVtbl[83]); } } void FastPathSetStreamSourceSlow() { m_pVtbl[83] = m_pOrigVtbl[83]; } void FastPathSetIndicesFast() { if((m_dwRuntimeFlags & (D3DRT_RECORDSTATEMODE | D3DRT_RSSOFTWAREPROCESSING)) == 0 && (BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0) { m_pVtbl[85] = m_pVtbl[104]; } else { DXGASSERT(m_pVtbl[85] == m_pOrigVtbl[85]); } } void FastPathSetIndicesSlow() { m_pVtbl[85] = m_pOrigVtbl[85]; } void FastPathSetTransformExecute() { if((BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0 && (BehaviorFlags() & D3DCREATE_PUREDEVICE) != 0) { m_pVtbl[37] = m_pVtbl[105]; } else { DXGASSERT(m_pVtbl[37] == m_pOrigVtbl[37]); } } void FastPathSetTransformRecord() { m_pVtbl[37] = m_pOrigVtbl[37]; } void FastPathMultiplyTransformExecute() { if((BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0 && (BehaviorFlags() & D3DCREATE_PUREDEVICE) != 0) { m_pVtbl[39] = m_pVtbl[106]; } else { DXGASSERT(m_pVtbl[39] == m_pOrigVtbl[39]); } } void FastPathMultiplyTransformRecord() { m_pVtbl[39] = m_pOrigVtbl[39]; } void FastPathSetMaterialExecute() { if((BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0) { m_pVtbl[42] = m_pVtbl[107]; } else { DXGASSERT(m_pVtbl[42] == m_pOrigVtbl[42]); } } void FastPathSetMaterialRecord() { m_pVtbl[42] = m_pOrigVtbl[42]; } void FastPathSetPixelShaderExecute() { if((BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0) { m_pVtbl[88] = m_pVtbl[108]; } else { DXGASSERT(m_pVtbl[88] == m_pOrigVtbl[88]); } } void FastPathSetPixelShaderRecord() { m_pVtbl[88] = m_pOrigVtbl[88]; } void FastPathSetPixelShaderConstantExecute() { if((BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0) { m_pVtbl[91] = m_pVtbl[109]; } else { DXGASSERT(m_pVtbl[91] == m_pOrigVtbl[91]); } } void FastPathSetPixelShaderConstantRecord() { m_pVtbl[91] = m_pOrigVtbl[91]; } void FastPathSetVertexShaderConstantExecute() { if((BehaviorFlags() & D3DCREATE_MULTITHREADED) == 0 && (BehaviorFlags() & D3DCREATE_PUREDEVICE) != 0) { m_pVtbl[79] = m_pVtbl[110]; } else { DXGASSERT(m_pVtbl[79] == m_pOrigVtbl[79]); } } void FastPathSetVertexShaderConstantRecord() { m_pVtbl[79] = m_pOrigVtbl[79]; } #endif // FAST_PATH public: CD3DBase(); virtual ~CD3DBase(); // 97 virtual HRESULT D3DAPI SetRenderStateFast(D3DRENDERSTATETYPE dwState, DWORD value); // 98 virtual HRESULT D3DAPI SetTextureStageStateFast(DWORD dwStage, D3DTEXTURESTAGESTATETYPE dwState, DWORD dwValue); // 99 virtual HRESULT D3DAPI SetTextureFast(DWORD, IDirect3DBaseTexture8 *lpTex); // 100 virtual HRESULT D3DAPI ApplyStateBlockFast(DWORD); // 101 #ifdef FAST_PATH virtual HRESULT D3DAPI SetVertexShaderFast(DWORD); // 102 virtual HRESULT D3DAPI SetStreamSourceFast(UINT StreamNumber, IDirect3DVertexBuffer8 *pStreamData, UINT Stride); // 103 virtual HRESULT D3DAPI SetIndicesFast(IDirect3DIndexBuffer8 *pIndexData, UINT BaseVertexIndex); // 104 virtual HRESULT D3DAPI SetTransformFast(D3DTRANSFORMSTATETYPE, CONST D3DMATRIX*); // 105 virtual HRESULT D3DAPI MultiplyTransformFast(D3DTRANSFORMSTATETYPE, CONST D3DMATRIX*); // 106 #endif // FAST_PATH virtual HRESULT D3DAPI SetMaterialFast(CONST D3DMATERIAL8*); // 107 virtual HRESULT D3DAPI SetPixelShaderFast(DWORD dwHandle); // 108 virtual HRESULT D3DAPI SetPixelShaderConstantFast(DWORD dwRegisterAddress, // 109 CONST VOID* lpvConstantData, DWORD dwConstantCount); virtual HRESULT D3DAPI SetVertexShaderConstantFast(DWORD dwRegisterAddress, // 110 CONST VOID* lpvConstantData, DWORD dwConstantCount); virtual void Destroy(); // 111 // Virtual methods for CBaseDevice virtual HRESULT InitDevice(); // 112 virtual void StateInitialize(BOOL bZEnable); // 113 virtual void UpdateRenderState(DWORD dwStateType, DWORD value) {} // 114 virtual void SetTransformI(D3DTRANSFORMSTATETYPE, CONST D3DMATRIX*); // 115 virtual void MultiplyTransformI(D3DTRANSFORMSTATETYPE, CONST D3DMATRIX*); // 116 virtual void SetClipPlaneI(DWORD dwPlaneIndex, // 117 CONST D3DVALUE* pPlaneEquation); virtual void UpdateDriverStates(){ DDASSERT( FALSE ); } // 118 virtual void SetViewportI(CONST D3DVIEWPORT8*); // 119 virtual void SetStreamSourceI(CVStream*); // 120 virtual void SetIndicesI(CVIndexStream*); // 121 virtual void CreateVertexShaderI(CONST DWORD* pdwDeclaration, // 122 DWORD dwDeclSize, CONST DWORD* pdwFunction, DWORD dwCodeSize, DWORD dwHandle); virtual void SetVertexShaderI(DWORD dwHandle); // 123 virtual void DeleteVertexShaderI(DWORD dwHandle); // 124 virtual void SetVertexShaderConstantI(DWORD dwRegisterAddress, // 125 CONST VOID* lpvConstantData, DWORD dwConstantCount); virtual void DrawPointsI(D3DPRIMITIVETYPE PrimitiveType, // 126 UINT StartVertex, UINT PrimitiveCount); virtual void SetLightI(DWORD dwLightIndex, CONST D3DLIGHT8*); // 127 virtual void LightEnableI(DWORD dwLightIndex, BOOL); // 128 virtual void SetRenderStateInternal(D3DRENDERSTATETYPE, DWORD); // 129 virtual void DrawPrimitiveUPI(D3DPRIMITIVETYPE PrimitiveType, // 130 UINT PrimitiveCount); virtual void DrawIndexedPrimitiveUPI(D3DPRIMITIVETYPE PrimitiveType, // 131 UINT MinVertexIndex, UINT NumVertexIndices, UINT PrimitiveCount); virtual void GetPixelShaderConstantI(DWORD Register, DWORD count, // 132 LPVOID pData ); virtual void ClearI( DWORD dwCount, CONST D3DRECT* rects, DWORD dwFlags, // 133 D3DCOLOR dwColor, D3DVALUE dvZ, DWORD dwStencil); // Picks the right DrawPrimitive and DrawIndexedPrimitive function to // execute // Call this function when // - vertex shader is changed // - stream source is changed // - D3DRS_CLIPPING is changed // - resource has been changed // // Base device implementation is empty, because the function pointers are // initialized in the constructor and do not change virtual void __declspec(nothrow) PickDrawPrimFn() {}; // 134 protected: void ValidateDraw(D3DPRIMITIVETYPE primType, UINT StartVertex, UINT PrimitiveCount, UINT NumVertices, BOOL bIndexPrimitive, BOOL bUsedMemPrimitive); void CheckIndices(CONST BYTE* pIndices, UINT NumIndices, UINT StartIndex, UINT MinIndex, UINT NumVertices, UINT IndexStride); void CheckViewport(CONST D3DVIEWPORT8* lpData); void CheckVertexShaderHandle(DWORD dwHandle); void CheckPixelShaderHandle(DWORD dwHandle); inline void ClearVertexShaderHandle() { m_dwCurrentShaderHandle = 0; } public: // non virtual methods HRESULT __declspec(nothrow) Init(); HRESULT VerifyTexture(DWORD dwStage, IDirect3DBaseTexture8 *lpTex); HRESULT CalcDDSurfInfo(BOOL bUpdateZBufferFields); // Re-creates hardware pixel and vertex shaders after device is reset HRESULT ResetShaders(); void __declspec(nothrow) NeedResourceStateUpdate() { this->m_dwRuntimeFlags |= (D3DRT_NEED_TEXTURE_UPDATE | D3DRT_NEED_VB_UPDATE); // We shouldn't call PickDrawPrimFn when the device is being destroyed if (m_pDDI) PickDrawPrimFn(); } HRESULT __declspec(nothrow) SetRenderTargetI(CBaseSurface* pTarget, CBaseSurface* pZ); // Checks if we can pass the render state to the driver BOOL CanHandleRenderState(D3DRENDERSTATETYPE type) { if (type >= m_rsMax) { // not an error condition because we don't send front-end stuff to // non-TL Hal devices, for example, but don't send to HAL anyway return FALSE; } return TRUE; }; void UpdateTextures(); void UpdatePalette(CBaseTexture *pTex, DWORD Palette, DWORD dwStage, BOOL bSavedWithinPrimitive); HRESULT __declspec(nothrow) TexBlt(CBaseTexture *lpDst, CBaseTexture* lpSrc, POINT *pPoint, RECTL *pRect); HRESULT __declspec(nothrow) CubeTexBlt(CBaseTexture *lpDstParent, CBaseTexture* lpSrcParent, DWORD dwDestFaceHandle, DWORD dwSrcFaceHandle, POINT *pPoint, RECTL *pRect); HRESULT __declspec(nothrow) VolBlt(CBaseTexture *lpDst, CBaseTexture* lpSrc, DWORD dwDestX, DWORD dwDestY, DWORD dwDestZ, D3DBOX *pBox); HRESULT __declspec(nothrow) BufBlt(CBuffer *lpDst, CBuffer* lpSrc, DWORD dwOffset, D3DRANGE* pRange); HRESULT __declspec(nothrow) SetPriority(CResource *pRes, DWORD dwPriority); HRESULT __declspec(nothrow) SetTexLOD(CBaseTexture *pTex, DWORD dwLOD); HRESULT __declspec(nothrow) AddDirtyRect(CBaseTexture *pTex, CONST RECTL *pRect); HRESULT __declspec(nothrow) AddCubeDirtyRect(CBaseTexture *pTex, DWORD dwFaceHandle, CONST RECTL *pRect); HRESULT __declspec(nothrow) AddDirtyBox(CBaseTexture *pTex, CONST D3DBOX *pBox); void __declspec(nothrow) CleanupTextures(); void __declspec(nothrow) OnTextureDestroy(CBaseTexture*); ULONGLONG __declspec(nothrow) CurrentBatch() { DDASSERT(m_qwBatch > 0); return m_qwBatch; } void IncrementBatchCount(); void __declspec(nothrow) Sync(ULONGLONG batch) { if (m_qwBatch <= batch) { FlushStatesNoThrow(); } } HRESULT __declspec(nothrow) ValidateFVF(DWORD dwFVF); void __declspec(nothrow) FlushStatesNoThrow(); #if DBG #define PROF_DRAWPRIMITIVEDEVICE2 0x0003 #define PROF_DRAWINDEXEDPRIMITIVEDEVICE2 0x0004 #define PROF_DRAWPRIMITIVESTRIDED 0x0005 #define PROF_DRAWINDEXEDPRIMITIVESTRIDED 0x0006 #define PROF_DRAWPRIMITIVEDEVICE3 0x0007 #define PROF_DRAWINDEXEDPRIMITIVEDEVICE3 0x0008 #define PROF_DRAWPRIMITIVEVB 0x0009 #define PROF_DRAWINDEXEDPRIMITIVEVB 0x000a DWORD dwCaller; DWORD dwPrimitiveType[PROF_DRAWINDEXEDPRIMITIVEVB+1]; DWORD dwVertexType1[PROF_DRAWINDEXEDPRIMITIVEVB+1]; DWORD dwVertexType2[PROF_DRAWINDEXEDPRIMITIVEVB+1]; void Profile(DWORD, D3DPRIMITIVETYPE, DWORD); #else #define Profile(a,b,c) #endif friend class CD3DDDIDX6; }; typedef CD3DBase *LPD3DBASE; ///////////////////////////////////////////////////////////////////////////// // // // CD3DHal // // // ///////////////////////////////////////////////////////////////////////////// typedef void (CD3DHal::* PFN_PREPARETODRAW)(UINT StartVertex); class CD3DHal : public CD3DBase { public: // Private Data // buffer for H vertices CAlignedBuffer32 HVbuf; // Front end data D3DFE_TRANSFORM transform; // Transformation state D3DCLIPSTATUS8 m_ClipStatus; // Pipeline state info D3DFE_PROCESSVERTICES* m_pv; // common data for D3D and PSGP DWORD dwFEFlags; // Front-end flags //--------------- Lights start ----------------------- // List of currently enabled lights LIST_ROOT(_dlights, DIRECT3DLIGHTI) m_ActiveLights; LIST_ROOT(name10,_SpecularTable) specular_tables; SpecularTable* specular_table; LIGHT_VERTEX_FUNC_TABLE *lightVertexFuncTable; // Light management support CHandleArray* m_pLightArray; //--------------- Lights end ----------------------- // Viewports D3DVIEWPORT8 m_Viewport; DWORD m_clrCount; // Number of rects allocated LPD3DRECT m_clrRects; // Rects used for clearing // Runtime copy of the renderstates LPDWORD rstates; // Runtime copy of texture stage states DWORD tsstates[D3DHAL_TSS_MAXSTAGES][D3DHAL_TSS_STATESPERSTAGE]; // Bit set for a render state means that we have to update internal front-end state // Otherwise we can go through a fast path CPackedBitArray rsVec; // Bit set for a render state means that the render state is retired CPackedBitArray rsVecRetired; // Bit set for a render state means that the render state is for vertex // processing only CPackedBitArray rsVertexProcessingOnly; // For every transformation matrix there is a bit, which is set if we need // to update driver state CPackedBitArray* pMatrixDirtyForDDI; // Pointer to a specific PrepareToDraw function PFN_PREPARETODRAW m_pfnPrepareToDraw; // Current vertex shader, corresponding to the dwCurrentShaderHandle // NULL for the fixed-function pipeline CVShader* m_pCurrentShader; // The instance of the class providing a guaranteed implementation D3DFE_PVFUNCSI* GeometryFuncsGuaranteed; // Pixel Shader constant registers cached for Hal device PVM_WORD m_PShaderConstReg[D3DPS_CONSTREG_MAX_DX8]; // Object, used to convert NPatches to TriPatches CNPatch2TriPatch* m_pConvObj; // Texture stages, which we need to remap, when number of output texture // coordinates is greater than number of input texture coordinates D3DFE_TEXTURESTAGE textureStageToRemap[D3DDP_MAXTEXCOORD]; // Number of texture stages to remap DWORD dwNumTextureStagesToRemap; virtual HRESULT D3DAPI SetRenderStateFast(D3DRENDERSTATETYPE dwState, DWORD value); virtual HRESULT D3DAPI SetTextureStageStateFast(DWORD dwStage, D3DTEXTURESTAGESTATETYPE dwState, DWORD dwValue); #ifdef FAST_PATH virtual HRESULT D3DAPI SetVertexShaderFast(DWORD); #endif // FAST_PATH virtual HRESULT D3DAPI SetMaterialFast(CONST D3DMATERIAL8*); virtual HRESULT D3DAPI SetPixelShaderFast(DWORD dwHandle); virtual HRESULT D3DAPI SetPixelShaderConstantFast(DWORD dwRegisterAddress, CONST VOID* lpvConstantData, DWORD dwConstantCount); public: CD3DHal(); virtual ~CD3DHal(); virtual void Destroy(); // // Pure Methods from CD3DBase implemented here // virtual HRESULT InitDevice(); virtual void StateInitialize(BOOL bZEnable); virtual void SetTransformI(D3DTRANSFORMSTATETYPE, CONST D3DMATRIX*); virtual void MultiplyTransformI(D3DTRANSFORMSTATETYPE, CONST D3DMATRIX*); virtual void SetViewportI(CONST D3DVIEWPORT8*); virtual void SetLightI(DWORD dwLightIndex, CONST D3DLIGHT8*); virtual void LightEnableI(DWORD dwLightIndex, BOOL); virtual void SetClipPlaneI(DWORD dwPlaneIndex, CONST D3DVALUE* pPlaneEquation); virtual void SetStreamSourceI(CVStream*); virtual void SetIndicesI(CVIndexStream*); virtual void CreateVertexShaderI(CONST DWORD* pdwDeclaration, DWORD dwDeclSize, CONST DWORD* pdwFunction, DWORD dwCodeSize, DWORD dwHandle); virtual void SetVertexShaderI(DWORD dwHandle); virtual void DeleteVertexShaderI(DWORD dwHandle); virtual void SetVertexShaderConstantI(DWORD dwRegisterAddress, CONST VOID* lpvConstantData, DWORD dwConstantCount); virtual void DrawPointsI(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount); virtual void DrawPrimitiveUPI(D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount); virtual void DrawIndexedPrimitiveUPI(D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertexIndices, UINT PrimitiveCount); virtual void ClearI( DWORD dwCount, CONST D3DRECT* rects, DWORD dwFlags, D3DCOLOR dwColor, D3DVALUE dvZ, DWORD dwStencil); // This function is used when in SetRenderTarget the driver context is // recreated virtual void UpdateDriverStates(); // 10 virtual void UpdateRenderState(DWORD dwStateType, DWORD value) {rstates[dwStateType] = value;} virtual void __declspec(nothrow) PickDrawPrimFn(); public: // non virtual methods // Called by drawing functions to prepare vertex stream pointers for // legacy vertex shaders void PrepareToDrawLegacy(UINT dwStartVertex); // Called by drawing functions to prepare vertex stream pointers for // programmable pipeline void PrepareToDrawVVM(UINT dwStartVertex); // Called by drawing functions to prepare vertex stream pointers for // fixed-function pipeline with declarations void PrepareToDraw(UINT dwStartVertex); // dwValue could be changed by the function, when we need to filter // PROJECTED bit. BOOL UpdateInternalTextureStageState(DWORD dwStage, D3DTEXTURESTAGESTATETYPE dwState, DWORD* dwValue); HRESULT checkDeviceSurface(LPDDRAWI_DDRAWSURFACE_LCL lpDDS, LPDDRAWI_DDRAWSURFACE_LCL lpZbuffer, LPGUID pGuid); void SetupFVFDataCommon(); void SetupFVFData(); void SwitchVertexProcessingMode(DWORD SoftwareMode); void DrawPoints(UINT StartVertex); void GetPixelShaderConstantI(DWORD Register, DWORD count, LPVOID pData ); void PrepareNPatchConversion(UINT PrimitiveCount, UINT StartVertex); BOOL NeedInternalTSSUpdate(DWORD dwState) { return dwState == D3DTSS_TEXCOORDINDEX || dwState >= D3DTSS_TEXTURETRANSFORMFLAGS || dwState == D3DTSS_COLOROP; } // Always use this function to update "rstates", because we have to // set some internal flags when "rstats" is changed. void UpdateInternalState(D3DRENDERSTATETYPE type, DWORD value); // Checks for 'retired' render state - returns TRUE if not retired BOOL CheckForRetiredRenderState(D3DRENDERSTATETYPE type) { if (!rsVecRetired.IsBitSet(type)) { // not retired return TRUE; } return FALSE; } // Update internal state inline void SetFogFlags(void); void ForceFVFRecompute(void) { dwFEFlags |= D3DFE_FVF_DIRTY | D3DFE_FRONTEND_DIRTY; m_pv->dwDeviceFlags &= ~(D3DDEV_POSITIONINCAMERASPACE | D3DDEV_NORMALINCAMERASPACE); m_dwRuntimeFlags |= D3DRT_SHADERDIRTY; }; void DisplayStats(); void SetRenderStateInternal(D3DRENDERSTATETYPE, DWORD); HRESULT Initialize(IUnknown* pUnkOuter, LPDDRAWI_DIRECTDRAW_INT pDDrawInt); HRESULT D3DFE_Create(); void D3DFE_Destroy(); void ValidateDraw2(D3DPRIMITIVETYPE primType, UINT StartVertex, UINT PrimitiveCount, UINT NumVertices, BOOL bIndexPrimitive, UINT StartIndex = 0); #if DBG void ValidateRTPatch(); #endif // DBG #if DBG #define PROF_DRAWPRIMITIVEDEVICE2 0x0003 #define PROF_DRAWINDEXEDPRIMITIVEDEVICE2 0x0004 #define PROF_DRAWPRIMITIVESTRIDED 0x0005 #define PROF_DRAWINDEXEDPRIMITIVESTRIDED 0x0006 #define PROF_DRAWPRIMITIVEDEVICE3 0x0007 #define PROF_DRAWINDEXEDPRIMITIVEDEVICE3 0x0008 #define PROF_DRAWPRIMITIVEVB 0x0009 #define PROF_DRAWINDEXEDPRIMITIVEVB 0x000a DWORD dwCaller; DWORD dwPrimitiveType[PROF_DRAWINDEXEDPRIMITIVEVB+1]; DWORD dwVertexType1[PROF_DRAWINDEXEDPRIMITIVEVB+1]; DWORD dwVertexType2[PROF_DRAWINDEXEDPRIMITIVEVB+1]; void Profile(DWORD, D3DPRIMITIVETYPE, DWORD); #else #define Profile(a,b,c) #endif public: // IDirect3DDevice8 Methods HRESULT D3DAPI GetViewport(D3DVIEWPORT8*); HRESULT D3DAPI GetMaterial(D3DMATERIAL8*); HRESULT D3DAPI GetTransform(D3DTRANSFORMSTATETYPE, LPD3DMATRIX); HRESULT D3DAPI GetLight(DWORD, D3DLIGHT8*); HRESULT D3DAPI GetLightEnable(DWORD dwLightIndex, BOOL*); HRESULT D3DAPI GetClipPlane(DWORD dwPlaneIndex, D3DVALUE* pPlaneEquation); HRESULT D3DAPI GetTextureStageState(DWORD, D3DTEXTURESTAGESTATETYPE, LPDWORD); HRESULT D3DAPI SetTextureStageState(DWORD dwStage, D3DTEXTURESTAGESTATETYPE dwState, DWORD dwValue); HRESULT D3DAPI GetRenderState(D3DRENDERSTATETYPE, LPDWORD); HRESULT D3DAPI SetRenderState(D3DRENDERSTATETYPE, DWORD); HRESULT D3DAPI SetClipStatus(CONST D3DCLIPSTATUS8*); HRESULT D3DAPI GetClipStatus(D3DCLIPSTATUS8*); HRESULT D3DAPI ProcessVertices(UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer8 *DestBuffer, DWORD Flags); HRESULT D3DAPI GetVertexShaderConstant(DWORD dwRegisterAddress, LPVOID lpvConstantData, DWORD dwConstantCount); HRESULT D3DAPI GetPixelShaderConstant(DWORD dwRegisterAddress, LPVOID lpvConstantData, DWORD dwConstantCount); HRESULT D3DAPI GetVertexShader(LPDWORD pdwHandle); HRESULT D3DAPI GetPixelShader(LPDWORD pdwHandle); }; //--------------------------------------------------------------------- // macros to characterize device // #define IS_DX7HAL_DEVICE(lpDevI) ((lpDevI)->GetDDIType() >= D3DDDITYPE_DX7) #define IS_DX8HAL_DEVICE(lpDevI) ((lpDevI)->GetDDIType() >= D3DDDITYPE_DX8) #define IS_FPU_SETUP(lpDevI) ((lpDevI)->m_dwHintFlags & D3DDEVBOOL_HINTFLAGS_FPUSETUP ) #define IS_HAL_DEVICE(lpDevI) ((lpDevI)->GetDeviceType() == D3DDEVTYPE_HAL) #define IS_HEL_DEVICE(lpDevI) ((lpDevI)->GetDeviceType() == D3DDEVTYPE_EMULATION) #define IS_REF_DEVICE(lpDevI) ((lpDevI)->GetDeviceType() == D3DDEVTYPE_REF) #endif // @@END_MSINTERNAL #endif /* _D3DI_H */