GTestAndEngine: triangle.h File Reference

00057 {
00058         geFloat OneOverdX;
00059         geFloat OneOverdY;
00060         geFloat Denominator;
00061         geFloat Width02  = pVertices[0].x-pVertices[2].x;
00062         geFloat Height02 = pVertices[0].y-pVertices[2].y;
00063         geFloat Width12  = pVertices[1].x-pVertices[2].x;
00064         geFloat Height12 = pVertices[1].y-pVertices[2].y;
00065         geFloat d02,d12;
00066         geFloat Size;
00067         assert( pVertices[0].z != 0.0f );
00068         assert( pVertices[1].z != 0.0f );
00069         assert( pVertices[2].z != 0.0f );
00070         
00071         Denominator = ( (Width12 * Height02) - (Width02 * Height12));
00072 
00073 
00074         if (Denominator == 0.0f)
00075                 return GE_FALSE;
00076 
00077         OneOverdX = 1.0f / Denominator;
00078 
00079         OneOverdY = -OneOverdX;
00080 
00081         {
00082                 geFloat Right   = MAX(pVertices[0].x,MAX(pVertices[1].x,pVertices[2].x));
00083                 geFloat Left    = MIN(pVertices[0].x,MIN(pVertices[1].x,pVertices[2].x));
00084                 geFloat Top     = MIN(pVertices[0].y,MIN(pVertices[1].y,pVertices[2].y));
00085                 geFloat Bottom  = MAX(pVertices[0].y,MAX(pVertices[1].y,pVertices[2].y));
00086                 Size = MAX(Right-Left,Bottom-Top);
00087         }
00088 
00089         if (Size < Triangle.MaxAffineSize)
00090                 G->Affine = 1;
00091         else
00092                 G->Affine = 0;
00093 
00094 
00095         if (Triangle.ROPFlags & (TMAP | ZBUF))
00096                 {
00097                         geFloat zmax = MAX(pVertices[0].z,MAX(pVertices[1].z,pVertices[2].z));
00098                         geFloat zmin = MIN(pVertices[0].z,MIN(pVertices[1].z,pVertices[2].z));
00099                         // G->FZScale is used to scale the range of all the interpolators to fit nicely 
00100                         // in the predeterminted fixed point ranges.  These fixed point ranges are setup
00101                         // to minimize visible errors.
00102                         // The following code is unfortunate.  Due to the limited range of the fixed 
00103                         // point math, the FZScale has a limited ability to scale everything else.
00104                         // the following ranges are uesd to keep FZScale within known good boundries. 
00105                         //   It's still possible to break the rasterizer by using Z values that are too 
00106                         //   large or too small.
00107                         if (zmax-zmin > 255.0f ) 
00108                                 {
00109                                         G->FZScale = zmin;
00110                                 }
00111                         else
00112                                 {
00113                                         if (zmin<80.0f) 
00114                                                 G->FZScale = zmin;
00115                                         else
00116                                                 {
00117                                                         if (zmax>500.0f) zmax=500.0f;
00118                                                         G->FZScale = zmax;
00119                                                 }
00120                                 }
00121                         #if 0
00122                                 {// debugging code:
00123                                         char s[1000];
00124                                         sprintf(s,"z[0]=%f\t\tz[1]=%f\t\tz[2]=%f\t\tScale=%f\n",
00125                                                 pVertices[0].z,pVertices[1].z,pVertices[2].z,G->FZScale);
00126                                         OutputDebugString(s);
00127                                 }
00128                         #endif
00129                         if (!G->Affine)
00130                                 {               
00131                                         G->OneOverZ[0] = G->FZScale/pVertices[0].z;
00132                                         G->OneOverZ[1] = G->FZScale/pVertices[1].z;
00133                                         G->OneOverZ[2] = G->FZScale/pVertices[2].z;
00134                                 }
00135                         else
00136                                 {
00137                                         geFloat OneOverZScale = 1.0f / G->FZScale;
00138                                         G->OneOverZ[0] = pVertices[0].z  * OneOverZScale;
00139                                         G->OneOverZ[1] = pVertices[1].z  * OneOverZScale;
00140                                         G->OneOverZ[2] = pVertices[2].z  * OneOverZScale;
00141                                 }
00142 
00143                         d02 = G->OneOverZ[0] - G->OneOverZ[2];
00144                         d12 = G->OneOverZ[1] - G->OneOverZ[2];
00145                         G->FdOneOverZdX = OneOverdX *  ((d12 * Height02) - (d02 * Height12));
00146                         G->dOneOverZdY = OneOverdY *  ((d12 * Width02 ) - (d02 * Width12 ));
00147                 
00148                         G->dOneOverZdX = FXFL_OOZ(G->FdOneOverZdX);
00149                         G->ZScale      =  FXFL_Z(G->FZScale);
00150                 }
00151 
00152         if (Triangle.ROPFlags & TMAP)           
00153                 {
00154                         G->UOverZ[0]   = ((pVertices[0].u * TextureWidth )+ 0.5f);
00155                         G->VOverZ[0]   = ((pVertices[0].v * TextureHeight)+ 0.5f);
00156                         G->UOverZ[1]   = ((pVertices[1].u * TextureWidth )+ 0.5f);
00157                         G->VOverZ[1]   = ((pVertices[1].v * TextureHeight)+ 0.5f);
00158                         G->UOverZ[2]   = ((pVertices[2].u * TextureWidth )+ 0.5f);
00159                         G->VOverZ[2]   = ((pVertices[2].v * TextureHeight) + 0.5f);
00160                         
00161                         if (!G->Affine)
00162                                 {               
00163                                         G->UOverZ[0]   *=  G->OneOverZ[0];
00164                                         G->VOverZ[0]   *=  G->OneOverZ[0];
00165                                         G->UOverZ[1]   *=  G->OneOverZ[1];
00166                                         G->VOverZ[1]   *=  G->OneOverZ[1];
00167                                         G->UOverZ[2]   *=  G->OneOverZ[2];
00168                                         G->VOverZ[2]   *=  G->OneOverZ[2];
00169                                 }
00170                 
00171 
00172                         d02 = G->UOverZ[0] - G->UOverZ[2];
00173                         d12 = G->UOverZ[1] - G->UOverZ[2];
00174                         G->FdUOverZdX   = OneOverdX *  ((d12 * Height02) - (d02 * Height12));
00175                         G->dUOverZdY   = OneOverdY *  ((d12 * Width02 ) - (d02 * Width12 ));
00176 
00177                         d02 = G->VOverZ[0] - G->VOverZ[2];
00178                         d12 = G->VOverZ[1] - G->VOverZ[2];
00179                         G->FdVOverZdX   = OneOverdX *  ((d12 * Height02) - (d02 * Height12));
00180                         G->dVOverZdY   = OneOverdY *  ((d12 * Width02 ) - (d02 * Width12));
00181 
00182                         G->dUOverZdX   =  FXFL_OZ(G->FdUOverZdX);
00183                         G->dVOverZdX   =  FXFL_OZ(G->FdVOverZdX);
00184                 }
00185                                         
00186 
00187         if (Triangle.ROPFlags & LSHADE)
00188                 {
00189                         // can clamp these things higher to remove more small negative overruns.  
00190                         d02 = (pVertices[0].r) - (pVertices[2].r);
00191                         d12 = (pVertices[1].r) - (pVertices[2].r);
00192                         G->FdRdX = OneOverdX * ((d12 * Height02) - (d02 * Height12));
00193                         G->dRdY  = OneOverdY * ((d12 * Width02) - (d02 * Width12));
00194 
00195                         d02 = (pVertices[0].g) - (pVertices[2].g);
00196                         d12 = (pVertices[1].g) - (pVertices[2].g);
00197                         G->FdGdX = OneOverdX * ((d12 * Height02) - (d02 * Height12));
00198                         G->dGdY  = OneOverdY * ((d12 * Width02) - (d02 * Width12));
00199 
00200                         d02 = (pVertices[0].b) - (pVertices[2].b);
00201                         d12 = (pVertices[1].b) - (pVertices[2].b);
00202                         G->FdBdX = OneOverdX * ((d12 * Height02) - (d02 * Height12));
00203                         G->dBdY  = OneOverdY * ((d12 * Width02) - (d02 * Width12));
00204 
00205                         G->dRdX = FXFL_RGB(G->FdRdX);
00206                         G->dGdX = FXFL_RGB(G->FdGdX);
00207                         G->dBdX = FXFL_RGB(G->FdBdX);
00208                 }
00209         
00210         if (!G->Affine)
00211                 {
00212                         geFloat ChangeIndicator = (geFloat)fabs(G->FdOneOverZdX) + (geFloat)fabs(G->dOneOverZdY);
00213 
00214                         if (Triangle.ROPFlags & LMAP) 
00215                                 {
00216                                         // can maybe infer from the lightmap density what's best to do here.
00217                                         G->SubSpanWidth = 16;
00218                                         G->SubSpanShift  = 4;
00219                                 }
00220                         else
00221                                 {
00222                                         if ( ChangeIndicator < 0.0005f) 
00223                                                 {
00224                                                         G->SubSpanWidth = 128;
00225                                                         G->SubSpanShift  = 7;
00226                                                 }
00227                                         else if ( ChangeIndicator < 0.001f) 
00228                                                 {
00229                                                         G->SubSpanWidth = 64;
00230                                                         G->SubSpanShift  = 6;
00231                                                 }
00232                                         else if ( ChangeIndicator < 0.005f)
00233                                                 {
00234                                                         G->SubSpanWidth = 32;
00235                                                         G->SubSpanShift  = 5;
00236                                                 }
00237                                         else
00238                                                 {
00239                                                         G->SubSpanWidth = 16;
00240                                                         G->SubSpanShift  = 4;
00241                                                 }
00242                                 }
00243                 }
00244         else
00245                 {
00246                         G->dOneOverZdX = OOZ_FXP_TO_16_16(G->dOneOverZdX) * Z_FXP_TO_INT(G->ZScale);
00247                         G->dUOverZdX   = OZ_FXP_TO_16_16 (G->dUOverZdX);
00248                         G->dVOverZdX   = OZ_FXP_TO_16_16 (G->dVOverZdX);
00249                 }
00250 
00251         return GE_TRUE;
00252 }


