/////////////////////////////////////////////////////////////////////////////// // Copyright (C) Microsoft Corporation, 1998. // // reftnl.hpp // // Direct3D Reference Transform and Lighting - Main Header File // /////////////////////////////////////////////////////////////////////////////// #ifndef _REFTNL_HPP #define _REFTNL_HPP #define MAX_REFERENCE_LIGHTS 128 // Default color values that should be used when ther is no lighting and // color in vertices provided #define RR_DEFAULT_DIFFUSE 0xFFFFFFFF; #define RR_DEFAULT_SPECULAR 0; #define REF_GB_LEFT -32768.f #define REF_GB_TOP -32768.f #define REF_GB_RIGHT 32767.f #define REF_GB_BOTTOM 32767.f //---------------------------------------------------------------------------- // FVF related macros //---------------------------------------------------------------------------- const DWORD RRMAX_FVF_TEXCOORD = 8; //----------------------------------------------------------------------------- // // Typedefs // //----------------------------------------------------------------------------- // Number of clipping planes #define RRMAX_USER_CLIPPLANES 6 // Number of clipping planes #define RRMAX_CLIPPING_PLANES (6+RRMAX_USER_CLIPPLANES) // Number of world matrices #define RRMAX_WORLD_MATRICES 4 // Space for vertices generated/copied while clipping one triangle #define RRMAX_CLIP_VERTICES (( 2 * RRMAX_CLIPPING_PLANES ) + 3 ) // 3 verts. -> 1 tri, 4 v -> 2 t, N vertices -> (N - 2) triangles #define RRMAX_CLIP_TRIANGLES ( RRMAX_CLIP_VERTICES - 2 ) // make smaller than guard band for easier clipping #define RRMAX_POINT_SIZE ( REF_GB_RIGHT ) typedef DWORD RRCLIPCODE; typedef struct _RRCLIPVTX { D3DVALUE hx; D3DVALUE hy; D3DVALUE hz; D3DVALUE hw; DWORD clip; D3DCOLOR color; D3DCOLOR specular; D3DVALUE sx; D3DVALUE sy; D3DVALUE sz; D3DVALUE rhw; _RRCLIPVTX *next; D3DVALUE tex[RRMAX_FVF_TEXCOORD*4]; D3DVALUE s; D3DVALUE eyenx; D3DVALUE eyeny; D3DVALUE eyenz; D3DVALUE eyex; D3DVALUE eyey; D3DVALUE eyez; } RRCLIPVTX; typedef struct _RRCLIPTRIANGLE { RRCLIPVTX *v[3]; } RRCLIPTRIANGLE; typedef struct _RRUSERCLIPPLANE { RRVECTOR4 plane; BOOL bActive; } RRUSERCLIPPLANE, *LPRRUSERCLIPPLANE; //----------------------------------------------------------------------------- // // forward declarations, mostly from reftnli.hpp // //----------------------------------------------------------------------------- class RRMaterial; class RRLight; class RRTransform; //----------------------------------------------------------------------------- // // Base class for all RefTnL classes to use common allocation functions // //----------------------------------------------------------------------------- class RRAlloc { public: void* operator new(size_t s); void operator delete(void* p, size_t); }; //----------------------------------------------------------------------------- // // RRVECTORH - Homogeneous vector // //----------------------------------------------------------------------------- typedef struct tagRRVECTORH { D3DVALUE x; D3DVALUE y; D3DVALUE z; D3DVALUE w; } RRVECTORH, *PRRVECTORH; //----------------------------------------------------------------------------- // // RRMATRIX - Matrix data-structure // //----------------------------------------------------------------------------- typedef enum tagRRMATRIXTYPE { RRMatrixIdentity, RRMatrixTranslate, RRMatrixRotateTranslate, RRMatrixAffine, RRMatrixGeneral } RRMATRIXTYPE; typedef D3DMATRIX RRMATRIX; //----------------------------------------------------------------------------- // // RRTRANSFORMDATA - Transformation data used by Refrence T&L implementation // to transform vertices. // //----------------------------------------------------------------------------- typedef struct tagRRTRANSFORMDATA { RRMATRIX m_PS; // Mproj * Mshift RRMATRIX m_VPS; // Mview * PS RRMATRIX m_VPSInv; // Inverse( Mview * PS ) RRMATRIX m_CTMI; // Inverse current transformation matrix RRVECTORH m_frustum[6]; // Normalized plane equations for viewing // frustum in the model space DWORD m_dwFlags; } RRTRANSFORMDATA, *PRRTRANSFORMDATA; //--------------------------------------------------------------------- // RRLIGHTING // All the lighting related state clubbed together //--------------------------------------------------------------------- typedef struct {D3DVALUE r,g,b;} RRCOLOR; typedef struct _RRLIGHTING { // Active Light list RRLight *pActiveLights; // Temporary data used when computing lighting D3DVECTOR eye_in_eye; // eye position in eye space // It is (0, 0, 0) // Ma * La + Me (Ambient and Emissive) ------ RRCOLOR ambEmiss; // ColorVertex stuff ------------------------ RRCOLOR *pAmbientSrc; RRCOLOR *pDiffuseSrc; RRCOLOR *pSpecularSrc; RRCOLOR *pEmissiveSrc; // Diffuse ---------------------------------- RRCOLOR vertexDiffuse; // Provided with a vertex, used if // COLORVERTEX is enabled and a diffuse // color is provided in the vertex RRCOLOR diffuse; // Diffuse accumulates here DWORD outDiffuse; // Diffuse color result of lighting // Specular -------------------------------- RRCOLOR vertexSpecular;// Provided with a vertex, used if // COLORVERTEX is enabled and a specular // color is provided in the vertex RRCOLOR 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 RRCOLOR matAmb; RRCOLOR matDiff; RRCOLOR matSpec; RRCOLOR matEmis; } RRLIGHTING; //----------------------------------------------------------------------------- // // RRLight - The light object used by the Reference T&L implementation // An array of these are instanced in the ReferenceRasterizer object. // //----------------------------------------------------------------------------- typedef struct _RRLIGHTI { DWORD flags; D3DVECTOR position_in_eye; // In the eye space D3DVECTOR 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 D3DVECTOR halfway; // Stuff for SpotLights D3DVALUE range_squared; D3DVALUE cos_theta_by_2; D3DVALUE cos_phi_by_2; D3DVALUE inv_theta_minus_phi; } RRLIGHTI; //----------------------------------------------------------------------------- // Function pointer to the functions that light a vertex //----------------------------------------------------------------------------- typedef void (*RRLIGHTVERTEXFN)( RRLIGHTING& LData, D3DLIGHT7 *pLight, RRLIGHTI *pLightI, D3DLIGHTINGELEMENT *in, DWORD dwFlags, DWORD dwFVFIn ); //----------------------------------------------------------------------------- // Functions to compute lighting //----------------------------------------------------------------------------- typedef struct _RRLIGHTVERTEX_FUNC_TABLE { RRLIGHTVERTEXFN pfnDirectional; RRLIGHTVERTEXFN pfnParallelPoint; RRLIGHTVERTEXFN pfnSpot; RRLIGHTVERTEXFN pfnPoint; } RRLIGHTVERTEX_FUNC_TABLE; //----------------------------------------------------------------------------- // // RRLight - The light object used by the Reference T&L implementation // An array of these are instanced in the ReferenceRasterizer object. // //----------------------------------------------------------------------------- #define RRLIGHT_ENABLED 0x00000001 // Is the light active #define RRLIGHT_NEEDSPROCESSING 0x00000002 // Is the light data processed class RRLight : public RRAlloc { public: RRLight(); BOOL IsEnabled() {return (m_dwFlags & RRLIGHT_ENABLED);} BOOL NeedsProcessing() {return (m_dwFlags & RRLIGHT_NEEDSPROCESSING);} HRESULT SetLight(LPD3DLIGHT7 pLight); HRESULT GetLight( LPD3DLIGHT7 pLight ); void ProcessLight( D3DMATERIAL7 *mat, RRLIGHTVERTEX_FUNC_TABLE *pTbl); void XformLight( D3DMATRIX* mV ); void Enable( RRLight **ppRoot ); void Disable( RRLight **ppRoot ); private: // Flags DWORD m_dwFlags; // Active List next element RRLight *m_Next; // Specific function to light the vertex RRLIGHTVERTEXFN m_pfnLightVertex; // Light data set by the runtime D3DLIGHT7 m_Light; // Light data computed by the driver RRLIGHTI m_LightI; friend class ReferenceRasterizer; friend class RRProcessVertices; }; //----------------------------------------------------------------------------- // // RRMaterial - Class for materials data used for lighting by the driver // //----------------------------------------------------------------------------- class RRMaterial : public RRAlloc { public: RRMaterial(); ~RRMaterial(); HRESULT SetMaterial(LPD3DMATERIAL7); HRESULT GetMaterial(LPD3DMATERIAL7); private: // Data describing material D3DMATERIAL7 dmMaterial; }; //--------------------------------------------------------------------- // This class manages growing buffer, aligned to 32 byte boundary // Number if bytes should be power of 2. // D3DMalloc is used to allocate memory //--------------------------------------------------------------------- class RefAlignedBuffer32 { public: RefAlignedBuffer32() {m_size = 0; m_allocatedBuf = 0; m_alignedBuf = 0;} ~RefAlignedBuffer32() {if (m_allocatedBuf) free(m_allocatedBuf);} // Returns aligned buffer address LPVOID GetAddress() {return m_alignedBuf;} // Returns aligned buffer size DWORD GetSize() {return m_size;} HRESULT Grow(DWORD dwSize); HRESULT CheckAndGrow(DWORD dwSize) { if (dwSize > m_size) return Grow(dwSize + 1024); else return S_OK; } protected: LPVOID m_allocatedBuf; LPVOID m_alignedBuf; DWORD m_size; }; //--------------------------------------------------------------------- // Digested Viewport information // calculated from viewport settings //--------------------------------------------------------------------- typedef struct _RR_VIEWPORTDATA { 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; } RRVIEWPORTDATA; //--------------------------------------------------------------------- // RRCLIPPING // Cached clipping data //--------------------------------------------------------------------- typedef struct __RRCLIPPING { RefAlignedBuffer32 ClipBuf; RRCLIPVTX *clip_vbuf1[RRMAX_CLIP_VERTICES]; RRCLIPVTX *clip_vbuf2[RRMAX_CLIP_VERTICES]; RRCLIPVTX **current_vbuf; // clip_vbuf1 or clip_vbuf2 RRCLIPVTX clip_vertices[RRMAX_CLIP_VERTICES]; DWORD dwInterpolate; int clip_vertices_used; DWORD clip_color; DWORD clip_specular; } RRCLIPPING; // RRProcessVertices::m_dwTLState flags #define RRPV_DOLIGHTING 0x00000001 #define RRPV_DOCLIPPING 0x00000002 #define RRPV_GUARDBAND 0x00000004 #define RRPV_DOFOG 0x00000008 #define RRPV_DOSPECULAR 0x00000010 #define RRPV_RANGEFOG 0x00000020 #define RRPV_NORMALIZENORMALS 0x00000040 #define RRPV_LOCALVIEWER 0x00000080 #define RRPV_DOCOMPUTEPOINTSIZE 0x00000100 #define RRPV_DOPASSEYENORMAL 0x00000200 #define RRPV_DOPASSEYEXYZ 0x00000400 // ColorVertexFlags #define RRPV_VERTEXDIFFUSENEEDED 0x00000800 #define RRPV_VERTEXSPECULARNEEDED 0x00001000 #define RRPV_COLORVERTEXAMB 0x00002000 #define RRPV_COLORVERTEXDIFF 0x00004000 #define RRPV_COLORVERTEXSPEC 0x00008000 #define RRPV_COLORVERTEXEMIS 0x00010000 #define RRPV_COLORVERTEXFLAGS (RRPV_VERTEXDIFFUSENEEDED | \ RRPV_VERTEXSPECULARNEEDED | \ RRPV_COLORVERTEXAMB | \ RRPV_COLORVERTEXDIFF | \ RRPV_COLORVERTEXSPEC | \ RRPV_COLORVERTEXEMIS ) // RRProcessVertices::m_dwDirtyFlags flags #define RRPV_DIRTY_PROJXFM 0x00000001 #define RRPV_DIRTY_VIEWXFM 0x00000002 #define RRPV_DIRTY_WORLDXFM 0x00000004 #define RRPV_DIRTY_WORLD1XFM 0x00000008 #define RRPV_DIRTY_WORLD2XFM 0x00000010 #define RRPV_DIRTY_WORLD3XFM 0x00000020 #define RRPV_DIRTY_VIEWRECT 0x00000040 #define RRPV_DIRTY_ZRANGE 0x00000080 #define RRPV_DIRTY_XFORM (RRPV_DIRTY_PROJXFM | \ RRPV_DIRTY_VIEWXFM | \ RRPV_DIRTY_VIEWRECT | \ RRPV_DIRTY_WORLDXFM | \ RRPV_DIRTY_WORLD1XFM | \ RRPV_DIRTY_WORLD2XFM | \ RRPV_DIRTY_WORLD3XFM | \ RRPV_DIRTY_ZRANGE) #define RRPV_DIRTY_MATERIAL 0x00000100 #define RRPV_DIRTY_SETLIGHT 0x00000200 #define RRPV_DIRTY_NEEDXFMLIGHT 0x00000400 #define RRPV_DIRTY_COLORVTX 0x00000800 #define RRPV_DIRTY_LIGHTING (RRPV_DIRTY_MATERIAL | \ RRPV_DIRTY_SETLIGHT | \ RRPV_DIRTY_NEEDXFMLIGHT | \ RRPV_DIRTY_COLORVTX) #define RRPV_DIRTY_FOG 0x00010000 #define RRPV_DIRTY_CLIPPLANES 0x00020000 #define RRPV_DIRTY_INVERSEWORLDVIEW 0x00040000 //--------------------------------------------------------------------- // Transform & Lighting related data is encapsulated here //--------------------------------------------------------------------- class RRProcessVertices { protected: //------------------------------------------------------------------------- // Unprocessed state set by the DDI //------------------------------------------------------------------------- // Growable Light array RRLight *m_pLightArray; // RRLight *m_pLightArray; DWORD m_dwLightArraySize; // Size of the light array allocated // Current material to use for lighting D3DMATERIAL7 m_Material; // Vertex components // Note: position is used to store the vertex buffer in the non-strided // driver emulation mode D3DDP_PTRSTRIDE m_position; D3DDP_PTRSTRIDE m_normal; D3DDP_PTRSTRIDE m_specular; D3DDP_PTRSTRIDE m_diffuse; D3DDP_PTRSTRIDE m_tex0; D3DDP_PTRSTRIDE m_tex1; D3DDP_PTRSTRIDE m_tex2; D3DDP_PTRSTRIDE m_tex3; D3DDP_PTRSTRIDE m_tex4; D3DDP_PTRSTRIDE m_tex5; D3DDP_PTRSTRIDE m_tex6; D3DDP_PTRSTRIDE m_tex7; // Transformation state stored by the reference implementation RRMATRIX m_xfmProj; RRMATRIX m_xfmView; RRMATRIX m_xfmWorld[RRMAX_WORLD_MATRICES]; // Viewport data D3DVIEWPORT7 m_Viewport; // User defined clipping planes RRVECTOR4 m_userClipPlanes[RRMAX_USER_CLIPPLANES]; //------------------------------------------------------------------------- // Cached T&L related render-state info //------------------------------------------------------------------------- DWORD m_dwTLState; // RenderState related flags DWORD m_dwDirtyFlags; // Dirty flags //------------------------------------------------------------------------- // Transformation data //------------------------------------------------------------------------- // Buffer to store clip flags RefAlignedBuffer32 m_ClipFlagBuf; RRCLIPCODE *m_pClipBuf; // Buffer to store transformed vertices RefAlignedBuffer32 m_TLVBuf; LPVOID m_pvOut; // Current transformation matrix RRMATRIX m_xfmCurrent[RRMAX_WORLD_MATRICES]; // using WORLDi matrix RRMATRIX m_xfmToEye[RRMAX_WORLD_MATRICES]; // Transforms to camera // space (Mworld*Mview) RRMATRIX m_xfmToEyeInv[RRMAX_WORLD_MATRICES]; // and its Inverse D3DPRIMITIVETYPE m_primType; // Current primitive being drawn DWORD m_dwNumVertices; // Number of vertices to process DWORD m_dwNumIndices; // Number of indices for Indexed Prims LPWORD m_pIndices; DWORD m_dwFVFIn; // FVF of the input vertices UINT64 m_qwFVFOut; // Desired FVF for the output vertices DWORD m_dwOutputVtxSize; // Size of the output vertex DWORD m_dwNumTexCoords; // Number of the texture coordinate sets DWORD m_dwTexCoordSize[D3DDP_MAXTEXCOORD]; // Size of each one of them in // bytes DWORD m_dwTextureCoordSizeTotal; // In Bytes DWORD m_dwTexOffset; // Offsets in the input FVF vertex. DWORD m_dwDiffuseOffset; // Recomputed when FVF is changed. DWORD m_dwSpecularOffset; DWORD m_dwNormalOffset; int m_numVertexBlends; RRTRANSFORMDATA m_TransformData; RRVIEWPORTDATA m_ViewData; // Computed Viewport dependent info. FLOAT m_fPointSize; FLOAT m_fPointAttA; FLOAT m_fPointAttB; FLOAT m_fPointAttC; FLOAT m_fPointSizeMin; //------------------------------------------------------------------------- // Lighting data //------------------------------------------------------------------------- RRLIGHTVERTEX_FUNC_TABLE m_LightVertexTable; RRLIGHTING m_lighting; // Lighting state //------------------------------------------------------------------------- // Clipping data //------------------------------------------------------------------------- // Clipping related RRCLIPCODE m_clipUnion; // OR of all vertex clip flags RRCLIPCODE m_clipIntersection; // AND of all vertex clip flags RRCLIPPING m_clipping; // User clip planes transformed RRUSERCLIPPLANE m_xfmUserClipPlanes[RRMAX_USER_CLIPPLANES]; /////////////////////////////////////////////////////////////////////////// // Methods /////////////////////////////////////////////////////////////////////////// HRESULT UpdateXformData(); HRESULT UpdateLightingData(); HRESULT UpdateFogData(); HRESULT UpdateClippingData( DWORD dwClipPlanesEnable ); RRCLIPCODE ComputeClipCodes(RRCLIPCODE* pclipIntersection, RRCLIPCODE* pclipUnion, FLOAT x_clip, FLOAT y_clip, FLOAT z_clip, FLOAT w_clip, FLOAT fPointSize); RRCLIPCODE ProcessVertices(); HRESULT DoIPrim(); HRESULT DoNIPrim(); void SetupFVFData(BOOL bFogEnabled, BOOL bSpecularEnable); void LightVertex( D3DLIGHTINGELEMENT *le ); void FogVertex ( D3DVECTOR &v, D3DLIGHTINGELEMENT *le, int numVertexBlends, float *pBlendFactors, BOOL bVertexInEyeSpace ); void InitTLData(); // DrawClippedPrimitive HRESULT DrawOneClippedIndexedPrimitive(); HRESULT DrawOneClippedPrimitive(); // Clipping Related void Interpolate(RRCLIPVTX *out, RRCLIPVTX *p1, RRCLIPVTX *p2, int code, D3DVALUE num, D3DVALUE denom); int ClipLeft( RRCLIPVTX **inv, RRCLIPVTX **outv, int count); int ClipRight( RRCLIPVTX **inv, RRCLIPVTX **outv, int count); int ClipTop( RRCLIPVTX **inv, RRCLIPVTX **outv, int count); int ClipBottom( RRCLIPVTX **inv, RRCLIPVTX **outv, int count); int ClipFront( RRCLIPVTX **inv, RRCLIPVTX **outv, int count); int ClipBack( RRCLIPVTX **inv, RRCLIPVTX **outv, int count); int ClipLeftGB( RRCLIPVTX **inv, RRCLIPVTX **outv, int count); int ClipRightGB( RRCLIPVTX **inv, RRCLIPVTX **outv, int count); int ClipTopGB( RRCLIPVTX **inv, RRCLIPVTX **outv, int count); int ClipBottomGB( RRCLIPVTX **inv, RRCLIPVTX **outv, int count); int ClipLineLeft( RRCLIPTRIANGLE *inv); int ClipLineRight( RRCLIPTRIANGLE *inv); int ClipLineTop( RRCLIPTRIANGLE *inv); int ClipLineBottom( RRCLIPTRIANGLE *inv); int ClipLineFront( RRCLIPTRIANGLE *inv); int ClipLineBack( RRCLIPTRIANGLE *inv); int ClipLineLeftGB( RRCLIPTRIANGLE *inv); int ClipLineRightGB( RRCLIPTRIANGLE *inv); int ClipLineTopGB( RRCLIPTRIANGLE *inv); int ClipLineBottomGB( RRCLIPTRIANGLE *inv); int ClipByPlane( RRCLIPVTX **inv, RRCLIPVTX **outv, RRVECTOR4 *plane, DWORD dwClipFlag, int count ); int ClipLineByPlane( RRCLIPTRIANGLE *line, RRVECTOR4 *plane, DWORD dwClipBit); }; // Vertex Lighting functions void RRLV_Directional( RRLIGHTING&, D3DLIGHT7 *, RRLIGHTI *, D3DLIGHTINGELEMENT *, DWORD, DWORD ); void RRLV_PointAndSpot( RRLIGHTING&, D3DLIGHT7 *, RRLIGHTI *, D3DLIGHTINGELEMENT *, DWORD, DWORD ); // For TL Refrast // Following primitive functions are shared by REF rasterizers HRESULT FASTCALL DoDrawOneIndexedPrimitive(ReferenceRasterizer * pCtx, UINT16 FvfStride, PUINT8 pVtx, LPWORD puIndices, D3DPRIMITIVETYPE PrimType, UINT cIndices); HRESULT FASTCALL DoDrawOnePrimitive(ReferenceRasterizer * pCtx, UINT16 FvfStride, PUINT8 pVtx, D3DPRIMITIVETYPE PrimType, UINT cVertices); HRESULT FASTCALL DoDrawOneEdgeFlagTriangleFan(ReferenceRasterizer * pCtx, UINT16 FvfStride, PUINT8 pVtx, UINT cVertices, UINT32 dwEdgeFlags); //--------------------------------------------------------------------- // ComputeTextureCoordSize: // Computes the following device data // - bTextureCoordSizeTotal // - bTextureCoordSize[] array, based on the input FVF id //--------------------------------------------------------------------- __inline void ComputeTextureCoordSize(DWORD dwFVF, LPDWORD pdwTexCoordSizeArray, LPDWORD pdwTexCoordSizeTotal) { // Texture formats size 00 01 10 11 static BYTE bTextureSize[4] = {2*4, 3*4, 4*4, 4}; DWORD dwNumTexCoord = FVF_TEXCOORD_NUMBER(dwFVF); // Compute texture coordinate size DWORD dwTextureFormats = dwFVF >> 16; if (dwTextureFormats == 0) { *pdwTexCoordSizeTotal = (BYTE)dwNumTexCoord * 2 * 4; for (DWORD i=0; i < dwNumTexCoord; i++) pdwTexCoordSizeArray[i] = 4*2; } else { *pdwTexCoordSizeTotal = 0; for (DWORD i=0; i < dwNumTexCoord; i++) { BYTE dwSize = bTextureSize[dwTextureFormats & 3]; pdwTexCoordSizeArray[i] = dwSize; *pdwTexCoordSizeTotal += dwSize; dwTextureFormats >>= 2; } } return; } /////////////////////////////////////////////////////////////////////////////// #endif // _REFTNL_HPP