GTestAndEngine: SoftDrv/RENDER.H File Reference

03303 {
03304         //hahhah memcpy is faster than anything I can do
03305         //return;
03306         S32     ZBSize;
03307 /*      if(0 && ProcessorInfo.Has3DNow)
03308         {
03309                 ZBSize  =(Window->Width*Window->Height)>>5;
03310 
03311                 _asm    _emit   0x0f    \
03312                 _asm    _emit   0x0e    \
03313                 _asm    mov             eax,[ZBuffer]
03314                 _asm    mov             ebx,[ZBuffer]
03315                 _asm    mov             ecx,dword ptr[ZBSize]
03316 //              _asm    _emit   0x0f                            \
03317 //              _asm    _emit   0x0d                            \
03318 //              _asm    _emit   0x00
03319                 _asm    movq    mm0,[Zero]
03320                 _asm    movq    mm1,[Zero]
03321 //              _asm    movq    mm2,[Zero]
03322 //              _asm    movq    mm3,[Zero]
03323 //              _asm    movq    mm4,[Zero]
03324 //              _asm    movq    mm5,[Zero]
03325 //              _asm    movq    mm6,[Zero]
03326 //              _asm    movq    mm7,[Zero]
03327 //              _asm    _emit   0x0f                            \
03328 //              _asm    _emit   0x0d                            \
03329 //              _asm    _emit   0x40                            \
03330 //              _asm    _emit   0x20                            
03331 ClearLoop3DNow:
03332                 _asm    movq    [eax],mm0
03333                 _asm    movq    [ebx+32],mm1
03334 //              _asm    _emit   0x0f                            \
03335 //              _asm    _emit   0x0d                            \
03336 //              _asm    _emit   0x40                            \
03337 //              _asm    _emit   0x40                            
03338                 _asm    movq    [eax+8],mm0
03339                 _asm    movq    [ebx+40],mm1
03340                 _asm    movq    [eax+16],mm0
03341                 _asm    movq    [ebx+48],mm1
03342                 _asm    movq    [eax+24],mm0
03343                 _asm    movq    [ebx+56],mm1
03344                 _asm    add             eax,64
03345                 _asm    add             ebx,64
03346 //              _asm    _emit   0x0f                            \
03347 //              _asm    _emit   0x0d                            \
03348 //              _asm    _emit   0x40                            \
03349 //              _asm    _emit   0x60                            
03350                 _asm    dec             ecx
03351                 _asm    jnz             ClearLoop3DNow
03352                 _asm    _emit   0x0f    \
03353                 _asm    _emit   0x0e    \
03354         }
03355         else if(0 && ProcessorInfo.HasMMX)
03356         {
03357                 ZBSize  =(Window->Width*Window->Height)>>4;
03358 
03359                 _asm    emms
03360                 _asm    mov             eax,[ZBuffer]
03361                 _asm    mov             ecx,dword ptr[ZBSize]
03362                 _asm    movq    mm0,[Zero]
03363 ClearLoop:
03364                 _asm    movq    [eax],mm0
03365                 _asm    movq    [eax+8],mm0
03366                 _asm    movq    [eax+16],mm0
03367                 _asm    movq    [eax+24],mm0
03368                 _asm    add             eax,32
03369                 _asm    dec             ecx
03370                 _asm    jnz             ClearLoop
03371                 _asm    emms
03372         }
03373         else
03374 */      {
03375                 ZBSize = (Window->Width*Window->Height)<<1;
03376                 memset(ZBuffer, 0, ZBSize);
03377         }
03378 }

