965 lines
31 KiB
C++
965 lines
31 KiB
C++
///////////////////////////////////////////////////////////////////////////////
|
|
// 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
|