Compounds
struct	Triangle_Edge
struct	Triangle_Gradients
struct	Triangle_Triangle
Defines
#define	USE_FIXED_POINT
#define	OOZ_NUMERATOR_SHIFTER (32)
#define	OOZ_NUMERATOR 0xFFFFFFFF
#define	OZ_FXP_SHIFTER (20)
#define	OOZ_FXP_SHIFTER (26)
#define	OOZ_DIV_PRECISION_BITS (18)
#define	OOZ_MULTIPLY_PRECISION_BITS (12)
#define	OZ_MULTIPLY_PRECISION_BITS (4)
#define	OOZ_DIV_PREP_RSHIFT (OOZ_FXP_SHIFTER - OOZ_DIV_PRECISION_BITS)
#define	RGB_FXP_SHIFTER (15)
#define	Z_FXP_SHIFTER (8)
#define	Z_FXP_MULTIPLIER ((geFloat)( 1 << Z_FXP_SHIFTER ))
#define	OOZ_FXP_MULTIPLIER ((geFloat)( 1 << OOZ_FXP_SHIFTER ))
#define	OZ_FXP_MULTIPLIER ((geFloat)( 1 << OZ_FXP_SHIFTER ))
#define	RGB_FXP_MULTIPLIER ((geFloat)( 1 << RGB_FXP_SHIFTER ))
#define	OOZ_MUL_PREP_RSHIFT (OOZ_NUMERATOR_SHIFTER - OOZ_FXP_SHIFTER + OOZ_DIV_PREP_RSHIFT - OOZ_MULTIPLY_PRECISION_BITS)
#define	OZ_MUL_PREP_RSHIFT (OZ_FXP_SHIFTER - OZ_MULTIPLY_PRECISION_BITS)
#define	OOZ_DIV_PREP(OOZ) ((OOZ)>>OOZ_DIV_PREP_RSHIFT)
#define	OZ_MUL_PREP(OZ) ((OZ)>>OZ_MUL_PREP_RSHIFT)
#define	OOZ_MUL_PREP(OZ) ((OZ)>>OOZ_MUL_PREP_RSHIFT)
#define	OOZ_MUL_Z(OOZ, Z) ( ((OOZ)>>(OOZ_MULTIPLY_PRECISION_BITS-8)) * (Z) )
#define	GRADIENT_OOZ_MUL_Z(OOZ, Z) ( ((OOZ)>>(OOZ_FXPMULTIPLY_PRECISION_BITS-8)) * (Z) )
#define	USE_FIXED_POINT
#define	DEST16BIT
#define	FXFL int32
#define	FXFL_OOZ(XXX) ((int32)((XXX) * OOZ_FXP_MULTIPLIER))
#define	FXFL_OZ(XXX) ((int32)((XXX) * OZ_FXP_MULTIPLIER))
#define	FXFL_RGB(XXX) ((int32)((XXX) * RGB_FXP_MULTIPLIER))
#define	FXFL_Z(XXX) ((int32)((XXX) * Z_FXP_MULTIPLIER))
#define	OOZ_FXP_TO_16_16(XXX) ( (XXX)>>(OOZ_FXP_SHIFTER-16) )
#define	OZ_FXP_TO_16_16(XXX) ( (XXX)>>(OZ_FXP_SHIFTER-16) )
#define	Z_FXP_TO_INT(XXX) ( (XXX)>>Z_FXP_SHIFTER )
#define	RGB_FXP_TO_16_16(XXX) (XXX)
#define	TEXTUREPIXEL unsigned char
#define	LIGHTMAPPIXEL unsigned char
#define	DESTPIXEL unsigned short
#define	ZMAPPIXEL unsigned short
#define	ALPHAMAPPIXEL unsigned short
#define	DESTPIXEL_SHIFTER (sizeof(DESTPIXEL)/2)
#define	TOPDOWN_OR_BOTTOMUP(XXX) ((XXX))
#define	TMAP 0x1
#define	LSHADE 0x2
#define	LFLAT 0x4
#define	LMAP 0x8
#define	AFLAT 0x10
#define	AMAP 0x20
#define	ZSET 0x40
#define	ZTEST 0x80
#define	ZBUF 0x100
#define	SBUF 0x200
#define	D565 0x200
#define	TRASTER_SMALL_DIVIDE_TABLESIZE 129
#define	Triangle_PaletteEntry uint32
Typedefs
typedef Triangle_Gradients	Triangle_Gradients
typedef Triangle_Edge	Triangle_Edge
typedef Triangle_Triangle	Triangle_Triangle
Functions
geBoolean GENESISCC	Triangle_GradientsCompute (Triangle_Gradients G, const DRV_TLVertex pVertices, geFloat TextureWidth, geFloat TextureHeight)
void GENESISCC	Triangle_EdgeCompute (Triangle_Edge E, const Triangle_Gradients Gradients, const DRV_TLVertex *pVertices, int Top, int Bottom, int IsLeftEdge)
Variables
int32	OneOverZ
int32	UOverZ
int32	VOverZ
int32	R
int32	G
int32	B
int32	A
int32	OneMinusA
Triangle_Triangle	Triangle

triangle.h File Reference

Compounds

Defines

Typedefs

Functions

Variables

Define Documentation

Typedef Documentation

Function Documentation

Variable Documentation