00249 {
00250         RECT    SRect2, *pSRect;
00251         int32   Width, Height;
00252         HRESULT ddrval;
00253 
00254         if(!AppInfo.RenderingIsOK)
00255                 return  TRUE;
00256 
00257         if (!SRect)
00258         {
00259                 SRect2.left = 0;
00260                 SRect2.right = THandle->Width;
00261                 SRect2.top = 0;
00262                 SRect2.bottom = THandle->Height;
00263                 pSRect = &SRect2;
00264                 Width = (THandle->Width);
00265                 Height = (THandle->Height);
00266         }
00267         else
00268         {
00269                 pSRect = SRect;
00270                 Width = (pSRect->right - pSRect->left)+1;
00271                 Height = (pSRect->bottom - pSRect->top)+1;
00272         }
00273         
00274         if (x + Width <= 0)
00275                 return TRUE;
00276         if (y + Height <= 0)
00277                 return TRUE;
00278 
00279         if (x >= ClientWindow.Width)
00280                 return TRUE;
00281         
00282         if (y >= ClientWindow.Height)
00283                 return TRUE;
00284         
00285         if (x + Width >= (ClientWindow.Width-1))
00286                 pSRect->right -= ((x + Width) - (ClientWindow.Width-1));
00287         if (y + Height >= (ClientWindow.Height-1))
00288                 pSRect->bottom -= ((y + Height) - (ClientWindow.Height-1));
00289 
00290         if (x < 0)
00291         {
00292                 pSRect->left += -x;
00293                 x=0;
00294         }
00295         if (y < 0)
00296         {
00297                 pSRect->top += -y;
00298                 y=0;
00299         }
00300         
00301 #if 0
00302 
00303 /*      01/24/2002 Wendell Buckner
00304     Change flags for speed...
00305         AppInfo.lpBackBuffer->BltFast(x, y, THandle->MipData[0].Surface, pSRect, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT);*/
00306     AppInfo.lpBackBuffer->BltFast(x, y, THandle->MipData[0].Surface, pSRect, DDBLTFAST_SRCCOLORKEY | DDBLTFAST_DONOTWAIT ); 
00307     
00308 #else
00309         RECT    DRect;
00310 
00311         Width = (pSRect->right - pSRect->left);
00312         Height = (pSRect->bottom - pSRect->top);
00313 
00314         DRect.left = x;
00315         DRect.right = x+Width;
00316         DRect.top = y;
00317         DRect.bottom = y+Height;
00318 
00319 /*      01/24/2002 Wendell Buckner
00320     Change flags for speed...
00321     ddrval= AppInfo.lpBackBuffer->Blt(&DRect, THandle->MipData[0].Surface, pSRect, 
00322                              (DDBLT_KEYSRC | DDBLT_WAIT), NULL);*/
00323         ddrval= AppInfo.lpBackBuffer->Blt(&DRect, THandle->MipData[0].Surface, pSRect, 
00324                              (DDBLT_KEYSRC | DDBLT_DONOTWAIT | DDBLT_ASYNC ), NULL);    
00325 
00326         if(ddrval==DDERR_SURFACELOST)
00327         {
00328                 if (!D3DMain_RestoreAllSurfaces())
00329                         return  GE_FALSE;
00330         }
00331         //AppInfo.lpBackBuffer->Blt(&DRect, Decals[Handle].Surface, pSRect, (DDBLT_WAIT), NULL);
00332 #endif
00333 
00334         return GE_TRUE;
00335 }

00049 {
00050         int32                   i;
00051         DRV_TLVertex    *pPnts;
00052         D3DTLVERTEX             D3DPnts[30], *pD3DPnts;
00053         float                   ZRecip;
00054         float                   Alpha;
00055 
00056         if(!AppInfo.RenderingIsOK)
00057                 return  TRUE;
00058 
00059         if (Flags & DRV_RENDER_FLUSH)
00060         {
00061                 if (!PCache_FlushWorldPolys())
00062                         return FALSE;
00063                 if (!PCache_FlushMiscPolys())
00064                         return FALSE;
00065         }
00066 
00067         Alpha = Pnts->a;
00068         
00069         D3DBlendFunc (D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA);
00070 
00071         D3DSetTexture(0, NULL);
00072         
00073         int32 SAlpha = (int32)Alpha<<24;
00074         pPnts = Pnts;
00075         pD3DPnts = D3DPnts;
00076         for (i=0; i< NumPoints; i++)
00077         {
00078                 ZRecip = 1/pPnts->z;
00079 
00080                 pD3DPnts->sx = pPnts->x;
00081                 pD3DPnts->sy = pPnts->y;
00082                 pD3DPnts->sz = (1.0f - ZRecip);         // ZBUFFER
00083                 pD3DPnts->rhw = ZRecip;
00084                 pD3DPnts->color = SAlpha | ((int32)pPnts->r<<16) | ((int32)pPnts->g<<8) | (int32)pPnts->b;
00085 
00086                 if (AppInfo.FogEnable && !(Flags & DRV_RENDER_POLY_NO_FOG)) // poly fog
00087                 {
00088                         DWORD   FogVal;
00089                         float   Val;
00090 
00091                         Val = pPnts->z;
00092 
00093                         if (Val > AppInfo.FogEnd)
00094                                 Val = AppInfo.FogEnd;
00095 
00096                         FogVal = (DWORD)((AppInfo.FogEnd-Val)/(AppInfo.FogEnd-AppInfo.FogStart)*255.0f);
00097                 
00098                         if (FogVal < 0)
00099                                 FogVal = 0;
00100                         else if (FogVal > 255)
00101                                 FogVal = 255;
00102                 
00103                         pD3DPnts->specular = (FogVal<<24);              // Alpha component in specular is the fog value (0...255)
00104                 }
00105                 else
00106                         pD3DPnts->specular = 0;
00107 
00108                 pPnts++;
00109                 pD3DPnts++;
00110         }
00111 
00112         D3DTexturedPolyOld(D3DPnts, NumPoints);
00113 
00114         if (Flags & DRV_RENDER_FLUSH)
00115         {
00116 /* 02/28/2001 Wendell Buckner
00117    These render states are unsupported d3d 7.0 
00118             AppInfo.lpD3DDevice->SetRenderState(D3DRENDERSTATE_FLUSHBATCH, 0);*/
00119                 AppInfo.lpD3DDevice->EndScene();
00120                 AppInfo.lpD3DDevice->BeginScene();
00121         }
00122 
00123         return TRUE;
00124 }

