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

965 lines
31 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
///////////////////////////////////////////////////////////////////////////////
// Copyright (C) Microsoft Corporation, 1998.
//
// reftnl.hpp
//
// Direct3D Reference Transform and Lighting - Main Header File
//
///////////////////////////////////////////////////////////////////////////////
#ifndef _REFTNL_HPP
#define _REFTNL_HPP
#define RD_GB_LEFT -32768.f
#define RD_GB_TOP -32768.f
#define RD_GB_RIGHT 32767.f
#define RD_GB_BOTTOM 32767.f
//-----------------------------------------------------------------------------
//
// Constants
//
//-----------------------------------------------------------------------------
// Default color values that should be used when ther is no lighting and
// color in vertices provided
const DWORD RD_DEFAULT_DIFFUSE = 0xFFFFFFFF;
const DWORD RD_DEFAULT_SPECULAR = 0;
const DWORD RD_MAX_FVF_TEXCOORD = 8;
const DWORD RD_MAX_VERTEX_COUNT = 2048;
// Number of clipping planes
const DWORD RD_MAX_USER_CLIPPLANES = 6;
// Number of clipping planes
const DWORD RD_MAX_CLIPPING_PLANES = (6+RD_MAX_USER_CLIPPLANES);
// Number of blend weights
const DWORD RD_MAX_BLEND_WEIGHTS = 4;
// Number of world matrices
const DWORD RD_MAX_WORLD_MATRICES = 256;
const DWORD RD_WORLDMATRIXBASE = 256;
// Space for vertices generated/copied while clipping one triangle
const DWORD RD_MAX_CLIP_VERTICES = (( 2 * RD_MAX_CLIPPING_PLANES ) + 3 );
// 3 verts. -> 1 tri, 4 v -> 2 t, N vertices -> (N - 2) triangles
const DWORD RD_MAX_CLIP_TRIANGLES = ( RD_MAX_CLIP_VERTICES - 2 );
// make smaller than guard band for easier clipping
const float RD_MAX_POINT_SIZE = 64;
//-----------------------------------------------------------------------------
//
// Forward defines
//
//-----------------------------------------------------------------------------
class RDLight;
//-----------------------------------------------------------------------------
//
// Typedefs
//
//-----------------------------------------------------------------------------
typedef DWORD RDCLIPCODE;
typedef D3DMATRIX RDMATRIX;
//-----------------------------------------------------------------------------
//
// RDVertex - Internal vertex structure of the refrast. This is the
// structure exchanged between the T&L and Rasterization parts
// of the refrast.
//
//-----------------------------------------------------------------------------
class RDVertex
{
public:
RDVertex()
{
Init();
}
RDVertex( LPDWORD pVtx, DWORD dwFvf )
{
SetFvfData( pVtx, (UINT64)dwFvf );
}
RDVertex( LPDWORD pVtx, UINT64 qwFvf )
{
SetFvfData( pVtx, qwFvf );
}
RDCLIPCODE m_clip;
FLOAT m_clip_x;
FLOAT m_clip_y;
FLOAT m_clip_z;
FLOAT m_clip_w;
RDVECTOR3 m_pos; // This is screen coordinates
FLOAT m_rhw;
RDCOLOR4 m_diffuse; // ARGB (0..1 each component)
RDCOLOR4 m_specular; // ARGB
FLOAT m_fog; // 0..1
FLOAT m_pointsize;
RDVECTOR4 m_tex[8];
UINT64 m_qwFVF;
void Init()
{
m_clip = 0;
m_clip_x = m_clip_y = m_clip_z = m_clip_w = 0.0f;
m_rhw = 0.0f;
m_diffuse.a = m_diffuse.r = m_diffuse.g = m_diffuse.b = 1.0f;
m_specular.a = m_specular.r = m_specular.g = m_specular.b = 0.0f;
m_fog = 0.0f;
m_pointsize = 1.0f;
// Initialize texture coordinates to {0.0, 0.0, 0.0, 1.0}
memset( m_tex, 0, sizeof(m_tex) );
for( int i=0; i<8; i++ ) m_tex[i].w = 1.0f;
m_qwFVF = 0;
}
void SetFVF( UINT64 qwControl )
{
m_qwFVF = qwControl;
}
void SetFvfData( LPDWORD pVtx, UINT64 qwFVF )
{
DWORD cDWORD = 0;
Init();
m_qwFVF = qwFVF;
switch( qwFVF & D3DFVF_POSITION_MASK )
{
case D3DFVF_XYZRHW:
memcpy( &m_pos, pVtx, 3*sizeof( float ) );
pVtx += 3;
m_rhw = *(float *)(pVtx);
pVtx += 1;
break;
default:
_ASSERT( TRUE, "RDVertex can only hold Transformed Vertices" );
return;
}
if (qwFVF & D3DFVF_PSIZE)
{
m_pointsize = *(FLOAT*)pVtx;
pVtx++;
}
if (qwFVF & D3DFVF_DIFFUSE)
{
MakeRDCOLOR4( &m_diffuse, *pVtx );
pVtx++;
}
if (qwFVF & D3DFVF_SPECULAR)
{
MakeRDCOLOR4( &m_specular, *pVtx );
m_fog = m_specular.a;
m_qwFVF |= D3DFVFP_FOG;
pVtx++;
}
if (qwFVF & D3DFVF_FOG)
{
m_fog = *(FLOAT*)pVtx;
m_qwFVF |= D3DFVFP_FOG;
pVtx++;
}
DWORD dwNumTexCoord = (DWORD)(FVF_TEXCOORD_NUMBER(qwFVF));
DWORD dwTextureFormats = (DWORD)qwFVF >> 16;
// Texture formats size 00 01 10 11
static DWORD dwTextureSize[4] = {2, 3, 4, 1};
for (DWORD i=0; i < dwNumTexCoord; i++)
{
memcpy( &m_tex[i], pVtx,
sizeof( float )*dwTextureSize[dwTextureFormats & 3] );
pVtx += dwTextureSize[dwTextureFormats & 3];
dwTextureFormats >>= 2;
}
}
FLOAT GetRHW( void ) const
{
return ( m_qwFVF & D3DFVF_XYZRHW ) ? m_rhw : 1.f ;
}
FLOAT* GetPtrXYZ( void ) { return (FLOAT*)&m_pos; }
FLOAT GetX( void ) const { return m_pos.x; }
FLOAT GetY( void ) const { return m_pos.y; }
FLOAT GetZ( void ) const { return m_pos.z; }
DWORD GetDiffuse( void ) const
{
DWORD diff =
D3DRGBA(m_diffuse.r, m_diffuse.g, m_diffuse.b, m_diffuse.a);
// return color if available else white (default)
return ( m_qwFVF & D3DFVF_DIFFUSE ) ? diff : 0xffffffff;
}
DWORD GetSpecular( void ) const
{
DWORD spec =
D3DRGBA(m_specular.r, m_specular.g, m_specular.b, m_specular.a);
// return color if available else black (default)
return ( m_qwFVF & D3DFVF_SPECULAR ) ? spec : 0x00000000;
}
UINT TexCrdCount( void ) const
{
return
(UINT)(( m_qwFVF & D3DFVF_TEXCOUNT_MASK ) >> D3DFVF_TEXCOUNT_SHIFT);
}
FLOAT GetTexCrd( UINT iCrd, UINT iCrdSet ) const
{
// This function ensures that right defaults are returned.
// Note, except for the q coordinate (which defaults to 1.0)
// the rest are 0.0.
if( (iCrdSet < TexCrdCount()) &&
(iCrd < GetTexCoordDim(m_qwFVF, iCrdSet)) )
{
return *( (FLOAT*)&m_tex[iCrdSet] + iCrd );
}
else if( iCrd == 3 )
{
return 1.0f;
}
else
{
return 0.0f;
}
}
FLOAT GetLastTexCrd( UINT iCrdSet ) const
{
// Return the last texture coordinate if present else 1.0
if( iCrdSet < TexCrdCount() )
{
return *( (FLOAT*)&m_tex[iCrdSet] +
GetTexCoordDim(m_qwFVF, iCrdSet) - 1);
}
else
{
return 1.0f;
}
}
FLOAT GetPointSize( void ) const
{
return ( m_qwFVF & D3DFVF_PSIZE ) ? m_pointsize : 1.0f;
}
FLOAT GetFog( void ) const
{
return ( m_qwFVF & D3DFVFP_FOG ) ? m_fog : 0.0f;
}
};
class RDClipVertex : public RDVertex
{
public:
RDClipVertex()
{
next = NULL;
}
RDClipVertex *next;
};
struct RDCLIPTRIANGLE
{
RDCLIPTRIANGLE()
{
memset( this, 0, sizeof(*this) );
}
RDClipVertex *v[3];
};
struct RDUSERCLIPPLANE
{
RDUSERCLIPPLANE()
{
memset( this, 0, sizeof(*this) );
}
RDVECTOR4 plane;
BOOL bActive;
};
//-----------------------------------------------------------------------------
//
// RDTRANSFORMDATA - Transformation data used by Refrence T&L implementation
// to transform vertices.
//
//-----------------------------------------------------------------------------
struct RDTRANSFORMDATA
{
RDTRANSFORMDATA()
{
memset( this, 0, sizeof(*this) );
}
RDMATRIX m_PS; // Mproj * Mshift
RDMATRIX m_VPS; // Mview * PS
RDMATRIX m_VPSInv; // Inverse( Mview * PS )
RDMATRIX m_CTMI; // Inverse current transformation matrix
RDVECTOR4 m_frustum[6]; // Normalized plane equations for viewing
// frustum in the model space
DWORD m_dwFlags;
};
//---------------------------------------------------------------------
// RDLIGHTINGDATA
// All the lighting related state clubbed together
//---------------------------------------------------------------------
struct RDLIGHTINGDATA
{
RDLIGHTINGDATA()
{
memset( this, 0, sizeof(*this) );
}
// Active Light list
RDLight *pActiveLights;
// Temporary data used when computing lighting
RDVECTOR3 eye_in_eye; // eye position in eye space
// It is (0, 0, 0)
// Ma * La + Me (Ambient and Emissive) ------
RDCOLOR3 ambEmiss;
// ColorVertex stuff ------------------------
RDCOLOR3 *pAmbientSrc;
RDCOLOR3 *pDiffuseSrc;
RDCOLOR3 *pSpecularSrc;
RDCOLOR3 *pEmissiveSrc;
// Diffuse ----------------------------------
RDCOLOR3 vertexDiffuse; // Provided with a vertex, used if
// COLORVERTEX is enabled and a diffuse
// color is provided in the vertex
RDCOLOR3 diffuse; // Diffuse accumulates here
DWORD outDiffuse; // Diffuse color result of lighting
// Specular --------------------------------
RDCOLOR3 vertexSpecular;// Provided with a vertex, used if
// COLORVERTEX is enabled and a specular
// color is provided in the vertex
RDCOLOR3 specular; // Specular accumulates here
DWORD outSpecular; // Specular color result of lighting
D3DVALUE specThreshold; // If the dot product is less than this
// value, specular factor is zero
// End of temporary data
// RENDERSTATEAMBIENT --------------------------------------
// Ambient color set by D3DRENDERSTATE_AMBIENT
// They are all scaled to 0 - 1
D3DVALUE ambient_red;
D3DVALUE ambient_green;
D3DVALUE ambient_blue;
DWORD ambient_save; // Original unscaled color
// Fog -----------------------------------------------------
int fog_mode;
D3DCOLOR fog_color;
D3DVALUE fog_density;
D3DVALUE fog_start;
D3DVALUE fog_end;
D3DVALUE fog_factor; // 255 / (fog_end - fog_start)
D3DCOLORMODEL color_model;
// Material ------------------------------------------------
// For color material
LPDWORD pDiffuseAlphaSrc;
LPDWORD pSpecularAlphaSrc;
DWORD materialDiffAlpha; // Current material diffuse
// alpha (0-255) shifted left
// by 24 bits
DWORD materialSpecAlpha; // Current material specular
// alpha (0-255) shifted left
// by 24 bits
DWORD vertexDiffAlpha; // Current material diffuse
// alpha (0-255) shifted left
// by 24 bits
DWORD vertexSpecAlpha; // Current material specular
// alpha (0-255) shifted left
// by 24 bits
D3DMATERIAL7 material; // Cached material data
RDCOLOR3 matAmb;
RDCOLOR3 matDiff;
RDCOLOR3 matSpec;
RDCOLOR3 matEmis;
};
//-----------------------------------------------------------------------------
//
// RDLight - The light object used by the Reference T&L implementation
// An array of these are instanced in the RefDev object.
//
//-----------------------------------------------------------------------------
struct RDLIGHTI
{
RDLIGHTI()
{
memset( this, 0, sizeof(*this) );
}
DWORD flags;
RDVECTOR3 position_in_eye; // In the eye space
RDVECTOR3 direction_in_eye; // In the eye space
//
// Saved light colors scaled from 0 - 255, needed for COLORVERTEX
//
D3DCOLORVALUE La; // light ambient
D3DCOLORVALUE Ld; // light diffuse
D3DCOLORVALUE Ls; // light specular
//
// Precomputed colors scaled from 0 - 255,
//
D3DCOLORVALUE Ma_La; // Material ambient times light ambient
D3DCOLORVALUE Md_Ld; // Material diffuse times light diffuse
D3DCOLORVALUE Ms_Ls; // Material specular times light specular
RDVECTOR3 halfway;
// Stuff for SpotLights
D3DVALUE range_squared;
D3DVALUE cos_theta_by_2;
D3DVALUE cos_phi_by_2;
D3DVALUE inv_theta_minus_phi;
};
//-----------------------------------------------------------------------------
// Function pointer to the functions that light a vertex
//-----------------------------------------------------------------------------
typedef void (*RDLIGHTVERTEXFN)( RDLIGHTINGDATA& LData, D3DLIGHT7 *pLight,
RDLIGHTI *pLightI, RDLIGHTINGELEMENT *in,
DWORD dwFlags, UINT64 qwFVFIn );
//-----------------------------------------------------------------------------
// Functions to compute lighting
//-----------------------------------------------------------------------------
struct RDLIGHTVERTEX_FUNC_TABLE
{
RDLIGHTVERTEX_FUNC_TABLE()
{
memset( this, 0, sizeof(*this) );
}
RDLIGHTVERTEXFN pfnDirectional;
RDLIGHTVERTEXFN pfnParallelPoint;
RDLIGHTVERTEXFN pfnSpot;
RDLIGHTVERTEXFN pfnPoint;
};
//-----------------------------------------------------------------------------
//
// RDLight - The light object used by the Reference T&L implementation
// An array of these are instanced in the RefDev object.
//
//-----------------------------------------------------------------------------
#define RDLIGHT_ENABLED 0x00000001 // Is the light active
#define RDLIGHT_NEEDSPROCESSING 0x00000002 // Is the light data processed
#define RDLIGHT_REFERED 0x00000004 // Has the light been refered
// to
class RDLight : public RDAlloc
{
public:
RDLight();
BOOL IsEnabled() {return (m_dwFlags & RDLIGHT_ENABLED);}
BOOL NeedsProcessing() {return (m_dwFlags & RDLIGHT_NEEDSPROCESSING);}
BOOL IsRefered() { return (m_dwFlags & RDLIGHT_REFERED); }
HRESULT SetLight(LPD3DLIGHT7 pLight);
HRESULT GetLight( LPD3DLIGHT7 pLight );
void ProcessLight( D3DMATERIAL7 *mat, RDLIGHTVERTEX_FUNC_TABLE *pTbl);
void XformLight( D3DMATRIX* mV );
void Enable( RDLight **ppRoot );
void Disable( RDLight **ppRoot );
private:
// Flags
DWORD m_dwFlags;
// Active List next element
RDLight *m_Next;
// Specific function to light the vertex
RDLIGHTVERTEXFN m_pfnLightVertex;
// Light data set by the runtime
D3DLIGHT7 m_Light;
// Light data computed by the driver
RDLIGHTI m_LightI;
friend class RefDev;
friend class RefVP;
};
//---------------------------------------------------------------------
//
// The clipper object. Contains digested Viewport information
// calculated from viewport settings.
//
//---------------------------------------------------------------------
class RefClipper
{
public:
RefClipper();
// The pointer to the driver object to obtain state
RefDev* m_pDev;
// m_dwDirtyFlags
static const DWORD RCLIP_DIRTY_ZRANGE;
static const DWORD RCLIP_DIRTY_VIEWRECT;
static const DWORD RCLIP_DO_FLATSHADING;
static const DWORD RCLIP_DO_WIREFRAME;
static const DWORD RCLIP_DO_ADJUSTWRAP;
static const DWORD RCLIP_Z_ENABLE;
DWORD m_dwFlags;
// Viewport data from the DDI.
D3DVIEWPORT7 m_Viewport;
// Is it guardband or not ?
BOOL m_bUseGB;
D3DVALUE dvX; // dwX
D3DVALUE dvY; // dwY
D3DVALUE dvWidth; // dwWidth
D3DVALUE dvHeight; // dwHeight
// Coefficients to compute screen coordinates from normalized window
// coordinates
D3DVALUE scaleX; // dvWidth/2
D3DVALUE scaleY; // dvHeight/2
D3DVALUE scaleZ; // (Viewport->dvMaxZ - Viewport->dvMinZ)
D3DVALUE offsetX; // dvX + scaleX
D3DVALUE offsetY; // dvY + scaleY
D3DVALUE offsetZ; // Viewport->dvMinZ
// Coefficients to compute screen coordinates from normalized window
// coordinates
D3DVALUE scaleXi; // Inverse of scaleX
D3DVALUE scaleYi; // Inverse of scaleY
D3DVALUE scaleZi; // Inverse of scaleZ
// Min and max values for viewport window in pixels
D3DVALUE minX; // offsetX - scaleX
D3DVALUE minY; // offsetY - scaleY
D3DVALUE maxX; // offsetX + scaleX
D3DVALUE maxY; // offsetY + scaleY
// Min and max window values with guard band in pixels
D3DVALUE minXgb;
D3DVALUE minYgb;
D3DVALUE maxXgb;
D3DVALUE maxYgb;
// Coefficients to transform a vertex to perform the guard band clipping
// x*gb11 + w*gb41
// y*gb22 + w*gb42
//
D3DVALUE gb11;
D3DVALUE gb22;
D3DVALUE gb41;
D3DVALUE gb42;
// Coefficients to apply clipping rules for the guard band clipping
// They are used by clipping routins
// w*Kgbx1 < x < w*Kgbx2
// w*Kgby1 < y < w*Kgby2
//
D3DVALUE Kgbx1;
D3DVALUE Kgby1;
D3DVALUE Kgbx2;
D3DVALUE Kgby2;
// Clipping related
RDCLIPCODE m_clipUnion; // OR of all vertex clip flags
RDCLIPCODE m_clipIntersection; // AND of all vertex clip flags
GArrayT<RDVertex> ClipBuf;
RDClipVertex *clip_vbuf1[RD_MAX_CLIP_VERTICES];
RDClipVertex *clip_vbuf2[RD_MAX_CLIP_VERTICES];
RDClipVertex **current_vbuf; // clip_vbuf1 or clip_vbuf2
RDClipVertex clip_vertices[RD_MAX_CLIP_VERTICES];
DWORD m_dwInterpolate;
int clip_vertices_used;
RDCOLOR4 clip_color;
RDCOLOR4 clip_specular;
// User defined clipping planes
RDVECTOR4 m_userClipPlanes[RD_MAX_USER_CLIPPLANES];
// User clip planes transformed
RDUSERCLIPPLANE m_xfmUserClipPlanes[RD_MAX_USER_CLIPPLANES];
//---------------------------------------------------
// Methods
//---------------------------------------------------
HRESULT UpdateViewData();
void MakeClipVertexFromVertex( RDClipVertex& cv, RDVertex& v,
DWORD dwClipMask);
inline BOOL UseGuardBand() { return m_bUseGB; }
RDCLIPCODE ComputeClipCodes(RDCLIPCODE* pclipIntersection,
RDCLIPCODE* pclipUnion, FLOAT x_clip,
FLOAT y_clip, FLOAT z_clip, FLOAT w_clip);
void ComputeClipCodesTL( RDVertex* pVtx );
void Interpolate( RDClipVertex *out, RDClipVertex *p1, RDClipVertex *p2,
int code, D3DVALUE num, D3DVALUE denom );
int ClipByPlane( RDClipVertex **inv, RDClipVertex **outv, RDVECTOR4 *plane,
DWORD dwClipFlag, int count );
int ClipLineByPlane( RDCLIPTRIANGLE *line, RDVECTOR4 *plane,
DWORD dwClipBit);
void ComputeScreenCoordinates( RDClipVertex **inv, int count );
DWORD ComputeClipCodeGB( RDClipVertex *p );
DWORD ComputeClipCode( RDClipVertex *p );
#if 0
DWORD ComputeClipCodeUserPlanes( RDUSERCLIPPLANE *UserPlanes,
RDClipVertex *p);
#endif
int ClipLeft( RDClipVertex **inv, RDClipVertex **outv, int count);
int ClipRight( RDClipVertex **inv, RDClipVertex **outv, int count);
int ClipTop( RDClipVertex **inv, RDClipVertex **outv, int count);
int ClipBottom( RDClipVertex **inv, RDClipVertex **outv, int count);
int ClipFront( RDClipVertex **inv, RDClipVertex **outv, int count);
int ClipBack( RDClipVertex **inv, RDClipVertex **outv, int count);
int ClipLeftGB( RDClipVertex **inv, RDClipVertex **outv, int count);
int ClipRightGB( RDClipVertex **inv, RDClipVertex **outv, int count);
int ClipTopGB( RDClipVertex **inv, RDClipVertex **outv, int count);
int ClipBottomGB( RDClipVertex **inv, RDClipVertex **outv, int count);
int ClipLineLeft( RDCLIPTRIANGLE *inv);
int ClipLineRight( RDCLIPTRIANGLE *inv);
int ClipLineTop( RDCLIPTRIANGLE *inv);
int ClipLineBottom( RDCLIPTRIANGLE *inv);
int ClipLineFront( RDCLIPTRIANGLE *inv);
int ClipLineBack( RDCLIPTRIANGLE *inv);
int ClipLineLeftGB( RDCLIPTRIANGLE *inv);
int ClipLineRightGB( RDCLIPTRIANGLE *inv);
int ClipLineTopGB( RDCLIPTRIANGLE *inv);
int ClipLineBottomGB( RDCLIPTRIANGLE *inv);
int ClipSingleLine( RDCLIPTRIANGLE *line );
int ClipSingleTriangle( RDCLIPTRIANGLE *tri,
RDClipVertex ***clipVertexPointer );
void DrawPoint( RDVertex* pvV0 );
void DrawLine( RDVertex* pvV0, RDVertex* pvV1 );
void DrawTriangle( RDVertex* pvV0, RDVertex* pvV1, RDVertex* pvV2,
WORD wFlags = D3DTRIFLAG_EDGEENABLETRIANGLE );
HRESULT DrawOnePrimitive( GArrayT<RDVertex>& VtxArray,
DWORD dwStartVertex,
D3DPRIMITIVETYPE PrimType,
UINT cVertices );
HRESULT DrawOneIndexedPrimitive( GArrayT<RDVertex>& VtxArray,
int StartVertexIndex,
LPWORD pIndices,
DWORD StartIndex,
UINT cIndices,
D3DPRIMITIVETYPE PrimType );
HRESULT DrawOneIndexedPrimitive( GArrayT<RDVertex>& VtxArray,
int StartVertexIndex,
LPDWORD pIndices,
DWORD StartIndex,
UINT cIndices,
D3DPRIMITIVETYPE PrimType );
};
// RefVP::m_dwTLState flags
#define RDPV_DOLIGHTING 0x00000001
#define RDPV_DOCLIPPING 0x00000002
#define RDPV_DOFOG 0x00000004
#define RDPV_DOSPECULAR 0x00000008
#define RDPV_RANGEFOG 0x00000010
#define RDPV_NORMALIZENORMALS 0x00000020
#define RDPV_LOCALVIEWER 0x00000040
#define RDPV_DOCOMPUTEPOINTSIZE 0x00000080
#define RDPV_DOPOINTSCALE 0x00000100
#define RDPV_DOTEXXFORM 0x00000200
#define RDPV_DOTEXGEN 0x00000400
#define RDPV_NEEDEYEXYZ 0x00000800
#define RDPV_NEEDEYENORMAL 0x00001000
// ColorVertexFlags
#define RDPV_VERTEXDIFFUSENEEDED 0x00002000
#define RDPV_VERTEXSPECULARNEEDED 0x00004000
#define RDPV_COLORVERTEXAMB 0x00008000
#define RDPV_COLORVERTEXDIFF 0x00010000
#define RDPV_COLORVERTEXSPEC 0x00020000
#define RDPV_COLORVERTEXEMIS 0x00040000
#define RDPV_COLORVERTEXFLAGS (RDPV_VERTEXDIFFUSENEEDED | \
RDPV_VERTEXSPECULARNEEDED | \
RDPV_COLORVERTEXAMB | \
RDPV_COLORVERTEXDIFF | \
RDPV_COLORVERTEXSPEC | \
RDPV_COLORVERTEXEMIS )
#define RDPV_DOINDEXEDVERTEXBLEND 0x00100000
#define RDPV_DOPOSITIONTWEENING 0x00200000
#define RDPV_DONORMALTWEENING 0x00400000
// RefVP::m_dwDirtyFlags flags
#define RDPV_DIRTY_PROJXFM 0x00000001
#define RDPV_DIRTY_VIEWXFM 0x00000002
#define RDPV_DIRTY_WORLDXFM 0x00000004
#define RDPV_DIRTY_WORLD1XFM 0x00000008
#define RDPV_DIRTY_WORLD2XFM 0x00000010
#define RDPV_DIRTY_WORLD3XFM 0x00000020
#define RDPV_DIRTY_XFORM (RDPV_DIRTY_PROJXFM | \
RDPV_DIRTY_VIEWXFM | \
RDPV_DIRTY_WORLDXFM | \
RDPV_DIRTY_WORLD1XFM | \
RDPV_DIRTY_WORLD2XFM | \
RDPV_DIRTY_WORLD3XFM)
#define RDPV_DIRTY_MATERIAL 0x00000100
#define RDPV_DIRTY_SETLIGHT 0x00000200
#define RDPV_DIRTY_NEEDXFMLIGHT 0x00000400
#define RDPV_DIRTY_COLORVTX 0x00000800
#define RDPV_DIRTY_LIGHTING (RDPV_DIRTY_MATERIAL | \
RDPV_DIRTY_SETLIGHT | \
RDPV_DIRTY_NEEDXFMLIGHT | \
RDPV_DIRTY_COLORVTX)
#define RDPV_DIRTY_FOG 0x00010000
#define RDPV_DIRTY_INVERSEWORLDVIEW 0x00020000
//---------------------------------------------------------------------
// RDPTRSTRIDE: A class instanced once per vertex element.
//---------------------------------------------------------------------
class RDPTRSTRIDE
{
public:
RDPTRSTRIDE()
{
Null();
}
inline void Init( LPVOID pData, DWORD dwStride )
{
m_pData = m_pCurrent = pData;
m_dwStride = dwStride;
}
inline void Null()
{
memset( this, 0, sizeof( *this ) );
}
inline void SetStride( DWORD dwStride )
{
m_dwStride = dwStride;
}
inline DWORD GetStride()
{
return m_dwStride;
}
inline LPVOID GetFirst()
{
return m_pData;
}
inline LPVOID GetCurrent()
{
return m_pCurrent;
}
inline LPVOID Reset()
{
return (m_pCurrent = m_pData);
}
inline LPVOID Next()
{
m_pCurrent = (LPVOID)((LPBYTE)m_pCurrent + m_dwStride);
return m_pCurrent;
}
LPVOID operator []( DWORD dwIndex ) const
{
return (LPVOID)((LPBYTE)m_pData + dwIndex*m_dwStride);
}
protected:
LPVOID m_pData;
DWORD m_dwStride; // in number of bytes
LPVOID m_pCurrent;
DWORD m_dwCurrentIndex;
};
//---------------------------------------------------------------------
// Struct holding the shader ptr
//---------------------------------------------------------------------
struct RDVShaderHandle
{
RDVShaderHandle()
{
m_pShader = NULL;
#if DBG
m_tag = 0;
#endif
}
RDVShader* m_pShader;
#if DBG
// Non zero means that it has been allocated
DWORD m_tag;
#endif
};
//---------------------------------------------------------------------
// Fixed function vertex processing pipeline object
//---------------------------------------------------------------------
class RefVP : public RDAlloc
{
protected:
// The pointer to the driver object to obtain state
RefDev* m_pDev;
//-------------------------------------------------------------------------
// Unprocessed state set by the DDI
//-------------------------------------------------------------------------
// Growable Light array
GArrayT<RDLight> m_LightArray;
// Current material to use for lighting
D3DMATERIAL7 m_Material;
// Transformation state stored by the reference implementation
RDMATRIX m_xfmProj;
RDMATRIX m_xfmView;
RDMATRIX m_xfmWorld[RD_MAX_WORLD_MATRICES];
RDMATRIX m_xfmTex[D3DHAL_TSS_MAXSTAGES];
//-------------------------------------------------------------------------
// Vertex Elements
//-------------------------------------------------------------------------
RDPTRSTRIDE m_position;
RDPTRSTRIDE m_position2;
RDPTRSTRIDE m_blendweights;
RDPTRSTRIDE m_blendindices;
RDPTRSTRIDE m_normal;
RDPTRSTRIDE m_normal2;
RDPTRSTRIDE m_specular;
RDPTRSTRIDE m_diffuse;
RDPTRSTRIDE m_pointsize;
RDPTRSTRIDE m_tex[8];
//-------------------------------------------------------------------------
// Cached T&L related render-state info
//-------------------------------------------------------------------------
DWORD m_dwTLState; // RenderState related flags
DWORD m_dwDirtyFlags; // Dirty flags
//-------------------------------------------------------------------------
// Transformation data
//-------------------------------------------------------------------------
// Current transformation matrix
RDMATRIX m_xfmCurrent[RD_MAX_WORLD_MATRICES]; // using WORLDi matrix
RDMATRIX m_xfmToEye[RD_MAX_WORLD_MATRICES]; // Transforms to camera
// space (Mworld*Mview)
RDMATRIX m_xfmToEyeInv[RD_MAX_WORLD_MATRICES]; // and its Inverse
BYTE m_WorldProcessed[RD_MAX_WORLD_MATRICES];
UINT64 m_qwFVFIn; // FVF of the input vertices
UINT64 m_qwFVFOut; // FVF of the output vertices
int m_numVertexBlends;
RDTRANSFORMDATA m_TransformData;
FLOAT m_fPointSize;
FLOAT m_fPointAttA;
FLOAT m_fPointAttB;
FLOAT m_fPointAttC;
FLOAT m_fPointSizeMin;
FLOAT m_fPointSizeMax;
FLOAT m_fTweenFactor;
//-------------------------------------------------------------------------
// Lighting data
//-------------------------------------------------------------------------
RDLIGHTVERTEX_FUNC_TABLE m_LightVertexTable;
RDLIGHTINGDATA m_lighting; // Lighting state
DWORD m_dwNumActiveTextureStages;
///////////////////////////////////////////////////////////////////////////
// Methods
///////////////////////////////////////////////////////////////////////////
HRESULT UpdateXformData();
void UpdateWorld( DWORD i );
HRESULT UpdateLightingData();
HRESULT UpdateFogData();
RDCLIPCODE ProcessVertices( UINT64 outFVF, GArrayT<RDVertex>& VtxArray,
DWORD count );
void LightVertex( RDLIGHTINGELEMENT *le );
void FogVertex ( RDVertex& Vout, RDVECTOR3 &v, RDLIGHTINGELEMENT *le,
int numVertexBlends, float *pBlendFactors,
BOOL bVertexInEyeSpace );
public:
RefVP();
inline void LightEnable( DWORD dwIndex, BOOL bEnable )
{
if( bEnable )
{
m_LightArray[dwIndex].Enable(&m_lighting.pActiveLights);
m_dwDirtyFlags |= RDPV_DIRTY_SETLIGHT;
}
else
{
m_LightArray[dwIndex].Disable(&m_lighting.pActiveLights);
}
}
inline HRESULT SetLightData( DWORD dwIndex, D3DLIGHT7* pData )
{
HRESULT hr = S_OK;
HR_RET(m_LightArray[dwIndex].SetLight(pData));
m_dwDirtyFlags |= RDPV_DIRTY_SETLIGHT;
return S_OK;
}
HRESULT GrowLightArray( DWORD dwIndex );
friend class RefDev;
};
// Vertex Lighting functions
void RDLV_Directional( RDLIGHTINGDATA&, D3DLIGHT7 *, RDLIGHTI *,
RDLIGHTINGELEMENT *, DWORD, UINT64 );
void RDLV_PointAndSpot( RDLIGHTINGDATA&, D3DLIGHT7 *, RDLIGHTI *,
RDLIGHTINGELEMENT *, DWORD, UINT64 );
///////////////////////////////////////////////////////////////////////////////
#endif // _REFTNL_HPP
Reference in a new issue Copy permalink