/////////////////////////////////////////////////////////////////////////////// // Copyright (C) Microsoft Corporation, 1998. // // refrast.hpp // // Direct3D Reference Rasterizer - Main Header File // /////////////////////////////////////////////////////////////////////////////// #ifndef _REFRAST_HPP #define _REFRAST_HPP // Leave this defined so various all the code compiles. However, // it will never be set, since it is a part of D3DFVF_RESERVED2 until // DX8. #define D3DFVF_S 0x1000 #include #include #include //----------------------------------------------------------------------------- // // Uncomment this to enable point sprites in the reference rasterizer // //----------------------------------------------------------------------------- //#define __POINTSPRITES 1 //----------------------------------------------------------------------------- // // Uncomment this to enable shadowbuffer in the reference rasterizer // //----------------------------------------------------------------------------- //#define __SHADOWBUFFER 1 //----------------------------------------------------------------------------- // // RefRastSetMemif - Routine to set memory allocation interface for reference // rasterizer - takes pointers to functions to use for malloc, free, and realloc. // // These must be set prior to new'ing any ReferenceRasterizer objects. These are // used for allocating rasterizer objects, and for allocation of the fragment // pointer array and fragment records used for sort-independent antialiasing and // transluscency. // //----------------------------------------------------------------------------- void RefRastSetMemif( LPVOID( _cdecl* pfnMemAlloc )( size_t ), void( _cdecl* pfnMemFree )( PVOID ), LPVOID( _cdecl* pfnMemReAlloc )( PVOID, size_t ) ); //----------------------------------------------------------------------------- // // Surface types for rendering surfaces and textures. Different subsets are // supported for render targets and for textures. // //----------------------------------------------------------------------------- typedef enum _RRSurfaceType { RR_STYPE_NULL = 0, RR_STYPE_B8G8R8 = 1, RR_STYPE_B8G8R8A8 = 2, RR_STYPE_B8G8R8X8 = 3, RR_STYPE_B5G6R5 = 4, RR_STYPE_B5G5R5 = 5, RR_STYPE_PALETTE4 = 6, RR_STYPE_PALETTE8 = 7, RR_STYPE_B5G5R5A1 = 8, RR_STYPE_B4G4R4 = 9, RR_STYPE_B4G4R4A4 =10, RR_STYPE_L8 =11, // 8 bit luminance-only RR_STYPE_L8A8 =12, // 16 bit alpha-luminance RR_STYPE_U8V8 =13, // 16 bit bump map format RR_STYPE_U5V5L6 =14, // 16 bit bump map format with luminance RR_STYPE_U8V8L8 =15, // 24 bit bump map format with luminance RR_STYPE_UYVY =16, // UYVY format (PC98 compliance) RR_STYPE_YUY2 =17, // YUY2 format (PC98 compliance) RR_STYPE_DXT1 =18, // S3 texture compression technique 1 RR_STYPE_DXT2 =19, // S3 texture compression technique 2 RR_STYPE_DXT3 =20, // S3 texture compression technique 3 RR_STYPE_DXT4 =21, // S3 texture compression technique 4 RR_STYPE_DXT5 =22, // S3 texture compression technique 5 RR_STYPE_B2G3R3 =23, // 8 bit RGB texture format RR_STYPE_L4A4 =24, // 8 bit alpha-luminance RR_STYPE_B2G3R3A8 =25, // 16 bit alpha-rgb RR_STYPE_Z16S0 =32, RR_STYPE_Z24S8 =33, RR_STYPE_Z15S1 =34, RR_STYPE_Z32S0 =35, RR_STYPE_S1Z15 =36, RR_STYPE_S8Z24 =37, RR_STYPE_Z24S4 =38, RR_STYPE_S4Z24 =39, } RRSurfaceType; //----------------------------------------------------------------------------- // // Constants // //----------------------------------------------------------------------------- #define SPRITETEXCOORDMAX (4095.75f/4096.0f) //----------------------------------------------------------------------------- // // forward declarations, mostly from refrasti.hpp // //----------------------------------------------------------------------------- class RRColorComp; class RRColor; class RRDepth; class RRPixel; class RRTexture; class RRTextureCoord; class RREnvTextureCoord; class RRFVFExtractor; typedef UINT16 RRCvgMask; typedef struct _RRFRAGMENT RRFRAGMENT; typedef struct _RRSCANCNVSTATE RRSCANCNVSTATE; typedef struct _RRSTATS RRSTATS; //----------------------------------------------------------------------------- // // RRRenderTarget - Class which encompasses all informatio about rendering // target, including size, type/pointer/stride for color and depth/stencil // buffers, guard band clip info, W range info. // // Usage is to instantiate, fill out public members, and install into a // ReferenceRasterizer object via ReferenceRasterizer::SetRenderTarget. // //----------------------------------------------------------------------------- class RRRenderTarget { public: /////////////////////////////////////////////////////////////////////////// // // public interface // /////////////////////////////////////////////////////////////////////////// RRRenderTarget( void ); ~RRRenderTarget( void ); static void* operator new( size_t ); static void operator delete( void* pv, size_t ); // // these need to be filled in by the user before installing in a // ReferenceRasterizer object // int m_iWidth; // size of target surfaces (color & depth/stencil int m_iHeight; // must be same size RECT m_Clip; FLOAT m_fWRange[2]; // range of device W (W at near and far clip planes) RRSurfaceType m_ColorSType; char* m_pColorBufBits; int m_iColorBufPitch; RRSurfaceType m_DepthSType; char* m_pDepthBufBits; int m_iDepthBufPitch; // // these are used only to facilitate the way refrast is used in the D3D runtime // and are not referenced within the refrast core // LPDDRAWI_DDRAWSURFACE_LCL m_pDDSLcl; LPDDRAWI_DDRAWSURFACE_LCL m_pDDSZLcl; /////////////////////////////////////////////////////////////////////////// // // internal state and methods // /////////////////////////////////////////////////////////////////////////// friend class ReferenceRasterizer; void ReadPixelColor ( INT32 iX, INT32 iY, RRColor& Color ); void WritePixelColor ( INT32 iX, INT32 iY, const RRColor& Color, BOOL bDither ); void WritePixelDepth ( INT32 iX, INT32 iY, const RRDepth& Depth ); void ReadPixelDepth ( INT32 iX, INT32 iY, RRDepth& Depth ); void WritePixelStencil( INT32 iX, INT32 iY, UINT8 uStencil ); void ReadPixelStencil ( INT32 iX, INT32 iY, UINT8& uStencil ); void Clear ( RRColor fillColor, LPD3DHAL_DP2COMMAND pCmd ); void ClearDepth ( RRDepth fillDepth, LPD3DHAL_DP2COMMAND pCmd ); void ClearStencil ( UINT8 uStencil, LPD3DHAL_DP2COMMAND pCmd ); void ClearDepthStencil( RRDepth fillDepth, UINT8 uStencil, LPD3DHAL_DP2COMMAND pCmd ); }; //----------------------------------------------------------------------------- // // RRTextureStageState - This holds the per-stage state for texture mapping. // An array of these are instanced in the ReferenceRasterizer object. // // Store texture matrix at the end of the texture stage state. // //----------------------------------------------------------------------------- #define D3DTSSI_MATRIX (D3DTSS_MAX) class RRTextureStageState { public: union { DWORD m_dwVal[D3DTSS_MAX+16]; // state array (unsigned) FLOAT m_fVal[D3DTSS_MAX+16]; // state array (float) }; RRTexture* m_pTexture; }; //----------------------------------------------------------------------------- // // RRTexture - Class instanced once per texture which encompasses information // about a chain of surfaces used as a texture map. Includes size and type // (assumed same for each level of detail) and pointer/stride for each LOD. // // Also includes pointer to palette, and colorkey value (legacy support only). // // Usage is to create RRTexture (and associated handle) with call to // ReferenceRasterizer::TextureCreate and install in ReferenceRasterizer // by passing handle into ReferenceRasterizer::SetRenderState. // //----------------------------------------------------------------------------- #define RRTEX_MAXCLOD 12*6 // supports base texture up to 4kx4k // for 6 envmaps class RRTexture { public: /////////////////////////////////////////////////////////////////////////// // // public interface // /////////////////////////////////////////////////////////////////////////// RRTexture( void ); ~RRTexture( void ); static void* operator new( size_t ); static void operator delete( void* pv, size_t ); // // this needs to be called after changing any of the public state to validate // internal (private) state // BOOL Validate( void ); // // these need to be filled in by the user before installing in a // ReferenceRasterizer object // DWORD m_uFlags; // RR_TEXTURE_* bitdefs // bit definitions for RRTexture::uFlags #define RR_TEXTURE_HAS_CK (1L<< 0) // set if texture has colorkey #define RR_TEXTURE_LOCKED (1L<< 1) // set if DD surface is locked (external use only) #define RR_TEXTURE_ALPHAINPALETTE (1L<< 2) // set if alpha channel in palette #define RR_TEXTURE_ENVMAP (1L<< 3) // set if texture is envmap with 6 times // the usual number of surfaces #define RR_TEXTURE_SHADOWMAP (1L<< 4) // set if the texture is a ZBuffer // basic info RRSurfaceType m_SurfType; // format of pixel int m_iWidth; // size of largest map int m_iHeight; char* m_pTextureBits[RRTEX_MAXCLOD]; // pointer to surface bits int m_iPitch[RRTEX_MAXCLOD]; // pitch in bytes int m_cLOD; // 0..(n-1) count of LODs currently available DWORD m_dwColorKey; // D3DCOLOR colorkey value DWORD m_dwEmptyFaceColor; // D3DCOLOR empty cubemap empty face value DWORD* m_pPalette; // pointer to D3DCOLOR palette (may be NULL) // // these are used only to facilitate the way refrast is used in the D3D runtime // and are not referenced within the refrast core // // DD surface pointers for locking/unlocking and GetSurf callback LPDDRAWI_DDRAWSURFACE_LCL m_pDDSLcl[RRTEX_MAXCLOD]; int m_cLODDDS; // 0..(n-1) count of LODs actually in the pDDS array // // may be useful to other users to have this public // D3DTEXTUREHANDLE m_hTex; // texture handle /////////////////////////////////////////////////////////////////////////// // // internal state and methods // /////////////////////////////////////////////////////////////////////////// friend class ReferenceRasterizer; // pointer to head of texture stage states, &m_TextureStageState[0] RRTextureStageState* m_pStageState; // texture.cpp - main interface methods used by ReferenceRasterizer object methods void DoLookupAndFilter( INT32 iStage, RRTextureCoord, RRColor& TextureColor ); void DoBumpMapping( INT32 iStage, RRTextureCoord TCoord, FLOAT& fBumpMapUDelta, FLOAT& fBumpMapVDelta, RRColor& BumpMapModulate ); void DoShadow(INT32 iStage, FLOAT* pfCoord, RRColor& OutputColor); // environment mapping versions void DoEnvProcessNormal( INT32 iStage, RREnvTextureCoord, RRColor& TextureColor ); void DoEnvLookupAndFilter(INT32 iStage, INT16 iFace, FLOAT fMajor, FLOAT fDMDX, FLOAT fDMDY, RRTextureCoord TCoord, RRColor& TextureColor); void DoEnvReMap(INT16 iU, INT16 iV, INT16 iUMask, INT16 iVMask, INT16 iFace, INT16 iLOD, RRColor &Texel, BOOL &bColorKeyMatched); void DoTableInterp(INT16 iU, INT16 iV, INT16 iUMask, INT16 iVMask, INT16 iFace, INT16 iLOD, UINT8 uUSign, UINT8 uVSign, RRColor &Texel, BOOL &bColorKeyMatched); BOOL m_bMipMapEnable; // TRUE if mipmapping is enabled for this texture INT16 m_iTexSize[2]; // LOD 0 size INT16 m_iTexShift[2]; // LOD 0 log2 size (valid for power-of-2 size only) UINT16 m_uTexMask[2]; // LOD 0 (1< StateSetData; typedef StateSetData *LPStateSetData; class ReferenceRasterizer; typedef HRESULT (*PFN_DP2REFOPERATION)(ReferenceRasterizer *pRefRast, LPD3DHAL_DP2COMMAND pCmd); typedef HRESULT (*PFN_DP2REFSETRENDERSTATES)(ReferenceRasterizer *pRefRast, DWORD dwFvf, LPD3DHAL_DP2COMMAND pCmd, LPDWORD lpdwRuntimeRStates); typedef HRESULT (*PFN_DP2REFTEXTURESTAGESTATE)(ReferenceRasterizer *pRefRast, DWORD dwFvf, LPD3DHAL_DP2COMMAND pCmd); typedef HRESULT (*PFN_DP2REFSETLIGHT)(ReferenceRasterizer *pRefRast, LPD3DHAL_DP2COMMAND pCmd, LPDWORD pdwStride); typedef struct _REF_STATESETFUNCTIONTBL { DWORD dwSize; // size of struct PFN_DP2REFSETRENDERSTATES pfnDp2SetRenderStates; PFN_DP2REFTEXTURESTAGESTATE pfnDp2TextureStageState; PFN_DP2REFOPERATION pfnDp2SetViewport; PFN_DP2REFOPERATION pfnDp2SetWRange; PFN_DP2REFOPERATION pfnDp2SetMaterial; PFN_DP2REFOPERATION pfnDp2SetZRange; PFN_DP2REFSETLIGHT pfnDp2SetLight; PFN_DP2REFOPERATION pfnDp2CreateLight; PFN_DP2REFOPERATION pfnDp2SetTransform; PFN_DP2REFOPERATION pfnDp2SetExtention; PFN_DP2REFOPERATION pfnDp2SetClipPlane; } REF_STATESETFUNCTIONTBL, *LPREF_STATESETFUNCTIONTBL; // // The device type that the RefRast should emulate // typedef enum { RRTYPE_OLDHAL = 1, RRTYPE_DPHAL, RRTYPE_DP2HAL, // DX6 HAL RRTYPE_DX7HAL, // DX7 HAL w/out T&L, with state sets RRTYPE_DX7TLHAL } RRDEVICETYPE; typedef struct _RRSTATEOVERRIDES { DWORD bits[D3DSTATE_OVERRIDE_BIAS >> RRSTATEOVERRIDE_DWORD_SHIFT]; } RRSTATEOVERRIDES; //----------------------------------------------------------------------------- // // ReferenceRasterizer - Primary object for reference rasterizer. Each instance // of this corresponds to a D3D device. // // Usage is to instantiate, install RRRenderTarget (and optional RRTexture's), // and set state and draw primitives. // //----------------------------------------------------------------------------- class ReferenceRasterizer : public RRProcessVertices { public: /////////////////////////////////////////////////////////////////////////// // // public interface // /////////////////////////////////////////////////////////////////////////// ReferenceRasterizer( LPDDRAWI_DIRECTDRAW_LCL pDDLcl, DWORD dwInterfaceType, RRDEVICETYPE dwDriverType ); ~ReferenceRasterizer( void ); static void* operator new( size_t ); static void operator delete( void* pv, size_t ); // Dp2 token handling functions HRESULT Dp2RecRenderStates(DWORD dwFvf, LPD3DHAL_DP2COMMAND pCmd, LPDWORD lpdwRuntimeRStates); HRESULT Dp2RecTextureStageState(DWORD dwFvf, LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2RecViewport(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2RecWRange(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2RecMaterial(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2RecZRange(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2RecSetLight(LPD3DHAL_DP2COMMAND pCmd, LPDWORD pdwStride); HRESULT Dp2RecCreateLight(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2RecTransform(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2RecExtention(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2RecClipPlane(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2SetRenderStates(DWORD dwFvf, LPD3DHAL_DP2COMMAND pCmd, LPDWORD lpdwRuntimeRStates); HRESULT Dp2SetTextureStageState(DWORD dwFvf, LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2SetViewport(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2SetWRange(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2SetMaterial(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2SetZRange(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2SetLight(LPD3DHAL_DP2COMMAND pCmd, PDWORD pdwStride); HRESULT Dp2CreateLight(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2SetTransform(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2SetExtention(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2SetRenderTarget(LPD3DHAL_DP2COMMAND pCmd); HRESULT Dp2SetClipPlane(LPD3DHAL_DP2COMMAND pCmd); // StateSet related functions void SetRecStateFunctions(void); void SetSetStateFunctions(void); HRESULT BeginStateSet(DWORD dwHandle); HRESULT EndStateSet(void); HRESULT ExecuteStateSet(DWORD dwHandle); HRESULT DeleteStateSet(DWORD dwHandle); HRESULT CaptureStateSet(DWORD dwHandle); HRESULT RecordStates(PUINT8 pData, DWORD dwSize); HRESULT RecordLastState(LPD3DHAL_DP2COMMAND pCmd, DWORD dwUnitSize); LPREF_STATESETFUNCTIONTBL pStateSetFuncTbl; // Interface style BOOL IsInterfaceDX6AndBefore() {return (m_dwInterfaceType <= 2);} // DriverStyle BOOL IsDriverDX6AndBefore() { return ((m_dwDriverType <= RRTYPE_DP2HAL) && (m_dwDriverType > 0)); } // Last State hack void StoreLastPixelState(BOOL bStore); // state management functions void SetRenderTarget( RRRenderTarget* pRenderTarget ); RRRenderTarget* GetRenderTarget( void ); void SetRenderState( DWORD dwState, DWORD dwValue ); DWORD* GetRenderState( void ); DWORD* GetTextureStageState(DWORD dwStage); void SetTextureStageState( DWORD dwStage, DWORD dwStageState, DWORD dwValue ); void SceneCapture( DWORD dwFlags ); // texture management functions BOOL TextureCreate ( LPD3DTEXTUREHANDLE phTex, RRTexture** ppTexture ); BOOL TextureCreate ( DWORD dwHandle, RRTexture** ppTex ); BOOL TextureDestroy ( D3DTEXTUREHANDLE hTex ); DWORD TextureGetSurf( D3DTEXTUREHANDLE hTex ); // rendering functions HRESULT Clear(LPD3DHAL_DP2COMMAND pCmd); HRESULT BeginRendering( DWORD dwFVFControl ); HRESULT EndRendering( void ); BOOL DoAreaCalcs(FLOAT* pfDet, RRFVFExtractor* pVtx0, RRFVFExtractor* pVtx1, RRFVFExtractor* pVtx2); void DoTexCoordCalcs(INT32 iStage, RRFVFExtractor* pVtx0, RRFVFExtractor* pVtx1, RRFVFExtractor* pVtx2); void DrawTriangle( void* pvV0, void* pvV1, void* pvV2, WORD wFlags = D3DTRIFLAG_EDGEENABLETRIANGLE ); void DrawLine( void* pvV0, void* pvV1, void* pvVFlat = NULL ); void DrawPoint( void* pvV0, void* pvVFlat = NULL ); void DrawClippedTriangle( void* pvV0, RRCLIPCODE c0, void* pvV1, RRCLIPCODE c1, void* pvV2, RRCLIPCODE c2, WORD wFlags = D3DTRIFLAG_EDGEENABLETRIANGLE ); void DrawClippedLine( void* pvV0, RRCLIPCODE c0, void* pvV1, RRCLIPCODE c1, void* pvVFlat = NULL ); void DrawClippedPoint( void* pvV0, RRCLIPCODE c0, void* pvVFlat = NULL ); // // these are used to facilitate the way refrast is used in the D3D runtime // // functions to manipulate current set of texture int GetCurrentTextureMaps( D3DTEXTUREHANDLE* phTex, RRTexture** pTex ); BOOL SetTextureMap( D3DTEXTUREHANDLE hTex, RRTexture* pTex ); // // T&L Hal specific functions // // For Non-Indexed Primitives void SavePrimitiveData( DWORD dwFVFIn, LPVOID pVtx, UINT cVertices, D3DPRIMITIVETYPE PrimType ); // For Indexed Primitives void SavePrimitiveData( DWORD dwFVFIn, LPVOID pVtx, UINT cVertices, D3DPRIMITIVETYPE PrimType, LPWORD pIndices, UINT cIndices); HRESULT ProcessPrimitive( BOOL bIndexedPrim ); HRESULT UpdateTLState(); int ClipSingleLine( RRCLIPTRIANGLE *line ); int ClipSingleTriangle(RRCLIPTRIANGLE *tri, RRCLIPVTX ***clipVertexPointer); // // Texture locking and Unlocking control // inline BOOL TexturesAreLocked() {return m_bTexturesAreLocked;}; inline void SetTexturesLocked() {m_bTexturesAreLocked = TRUE;}; inline void ClearTexturesLocked() {m_bTexturesAreLocked = FALSE;}; private: /////////////////////////////////////////////////////////////////////////// // // internal state and methods // /////////////////////////////////////////////////////////////////////////// //------------------------------------------------------------------------- // state //------------------------------------------------------------------------- // DDraw Local, needed for the new texture handles from DX7 onwards LPDDRAWI_DIRECTDRAW_LCL m_pDDLcl; // This is obtained from CONTEXTCREATE->ddrval, indicates // what kind of emulation (DX3, DX5, DX6 or DX7) the driver should do. RRDEVICETYPE m_dwDriverType; // This is obtained from CONTEXTCREATE->dwhContext, indicates // which D3D Device interface called the driver. DWORD m_dwInterfaceType; // save area for floating point unit control WORD m_wSaveFP; // TRUE if in begin/end primitive sequence BOOL m_bInBegin; // TRUE if in rendering point sprite triangles BOOL m_bPointSprite; // current Flexible Vertex Format control word UINT64 m_qwFVFControl; // render target (color & Z buffer) RRRenderTarget* m_pRenderTarget; FLOAT m_fWBufferNorm[2]; // { Wnear, 1/(Wfar-Wnear) } to normalize W buffer value // fragment buffer RRFRAGMENT** m_ppFragBuf; INT m_iFragBufWidth; INT m_iFragBufHeight; BOOL m_bFragmentProcessingEnabled; // D3D renderstate union { DWORD m_dwRenderState[D3DHAL_MAX_RSTATES]; FLOAT m_fRenderState[D3DHAL_MAX_RSTATES]; }; // State Override flags RRSTATEOVERRIDES m_renderstate_override; // texture state - per-stage state and pointer to associated texture int m_cActiveTextureStages; // count of active texture stages (range 0..D3DHAL_TSS_MAXSTAGES) RRTextureStageState m_TextureStageState[D3DHAL_TSS_MAXSTAGES]; RRTexture* m_pTexture[D3DHAL_TSS_MAXSTAGES]; // texture maps associated with texture stages // DX7 style texture objects, where the handle is specified by the // runtime. It is basically an index into an array. // This array is dynamically allocated and grown very much like the light // array. RRTexture** m_ppTextureArray; DWORD m_dwTexArrayLength; // scan converter state RRSCANCNVSTATE* m_pSCS; // statistics RRSTATS* m_pStt; // Last state DWORD m_LastState; // Array of StateSets, which are in turn implemented with TemplArray as // TemplArray StateSetData TemplArray m_pStateSets; // This bool indicates that the textures are already locked BOOL m_bTexturesAreLocked; //------------------------------------------------------------------------- // methods //------------------------------------------------------------------------- // refrasti.cpp HRESULT GrowTexArray( DWORD dwHandle ); HRESULT SetTextureHandle( int iStage, DWORD dwHandle ); void MapTextureHandleToDevice( int iStage ); void UpdateActiveTexStageCount( void ); RRTexture* MapHandleToTexture( D3DTEXTUREHANDLE hTex ); // MapLegcy.cpp void MapLegacyTextureBlend( void ); void MapLegacyTextureFilter( void ); // setup.cpp void SetPrimitiveAttributeFunctions( const RRFVFExtractor& Vtx0, const RRFVFExtractor& Vtx1, const RRFVFExtractor& Vtx2, const RRFVFExtractor& VtxFlat ); // scancnv.cpp FLOAT ComputePixelAttrib( int iAttrib ); FLOAT ComputePixelAttribClamp( int iAttrib ); FLOAT ComputePixelAttribTex( int iTex, int iCrd ); void ComputeFogIntensity( RRPixel& Pixel ); void DoScanCnvGenPixel( RRCvgMask CvgMask, BOOL bTri ); void DoScanCnvTri( int iEdgeCount ); void DoScanCnvLine( void ); // texstage.cpp void DoTexture( const RRPixel& Pixel, RRColor& OutputColor); void ComputeTextureBlendArg( DWORD dwArgCtl, BOOL bAlphaOnly, const RRColor& DiffuseColor, const RRColor& SpecularColor, const RRColor& CurrentColor, const RRColor& TextureColor, RRColor& BlendArg); void DoTextureBlendStage( int iStage, const RRColor& DiffuseColor, const RRColor& SpecularColor, const RRColor& CurrentColor, const RRColor& TextureColor, RRColor& OutputColor); // pixproc.cpp BOOL DepthCloser( const RRDepth& DepthVal, const RRDepth& DepthBuf ); BOOL AlphaTest( const RRColorComp& Alpha ); BOOL DoStencil( UINT8 uStncBuf, BOOL bDepthTest, RRSurfaceType DepthSType, UINT8& uStncRet ); void DoAlphaBlend( const RRColor& SrcColor, const RRColor& DstColor, RRColor& ResColor ); void DoPixel( RRPixel& Pixel ); // fragproc.cpp BOOL DoFragmentGenerationProcessing( RRPixel& Pixel ); void DoFragmentBufferFixup( const RRPixel& Pixel ); RRFRAGMENT* FragAlloc( void ); void FragFree( RRFRAGMENT* pFrag ); // fragrslv.cpp void DoBufferResolve( void); void DoFragResolve( RRColor& ResolvedColor, RRDepth& ResolvedDepth, RRFRAGMENT* pFragList, const RRColor& PixelColor ); // PixRef.cpp void WritePixel( INT32 iX, INT32 iY, const RRColor& Color, const RRDepth& Depth); // primfns.cpp void SetXfrm( D3DTRANSFORMSTATETYPE xfrmType, D3DMATRIX *pMat ); HRESULT GrowLightArray(const DWORD dwIndex); }; //----------------------------------------------------------------------------- // // RRFVFExtractor - Encases Flexible Vertex Format pointer and control to get // vertex data. // //----------------------------------------------------------------------------- #ifndef D3DFVF_GETTEXCOORDSIZE #define D3DFVF_GETTEXCOORDSIZE(FVF, CoordIndex) ((FVF >> (CoordIndex*2 + 16)) & 0x3) #endif class RRFVFExtractor { private: void* m_pvData; UINT64 m_qwControl; BOOL m_bPerspectiveEnable; int m_iXYZ; int m_iDiffuse; int m_iSpecular; int m_iTexCrd[D3DHAL_TSS_MAXSTAGES+1]; int m_iS; int m_iEyeNormal; int m_iEyeXYZ; public: // constructor RRFVFExtractor( void* pvData, UINT64 qwControl, BOOL bPerspectiveEnable ) { m_pvData = pvData; m_qwControl = qwControl; m_bPerspectiveEnable = bPerspectiveEnable; // compute offsets to fields within FVF m_iXYZ = 0 + ( m_qwControl & D3DFVF_RESERVED0 ? 1 : 0 ); m_iDiffuse = m_iXYZ + ( m_qwControl & D3DFVF_XYZ ? 3 : 0 ) + ( m_qwControl & D3DFVF_XYZRHW ? 4 : 0 ) + ( m_qwControl & D3DFVF_NORMAL ? 3 : 0 ) + ( m_qwControl & D3DFVF_RESERVED1 ? 1 : 0 ); m_iSpecular = m_iDiffuse + ( m_qwControl & D3DFVF_DIFFUSE ? 1 : 0 ); m_iTexCrd[0] = m_iSpecular + ( m_qwControl & D3DFVF_SPECULAR ? 1 : 0 ); m_iS = m_iTexCrd[0]; for(int i = 0; i < TexCrdCount(); i++) { int iTexND; switch (D3DFVF_GETTEXCOORDSIZE(m_qwControl, i)) { case D3DFVF_TEXTUREFORMAT2: iTexND = 2; break; case D3DFVF_TEXTUREFORMAT3: iTexND = 3; break; case D3DFVF_TEXTUREFORMAT4: iTexND = 4; break; case D3DFVF_TEXTUREFORMAT1: iTexND = 1; break; } m_iTexCrd[i+1] = m_iTexCrd[i] + iTexND; m_iS = m_iTexCrd[i+1]; // generate one more iTexCrd pointer than // needed, and use it for size } m_iEyeNormal = m_iS + ( m_qwControl & D3DFVF_S ? 1 : 0 ); m_iEyeXYZ = m_iEyeNormal + ( m_qwControl & D3DFVFP_EYENORMAL ? 3 : 0 ); } // coordinate access methods FLOAT* GetPtrXYZ( void ) const { return (FLOAT*)m_pvData + m_iXYZ; } FLOAT GetX( void ) const { return *( GetPtrXYZ() + 0 ); } FLOAT GetY( void ) const { return *( GetPtrXYZ() + 1 ); } FLOAT GetZ( void ) const { return *( GetPtrXYZ() + 2 ); } FLOAT GetRHW( void ) const { // return 1. if perspective not enabled if ( !m_bPerspectiveEnable ) return 1.f; // return 1/W if available else default value 1.0 return ( m_qwControl & D3DFVF_XYZRHW ) ? *( GetPtrXYZ() + 3 ) : 1.f ; } // color access methods DWORD GetDiffuse( void ) const { // return color if available else white (default) return ( m_qwControl & D3DFVF_DIFFUSE ) ? *( (DWORD*)m_pvData + m_iDiffuse ) : 0xffffffff; } DWORD GetSpecular( void ) const { // return color if available else black and zero vertex fog (default) return ( m_qwControl & D3DFVF_SPECULAR ) ? *( (DWORD*)m_pvData + m_iSpecular ) : 0x00000000; } // texture coordinate access methods int TexCrdCount( void ) const { return (int)(( m_qwControl & D3DFVF_TEXCOUNT_MASK ) >> D3DFVF_TEXCOUNT_SHIFT); } FLOAT GetTexCrd( int iCrd, int iCrdSet ) const { return ( (TexCrdCount() > iCrdSet) && (iCrd < 4) ) ? *( (FLOAT*)m_pvData + m_iTexCrd[iCrdSet] + iCrd ) : 0.f; } FLOAT* GetPtrTexCrd( int iCrd, int iCrdSet ) const { return (FLOAT*)m_pvData + m_iTexCrd[iCrdSet] + iCrd; } FLOAT GetS( void ) const { return ( m_qwControl & D3DFVF_S ) ? *( (FLOAT*)m_pvData + m_iS ) : 1.0f; } FLOAT* GetPtrS( void ) const { return (FLOAT*)m_pvData + m_iS; } FLOAT GetEyeNormal( int iCrd ) const { return (m_qwControl & D3DFVFP_EYENORMAL) ? *( (FLOAT*)m_pvData + m_iEyeNormal + iCrd) : 0.f; } FLOAT* GetPtrEyeNormal( void ) const { return (FLOAT*)m_pvData + m_iEyeNormal; } FLOAT GetEyeXYZ( int iCrd ) const { return (m_qwControl & D3DFVFP_EYEXYZ) ? *( (FLOAT*)m_pvData + m_iEyeXYZ + iCrd) : 0.f; } FLOAT* GetPtrEyeXYZ( void ) const { return (FLOAT*)m_pvData + m_iEyeXYZ; } }; //------------------------------------------------------------------------- // S3 compressed texture formats //------------------------------------------------------------------------- // number of s3 compression formats #define NUM_DXT_FORMATS 5 // number of pixels in block #define DXT_BLOCK_PIXELS 16 typedef struct { BYTE rgba[4]; } DXT_COLOR; typedef WORD RGB565; // packed color typedef DWORD PIXBM; // 2 BPP bitmap typedef struct { RGB565 rgb0; // color for index 0 RGB565 rgb1; // color for index 1 PIXBM pixbm; // pixel bitmap } DXTBlockRGB; typedef struct { WORD alphabm[4]; // alpha bitmap at 4 BPP DXTBlockRGB rgb; // color block } DXTBlockAlpha4; typedef struct { BYTE alpha0; // alpha for index 0 BYTE alpha1; // alpha for index 1 BYTE alphabm[6]; // alpha bitmap at 3 BPP DXTBlockRGB rgb; // color block } DXTBlockAlpha3; void DecodeBlockRGB (DXTBlockRGB *pblockSrc, DXT_COLOR colorDst[DXT_BLOCK_PIXELS]); void DecodeBlockAlpha4(DXTBlockAlpha4 *pblockSrc, DXT_COLOR colorDst[DXT_BLOCK_PIXELS]); void DecodeBlockAlpha3(DXTBlockAlpha3 *pblockSrc, DXT_COLOR colorDst[DXT_BLOCK_PIXELS]); /////////////////////////////////////////////////////////////////////////////// #endif // _REFRAST_HPP