03384 {
03385 //      U32     OldFlags        =0;
03386 
03387         ZBuffer =(U16 *)malloc(ClientWindow.Width * ClientWindow.Height * 2);
03388 
03389 /*      if(!VirtualProtect((U8 *)ZBuffer,
03390                 (ClientWindow.Width * ClientWindow.Height)*2,
03391                 PAGE_READWRITE | PAGE_NOCACHE,
03392                 &OldFlags))
03393         {
03394                 ErrorPrintf("Failed to set zbuffer page uncacheable\n");
03395         }
03396 */
03397         if(!ZBuffer)
03398         {
03399                 SetLastDrvError(DRV_ERROR_NO_MEMORY, "SOFT_RenderInit:  Not enough memory for ZBuffer.");
03400                 return FALSE;
03401         }
03402         
03403         #define Mul(a) (uint32)((1.0f/(geFloat)(a))*65536*32768)
03404         //#define Mul(a) ((uint32)((1.0f/(geFloat)(a))*(1<<31)))
03405 
03406         return GE_TRUE;
03407 }

00228 {
00229         if(!AppInfo.RenderingIsOK)
00230         {
00231                 return  TRUE;
00232         }
00233         else if (Flags & DRV_RENDER_FLUSH)
00234         {
00235                 PCache_FlushMiscPolys();
00236         }
00237                                 
00238         PCache_InsertMiscPoly(Pnts, NumPoints, THandle, Flags);
00239 
00240         if (Flags & DRV_RENDER_FLUSH)
00241         {
00242                 PCache_FlushMiscPolys();
00243         }
00244 
00245         return TRUE;
00246 }

03410 {
03411         if(ZBuffer)
03412         {
03413                 free(ZBuffer);
03414                 ZBuffer =NULL;
03415         }
03416         return  GE_TRUE;
03417 }

00127 {
00128 #ifdef USE_SPANS
00129         int32                   i;
00130         DRV_TLVertex    *CPnt;
00131         int32                   OldPixels;
00132         int32                   Mip = 0;
00133         int32                   MinY, MaxY, MinX, MaxX;
00134         int32                   FirstX, FirstY, x1, y1, x2, y2;
00135         SPAN                    *pSpans;
00136         int32                   WidthHeight;
00137 #endif
00138         
00139         if(!AppInfo.RenderingIsOK)
00140         {
00141                 return  TRUE;
00142         }
00143         else if (Flags & DRV_RENDER_FLUSH)
00144         {
00145                 if (!PCache_FlushWorldPolys())
00146                         return FALSE;
00147         }
00148 
00149 #ifdef USE_SPANS
00150         if (RenderMode != RENDER_WORLD)
00151                 goto NotWorld;
00152         
00153         CPnt = Pnts;                                            // Set to the first points in the array 
00154 
00155         x1 = (int32)CPnt->x;
00156         y1 = (int32)CPnt->y;
00157 
00158         FirstX = MinX = MaxX = x1;
00159         FirstY = MinY = MaxY = y1;
00160 
00161         for (i = 1; i < NumPoints; i++)
00162         {
00163                 CPnt++;
00164 
00165                 x2 = (int32)CPnt->x;
00166                 y2 = (int32)CPnt->y;
00167 
00168                 EdgeOutNoUV (x1, y1, x2, y2);
00169 
00170                 if (x2 > MaxX) 
00171                         MaxX = x2;
00172                 else if (x2 < MinX) 
00173                         MinX = x2;
00174         
00175                 if (y2 > MaxY) 
00176                         MaxY = y2;
00177                 else if (y2 < MinY) 
00178                         MinY = y2;
00179 
00180                 // Swap
00181                 x1 = x2;
00182                 y1 = y2;
00183         }
00184 
00185         // Close the poly
00186         EdgeOutNoUV (x1, y1, FirstX, FirstY);
00187 
00188         OldPixels = NumWorldPixels;
00189         
00190         pSpans = &SpanLines[MinY];
00191 
00192         WidthHeight = ClientWindow.Width*ClientWindow.Height;
00193         for (i = MinY; i <= MaxY; i++, pSpans++)
00194         {
00195                 AddSpanNoUV(pSpans->x1, pSpans->x2, i);
00196 
00197                 if (NumWorldPixels >= WidthHeight)
00198                         break;
00199         }
00200 
00201         if ((MaxY - MinY) < 3)
00202                 goto NotWorld;
00203 
00204         if ((MaxX - MinX) < 3)
00205                 goto NotWorld;
00206 
00207         if (NumWorldPixels == OldPixels)
00208                 return TRUE;
00209 
00210         NotWorld:;
00211 #endif
00212         
00213         D3DDRV.NumRenderedPolys++;
00214         
00215         // Insert the poly into the world cache, for later rendering
00216         PCache_InsertWorldPoly(Pnts, NumPoints, THandle, TexInfo, LInfo, Flags);
00217 
00218         if (Flags & DRV_RENDER_FLUSH)
00219         {
00220                 if (!PCache_FlushWorldPolys())
00221                         return FALSE;
00222         }
00223 
00224         return TRUE;
00225 }


