able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/dxg/d3d8/inc/d3di.hpp

1376 lines
59 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*==========================================================================;
*
* 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 <d3ditype.h>
#include <d3dutil.h>
#include <d3dfe.hpp>
#include <vshader.hpp>
#include <pshader.hpp>
#include <rtdmon.hpp>
#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 */
Reference in a new issue Copy permalink