Defines
#define	ZBUFFER_PREC (65536.0f * 65536.0f)
#define	ZBUFFER_SHIFT 21
#define	ZBUFFER_RIGHT_SHIFT 10
Typedefs
typedef int32	Fixed16
Functions
BOOL	RenderInit (DRV_Window *Window)
BOOL	RenderShutdown (void)
void	ClearZBuffer (DRV_Window *Window)
BOOL DRIVERCC	RenderGouraudPoly (DRV_TLVertex *Pnts, int32 NumPoints, uint32 Flags)
BOOL DRIVERCC	RenderWorldPoly (DRV_TLVertex Pnts, int32 NumPoints, geRDriver_THandle THandle, DRV_TexInfo TexInfo, DRV_LInfo LInfo, uint32 Flags)
BOOL DRIVERCC	RenderMiscTexturePoly (DRV_TLVertex Pnts, int32 NumPoints, geRDriver_THandle THandle, uint32 Flags)
BOOL DRIVERCC	DrawDecal (geRDriver_THandle THandle, RECT SRect, int32 x, int32 y)
Variables
int32	SpanMode
int32	PolyMode
BOOL	PolyIsTrans
BOOL	PolyVisible
int32	ActuallVisible
int32	NumPixels
int32	SMIN
int32	SMAX
uint8	GMipLevel
int32	GMipLevel4
int32	GMipLevel20
int32	GMipLevel4_8
int32	GLMapAdd
DRV_LInfo *	GLInfo
DRV_Bitmap *	GBitmap
geRDriver_THandle *	GTexture
uint16 *	pScrPtr16bpp
int32	GLightWidth
uint8 *	GLightData
int32	DeltaX
int32	Remaining
int32	N_Runs
int32	PixelCount
uint16 *	Source
uint16 *	Dest
int32	U2
int32	V2
int32	StepU
int32	StepV
geFloat	UDivZ
geFloat	VDivZ
geFloat	Zi
geFloat	Z
geFloat	Dx
geFloat	Dy
geFloat	PixelEnd
int32	TxWhole
int32	TyWhole
int32	TxFract
int32	TyFract
geFloat	UDivZnStepX
geFloat	VDivZnStepX
geFloat	ZinStepX
int32	Junk [2]
geFloat	Real16
geFloat	Real65536
int32	U
int32	V
int32	GW
int32	GWMask
int32	GH
int32	GHMask
uint8 *	GBitPtr
uint16 *	GBitPtr16
uint16 *	ZBuffer
geFloat	UDivZStepX
geFloat	UDivZStepY
geFloat	VDivZStepX
geFloat	VDivZStepY
geFloat	UDivZOrigin
geFloat	VDivZOrigin
geFloat	UDivZ16StepX
geFloat	VDivZ16StepX
geFloat	Zi16StepX
geFloat	UDivZ32StepX
geFloat	VDivZ32StepX
geFloat	Zi32StepX
geFloat	ZiStepX
geFloat	ZiStepY
geFloat	ZiOrigin
Fixed16	UAdjust
Fixed16	VAdjust
Fixed16	UAdjustL
Fixed16	VAdjustL
Fixed16	UAdjust1
Fixed16	VAdjust1
Fixed16	UAdjust2
Fixed16	VAdjust2
Fixed16	MaxU
Fixed16	MaxV

RENDER.H File Reference

Defines

Typedefs

Functions

Variables

Define Documentation

Typedef Documentation

Function Documentation

Variable Documentation