quake: merge some fixed-point optimizations from PocketQuake
The PocketQuake project, available below, has some nice fixed-point code: https://web.archive.org/web/20150412233306/http://quake.pocketmatrix.com/PocketQuake0062_src.zip I'd like to see most of them merged into our Quake port. This commit gives +0.9FPS on ipod6g. (A big change given that it was running at only 9.7FPS to begin with!) Change-Id: I91931bdd5c22f14fb28616de938a03b4e7d7b076
This commit is contained in:
Franklin Wei
parent
3fffabf50d
commit
ee70dad305
10 changed files with 866 additions and 6 deletions
246
apps/plugins/sdl/progs/quake/FixedPointMath.h
Normal file
246
apps/plugins/sdl/progs/quake/FixedPointMath.h
Normal file
|
|
@ -0,0 +1,246 @@
|
|||
#ifndef _FIXEDPOINTMATH_H
|
||||
#define _FIXEDPOINTMATH_H
|
||||
//Fixed point math routines (16.16)
|
||||
//Dan East
|
||||
//01-24-2001
|
||||
|
||||
#define FPM_PI 205887L
|
||||
#define FPM_2PI 411775L
|
||||
#define FPM_E 178144L
|
||||
#define FPM_ROOT2 74804L
|
||||
#define FPM_ROOT3 113512L
|
||||
#define FPM_GOLDEN 106039L
|
||||
#define FPM_MAX 0x7fff0000
|
||||
|
||||
|
||||
typedef long fixedpoint_t;
|
||||
typedef long fixedpoint8_24_t;
|
||||
|
||||
|
||||
fixedpoint_t fpm_FromFloat(double f);
|
||||
float fpm_ToFloat(fixedpoint_t fxp);
|
||||
|
||||
fixedpoint_t fpm_FromLong(long l);
|
||||
long fpm_ToLong(fixedpoint_t fxp);
|
||||
|
||||
fixedpoint_t fpm_Add(fixedpoint_t fxp1, fixedpoint_t fxp2);
|
||||
fixedpoint_t fpm_Add3(fixedpoint_t fxp1, fixedpoint_t fxp2, fixedpoint_t fxp3);
|
||||
|
||||
fixedpoint_t fpm_Sub(fixedpoint_t fxp1, fixedpoint_t fxp2);
|
||||
|
||||
fixedpoint_t fpm_Mul(fixedpoint_t fxp1, fixedpoint_t fxp2);
|
||||
|
||||
fixedpoint_t fpm_Div(fixedpoint_t fxp1, fixedpoint_t fxp2);
|
||||
fixedpoint_t fpm_DivInt(fixedpoint_t fxp1, long l);
|
||||
fixedpoint_t fpm_Abs(fixedpoint_t fxp);
|
||||
|
||||
fixedpoint_t fpm_Ceil(fixedpoint_t fxp);
|
||||
fixedpoint_t fpm_Floor(fixedpoint_t fxp);
|
||||
|
||||
fixedpoint_t fpm_Sqrt(fixedpoint_t fxp);
|
||||
fixedpoint_t fpm_Sqr(fixedpoint_t fxp);
|
||||
|
||||
fixedpoint_t fpm_Inv(fixedpoint_t fxp);
|
||||
|
||||
fixedpoint_t fpm_Sin(fixedpoint_t fxp);
|
||||
fixedpoint_t fpm_Cos(fixedpoint_t fxp);
|
||||
fixedpoint_t fpm_Tan(fixedpoint_t fxp);
|
||||
fixedpoint_t fpm_ATan(fixedpoint_t fxp);
|
||||
//These take degrees
|
||||
fixedpoint_t fpm_SinDeg(fixedpoint_t fxp);
|
||||
fixedpoint_t fpm_CosDeg(fixedpoint_t fxp);
|
||||
fixedpoint_t fpm_TanDeg(fixedpoint_t fxp);
|
||||
fixedpoint_t fpm_ATanDeg(fixedpoint_t fxp);
|
||||
|
||||
|
||||
#define FPM_FROMFLOAT(f) fpm_FromFloat(f)
|
||||
#define FPM_FROMFLOATC(f) ((long)((f) * 65536.0 )) //Constant version
|
||||
#define FPM_TOFLOAT(fxp) fpm_ToFloat(fxp)
|
||||
|
||||
#define FPM_FROMLONG(l) fpm_FromLong(l)
|
||||
#define FPM_FROMLONGC(l) ((l)<<16) //Constant version
|
||||
#define FPM_TOLONG(l) fpm_ToLong(l)
|
||||
|
||||
#define FPM_ADD(f1, f2) fpm_Add(f1, f2)
|
||||
#define FPM_ADD3(f1, f2, f3) fpm_Add3(f1, f2, f3)
|
||||
#define FPM_INC(f1) ((f1)=FPM_ADD(f1, FPM_FROMLONG(1)))
|
||||
|
||||
#define FPM_SUB(f1, f2) fpm_Sub(f1, f2)
|
||||
#define FPM_DEC(f1) ((f1)=FPM_SUB(f1, FPM_FROMLONG(1)))
|
||||
|
||||
#define FPM_MUL(f1, f2) fpm_Mul(f1, f2)
|
||||
|
||||
#define FPM_DIV(n, d) fpm_Div(n, d)
|
||||
#define FPM_DIVINT(n, d) fpm_DivInt(n, d)
|
||||
|
||||
#define FPM_ABS(fxp) fpm_Abs(fxp)
|
||||
|
||||
#define FPM_CEIL(fxp) fpm_Ceil(fxp)
|
||||
#define FPM_FLOOR(fxp) fpm_Floor(fxp)
|
||||
|
||||
#define FPM_SQRT(fxp) fpm_Sqrt(fxp)
|
||||
#define FPM_SQR(fxp) fpm_Sqr(fxp)
|
||||
|
||||
#define FPM_INV(fxp) fpm_Inv(fxp)
|
||||
|
||||
//These take radians
|
||||
#define FPM_SIN(r) fpm_Sin(r)
|
||||
#define FPM_COS(r) fpm_Cos(r)
|
||||
#define FPM_TAN(r) fpm_Tan(r)
|
||||
#define FPM_ATAN(r) fpm_ATan(r)
|
||||
|
||||
//These take degrees
|
||||
#define FPM_SIN_DEG(d) fpm_SinDeg(d)
|
||||
#define FPM_COS_DEG(d) fpm_CosDeg(d)
|
||||
#define FPM_TAN_DEG(d) fpm_TanDeg(d)
|
||||
#define FPM_ATAN_DEG(d) fpm_ATanDeg(d)
|
||||
|
||||
fixedpoint8_24_t fpm_FromFloat(double f);
|
||||
float fpm_ToFloat8_24(fixedpoint8_24_t fxp);
|
||||
|
||||
fixedpoint8_24_t fpm_FromLong8_24(long l);
|
||||
long fpm_ToLong8_24(fixedpoint8_24_t fxp);
|
||||
|
||||
fixedpoint8_24_t fpm_FromFixedPoint(fixedpoint_t fxp);
|
||||
fixedpoint_t fpm_ToFixedPoint(fixedpoint8_24_t fxp);
|
||||
|
||||
fixedpoint8_24_t fpm_Add8_24(fixedpoint8_24_t fxp1, fixedpoint8_24_t fxp2);
|
||||
fixedpoint8_24_t fpm_Add38_24(fixedpoint8_24_t fxp1, fixedpoint8_24_t fxp2, fixedpoint8_24_t fxp3);
|
||||
|
||||
fixedpoint8_24_t fpm_Sub8_24(fixedpoint8_24_t fxp1, fixedpoint8_24_t fxp2);
|
||||
|
||||
fixedpoint8_24_t fpm_Mul8_24(fixedpoint8_24_t fxp1, fixedpoint8_24_t fxp2);
|
||||
fixedpoint_t fpm_MulMixed8_24(fixedpoint8_24_t fxp1, fixedpoint_t fxp2);
|
||||
|
||||
fixedpoint8_24_t fpm_Div8_24(fixedpoint8_24_t fxp1, fixedpoint8_24_t fxp2);
|
||||
fixedpoint8_24_t fpm_DivInt8_24(fixedpoint8_24_t fxp1, long l);
|
||||
fixedpoint8_24_t fpm_DivInt64_8_24(fixedpoint8_24_t fxp1, long long l);
|
||||
|
||||
fixedpoint8_24_t fpm_Abs8_24(fixedpoint8_24_t fxp);
|
||||
|
||||
fixedpoint8_24_t fpm_Ceil8_24(fixedpoint8_24_t fxp);
|
||||
fixedpoint8_24_t fpm_Floor8_24(fixedpoint8_24_t fxp);
|
||||
|
||||
fixedpoint8_24_t fpm_Sqrt8_24(fixedpoint8_24_t fxp);
|
||||
fixedpoint8_24_t fpm_Sqr8_24(fixedpoint8_24_t fxp);
|
||||
|
||||
fixedpoint8_24_t fpm_Inv8_24(fixedpoint8_24_t fxp);
|
||||
|
||||
|
||||
#define FPM_FROMFLOAT8_24(f) fpm_FromFloat8_24(f)
|
||||
#define FPM_FROMFLOATC8_24(f) ((long)((f) * 16777216.0 )) //Constant version
|
||||
#define FPM_TOFLOAT8_24(fxp) fpm_ToFloat8_24(fxp)
|
||||
|
||||
#define FPM_FROMLONG8_24(l) fpm_FromLong8_24(l)
|
||||
#define FPM_FROMLONGC8_24(l) ((l)<<24) //Constant version
|
||||
#define FPM_TOLONG8_24(l) fpm_ToLong8_24(l)
|
||||
|
||||
|
||||
/*
|
||||
extern __int64 FPM_TMPVAR_INT64;
|
||||
|
||||
#define FPM_FROMFLOAT(f) ((long)((f) * 65536.0 )) //+0.5
|
||||
#define FPM_TOFLOAT(fxp) (((float)(fxp)) / 65536.0)
|
||||
|
||||
#define FPM_FROMLONG(l) ((l)<<16)
|
||||
#define FPM_TOLONG(l) ((l)<0?(-(long)((l)^0xffffffff)>>16):(((l)>>16)&0x0000ffff))
|
||||
|
||||
#define FPM_ADD(f1, f2) ((f1)+(f2))
|
||||
#define FPM_ADD3(f1, f2, f3) ((f1)+(f2)+(f3))
|
||||
#define FPM_INC(f1) ((f1)=FPM_ADD(f1, FPM_FROMLONG(1)))
|
||||
|
||||
#define FPM_SUB(f1, f2) ((f1)-(f2))
|
||||
#define FPM_DEC(f1) ((f1)=FPM_SUB(f1, FPM_FROMLONG(1)))
|
||||
|
||||
#define FPM_MUL(f1, f2) (((f1)>>8)*((f2)>>8))
|
||||
//#define FPM_MUL(f1, f2) ((fixedpoint_t)((FPM_TMPVAR_INT64=(f1))*(f2))>>16)
|
||||
//#define FPM_MUL(f1, f2) (((f1)*(f2))>>16)
|
||||
//TODO: This needs to be done without copying to another var
|
||||
#define FPM_DIV(n, d) ((fixedpoint_t)(((FPM_TMPVAR_INT64=(n))<<16)/d))
|
||||
#define FPM_DIVINT(n, d) ((fixedpoint_t)((n)/(d)))
|
||||
//#define FPM_DIV(n, d) ((long)(((__int64)n)<<16)/(d))
|
||||
|
||||
#define FPM_ABS(fxp) (abs(fxp))
|
||||
|
||||
//TODO: could be more effecient
|
||||
#define FPM_CEIL(fxp) ((fxp)&0x0000ffff?((fxp)<=0?((fxp)&0xffff0000):(((fxp)&0xffff0000)+FPM_FROMLONG(1))):(fxp))
|
||||
#define FPM_FLOOR(fxp) ((fxp)&0x0000ffff?((fxp)<0?(((fxp)&0xffff0000)-FPM_FROMLONG(1)):((fxp)&0xffff0000)):(fxp))
|
||||
|
||||
//TODO: Implement sqrt mathematically instead of converting to float and back
|
||||
#define FPM_SQRT(fxp) (FPM_FROMFLOAT(sqrt(FPM_TOFLOAT(fxp))))
|
||||
#define FPM_SQR(fxp) (FPM_MUL(fxp,fxp)>>16)
|
||||
|
||||
#define FPM_INV(fxp) (FPM_DIV(0x10000, fxp))
|
||||
//TODO: Calc trig functions (or lookup) instead of converting to float and back
|
||||
//These take radians
|
||||
#define FPM_SIN(r) (FPM_FROMFLOAT(sin(FPM_TOFLOAT(r))))
|
||||
#define FPM_COS(r) (FPM_FROMFLOAT(cos(FPM_TOFLOAT(r))))
|
||||
#define FPM_TAN(r) (FPM_FROMFLOAT(tan(FPM_TOFLOAT(r))))
|
||||
#define FPM_ATAN(r) (FPM_FROMFLOAT(atan(FPM_TOFLOAT(r))))
|
||||
|
||||
//These take degrees
|
||||
#define FPM_SIN_DEG(d) (FPM_SIN(FPM_DIV(FPM_MUL(d,FPM_PI),0xB40000))) //0xB40000 = 180.0
|
||||
#define FPM_COS_DEG(d) (FPM_COS(FPM_DIV(FPM_MUL(d,FPM_PI),0xB40000)))
|
||||
#define FPM_TAN_DEG(d) (FPM_TAN(FPM_DIV(FPM_MUL(d,FPM_PI),0xB40000)))
|
||||
#define FPM_ATAN_DEG(d) (FPM_ATAN(FPM_DIV(FPM_MUL(d,FPM_PI),0xB40000)))
|
||||
|
||||
*/
|
||||
/*
|
||||
#define FPM_PI 3.14
|
||||
#define FPM_2PI (3.14*2)
|
||||
#define FPM_E 178144L
|
||||
#define FPM_ROOT2 74804L
|
||||
#define FPM_ROOT3 113512L
|
||||
#define FPM_GOLDEN 106039L
|
||||
|
||||
|
||||
typedef float fixedpoint_t;
|
||||
//This variable must be declared in one of the implementation files.
|
||||
extern __int64 FPM_TMPVAR_INT64;
|
||||
|
||||
#define FPM_FROMFLOAT(f) (f)
|
||||
#define FPM_TOFLOAT(fxp) (fxp)
|
||||
|
||||
#define FPM_FROMLONG(l) ((float)l)
|
||||
#define FPM_TOLONG(fxp) ((long)fxp)
|
||||
|
||||
#define FPM_ADD(f1, f2) ((f1)+(f2))
|
||||
#define FPM_ADD3(f1, f2, f3) ((f1)+(f2)+(f3))
|
||||
#define FPM_INC(f1) ((f1)++)
|
||||
|
||||
#define FPM_SUB(f1, f2) ((f1)-(f2))
|
||||
#define FPM_DEC(f1) ((f1)--)
|
||||
|
||||
#define FPM_MUL(f1, f2) ((f1)*(f2))
|
||||
//#define FPM_MUL(f1, f2) ((fixedpoint_t)((FPM_TMPVAR_INT64=(f1))*(f2))>>16)
|
||||
//#define FPM_MUL(f1, f2) (((f1)*(f2))>>16)
|
||||
//TODO: This needs to be done without copying to another var
|
||||
#define FPM_DIV(n, d) ((n)/(d))
|
||||
//#define FPM_DIV(n, d) ((long)(((__int64)n)<<16)/(d))
|
||||
|
||||
#define FPM_ABS(fxp) (abs(fxp))
|
||||
|
||||
//TODO: Implement ceil mathematically instead of converting to float and back
|
||||
#define FPM_CEIL(fxp) (ceil(fxp))
|
||||
#define FPM_FLOOR(fxp) (floor(fxp))
|
||||
|
||||
//TODO: Implement sqrt mathematically instead of converting to float and back
|
||||
#define FPM_SQRT(fxp) (sqrt(fxp))
|
||||
#define FPM_SQR(fxp) ((fxp)*(fxp))
|
||||
|
||||
#define FPM_INV(fxp) (1/(fxp))
|
||||
//TODO: Calc trig functions (or lookup) instead of converting to float and back
|
||||
//These take radians
|
||||
#define FPM_SIN(r) (sin(r))
|
||||
#define FPM_COS(r) (cos(r))
|
||||
#define FPM_TAN(r) (tan(r))
|
||||
#define FPM_ATAN(r) (atan(r))
|
||||
|
||||
//These take degrees
|
||||
#define FPM_SIN_DEG(d) FPM_SIN(((d)*FPM_PI)/180.0) //0xB40000 = 180.0
|
||||
#define FPM_COS_DEG(d) FPM_COS(((d)*FPM_PI)/180.0)
|
||||
#define FPM_TAN_DEG(d) FPM_TAN(((d)*FPM_PI)/180.0)
|
||||
#define FPM_ATAN_DEG(d) FPM_ATAN(((d)*FPM_PI)/180.0)
|
||||
*/
|
||||
|
||||
#endif //_FIXEDPOINTMATH_H
|
||||
|
|
@ -122,6 +122,7 @@ void D_PolysetScanLeftEdge (int height);
|
|||
D_PolysetDraw
|
||||
================
|
||||
*/
|
||||
#ifndef USE_PQ_OPT
|
||||
void D_PolysetDraw (void)
|
||||
{
|
||||
spanpackage_t spans[DPS_MAXSPANS + 1 +
|
||||
|
|
@ -140,7 +141,21 @@ void D_PolysetDraw (void)
|
|||
D_DrawNonSubdiv ();
|
||||
}
|
||||
}
|
||||
#else
|
||||
//JB: Optimization
|
||||
//Dan East: May result in image quality loss. Actual performance gain not verified.
|
||||
void D_PolysetDraw (void)
|
||||
{
|
||||
spanpackage_t spans[DPS_MAXSPANS + 1 +
|
||||
((CACHE_SIZE - 1) / sizeof(spanpackage_t)) + 1];
|
||||
// one extra because of cache line pretouching
|
||||
|
||||
a_spans = (spanpackage_t *)
|
||||
(((long)&spans[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
|
||||
|
||||
D_DrawNonSubdiv ();
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
================
|
||||
|
|
@ -528,6 +543,7 @@ void D_PolysetSetUpForLineScan(fixed8_t startvertu, fixed8_t startvertv,
|
|||
D_PolysetCalcGradients
|
||||
================
|
||||
*/
|
||||
#ifndef USE_PQ_OPT4
|
||||
void D_PolysetCalcGradients (int skinwidth)
|
||||
{
|
||||
float xstepdenominv, ystepdenominv, t0, t1;
|
||||
|
|
@ -583,7 +599,88 @@ void D_PolysetCalcGradients (int skinwidth)
|
|||
|
||||
a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16);
|
||||
}
|
||||
#else
|
||||
void D_PolysetCalcGradients (int skinwidth)
|
||||
{
|
||||
//Dan East: Fixed point conversion
|
||||
int p01_minus_p21, p11_minus_p21, p00_minus_p20, p10_minus_p20, t0, t1;
|
||||
int tmp, ydenom;
|
||||
|
||||
//float xstepdenominv = (float)(1.0 / (float)d_xdenom);
|
||||
//float ystepdenominv = -xstepdenominv;
|
||||
//int checkx, checky;
|
||||
|
||||
p00_minus_p20 = (r_p0[0] - r_p2[0]);
|
||||
p01_minus_p21 = (r_p0[1] - r_p2[1]);
|
||||
p10_minus_p20 = (r_p1[0] - r_p2[0]);
|
||||
p11_minus_p21 = (r_p1[1] - r_p2[1]);
|
||||
|
||||
//xstepdenominv = d_xdenom;
|
||||
ydenom=-d_xdenom;
|
||||
//ystepdenominv = -xstepdenominv;
|
||||
|
||||
t0 = (r_p0[4] - r_p2[4]);
|
||||
t1 = (r_p1[4] - r_p2[4]);
|
||||
//TODO: Ceil has been removed
|
||||
tmp=t1 * p01_minus_p21 - t0 * p11_minus_p21;
|
||||
r_lstepx = tmp / d_xdenom;
|
||||
if (tmp%d_xdenom) r_lstepx++;
|
||||
|
||||
tmp=t1 * p00_minus_p20 - t0 * p10_minus_p20;
|
||||
r_lstepy = tmp / ydenom;
|
||||
if (tmp%ydenom) r_lstepy++;
|
||||
/*
|
||||
checkx = (int)ceil((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv);
|
||||
checky = (int)ceil((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv);
|
||||
if (checkx-r_lstepx>1||checkx-r_lstepx<-1)
|
||||
r_lstepx=r_lstepx;
|
||||
if (checky-r_lstepy>1||checky-r_lstepy<-1)
|
||||
r_lstepy=r_lstepy;
|
||||
*/
|
||||
t0 = (r_p0[2] - r_p2[2]);
|
||||
t1 = (r_p1[2] - r_p2[2]);
|
||||
r_sstepx = (t1 * p01_minus_p21 - t0 * p11_minus_p21) / d_xdenom;
|
||||
r_sstepy = (t1 * p00_minus_p20 - t0* p10_minus_p20) / ydenom;
|
||||
/*
|
||||
checkx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv);
|
||||
checky = (int)((t1 * p00_minus_p20 - t0* p10_minus_p20) * ystepdenominv);
|
||||
if (checkx-r_sstepx>1||checkx-r_sstepx<-1)
|
||||
r_lstepx=r_lstepx;
|
||||
if (checky-r_sstepy>1||checky-r_sstepy<-1)
|
||||
r_lstepy=r_lstepy;
|
||||
*/
|
||||
|
||||
t0 = (r_p0[3] - r_p2[3]);
|
||||
t1 = (r_p1[3] - r_p2[3]);
|
||||
r_tstepx = (t1 * p01_minus_p21 - t0 * p11_minus_p21) / d_xdenom;
|
||||
r_tstepy = (t1 * p00_minus_p20 - t0 * p10_minus_p20) / ydenom;
|
||||
/*
|
||||
checkx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv);
|
||||
checky = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv);
|
||||
if (checkx-r_tstepx>1||checkx-r_tstepx<-1)
|
||||
r_lstepx=r_lstepx;
|
||||
if (checky-r_tstepy>1||checky-r_tstepy<-1)
|
||||
r_lstepy=r_lstepy;
|
||||
*/
|
||||
|
||||
t0 = (r_p0[5] - r_p2[5]);
|
||||
t1 = (r_p1[5] - r_p2[5]);
|
||||
r_zistepx = (t1 * p01_minus_p21 - t0 * p11_minus_p21) / d_xdenom;
|
||||
r_zistepy = (t1 * p00_minus_p20 - t0 * p10_minus_p20) / ydenom;
|
||||
/*
|
||||
checkx = (int)((t1 * p01_minus_p21 - t0 * p11_minus_p21) * xstepdenominv);
|
||||
checky = (int)((t1 * p00_minus_p20 - t0 * p10_minus_p20) * ystepdenominv);
|
||||
if (checkx-r_zistepx>1||checkx-r_zistepx<-1)
|
||||
r_lstepx=checkx;
|
||||
if (checky-r_zistepy>1||checky-r_zistepy<-1)
|
||||
r_lstepy=checky;
|
||||
*/
|
||||
|
||||
a_sstepxfrac = r_sstepx & 0xFFFF;
|
||||
a_tstepxfrac = r_tstepx & 0xFFFF;
|
||||
a_ststepxwhole = skinwidth * (r_tstepx >> 16) + (r_sstepx >> 16);
|
||||
}
|
||||
#endif
|
||||
#endif // !id386
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -19,6 +19,19 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|||
*/
|
||||
// mathlib.h
|
||||
|
||||
//Dan East:
|
||||
#include "FixedPointMath.h"
|
||||
|
||||
#ifdef USE_PQ_OPT
|
||||
typedef int fpvec3[3];
|
||||
#endif
|
||||
|
||||
typedef fixedpoint_t vec3_FPM_t[3];
|
||||
typedef fixedpoint8_24_t vec3_8_24FPM_t[3];
|
||||
typedef fixedpoint_t vec5_FPM_t[5];
|
||||
|
||||
//End Dan
|
||||
|
||||
typedef float vec_t;
|
||||
typedef vec_t vec3_t[3];
|
||||
typedef vec_t vec5_t[5];
|
||||
|
|
|
|||
|
|
@ -49,6 +49,16 @@ typedef struct
|
|||
vec3_t position;
|
||||
} mvertex_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int position[3];
|
||||
} mvertex_fxp_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
vec3_FPM_t position;
|
||||
} mvertex_FPM_t;
|
||||
|
||||
#define SIDE_FRONT 0
|
||||
#define SIDE_BACK 1
|
||||
#define SIDE_ON 2
|
||||
|
|
@ -331,6 +341,10 @@ typedef struct model_s
|
|||
|
||||
int numvertexes;
|
||||
mvertex_t *vertexes;
|
||||
|
||||
#ifdef USE_PQ_OPT2
|
||||
mvertex_fxp_t *vertexes_fxp;
|
||||
#endif
|
||||
|
||||
int numedges;
|
||||
medge_t *edges;
|
||||
|
|
|
|||
|
|
@ -25,6 +25,18 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|||
#include <stdarg.h>
|
||||
#include <setjmp.h>
|
||||
|
||||
#define FIXEDPOINT_OPT // FW: enable fixed-point optimizations
|
||||
|
||||
/* Fixed-point optimizations, thanks to Pocket Quake and Dan East. */
|
||||
#ifdef FIXEDPOINT_OPT
|
||||
#define USE_PQ_OPT
|
||||
#define USE_PQ_OPT1
|
||||
//#define USE_PQ_OPT2
|
||||
//#define USE_PQ_OPT3 // don't use
|
||||
#define USE_PQ_OPT4
|
||||
//#define USE_PQ_OPT5
|
||||
#endif
|
||||
|
||||
#define QUAKE_GAME // as opposed to utilities
|
||||
|
||||
#undef VERSION
|
||||
|
|
|
|||
|
|
@ -27,6 +27,11 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|||
//
|
||||
qboolean insubmodel;
|
||||
entity_t *currententity;
|
||||
|
||||
#ifdef USE_PQ_OPT1
|
||||
int modelorg_fxp[3];
|
||||
#endif
|
||||
|
||||
vec3_t modelorg, base_modelorg;
|
||||
// modelorg is the viewpoint reletive to
|
||||
// the currently rendering entity
|
||||
|
|
@ -440,6 +445,10 @@ void R_DrawSubmodelPolygons (model_t *pmodel, int clipflags)
|
|||
}
|
||||
}
|
||||
|
||||
#ifdef USE_PQ_OPT1
|
||||
int clipplanes_fxp[4][3];
|
||||
int clipdist_fxp[4];
|
||||
#endif
|
||||
|
||||
/*
|
||||
================
|
||||
|
|
@ -449,11 +458,16 @@ R_RecursiveWorldNode
|
|||
void R_RecursiveWorldNode (mnode_t *node, int clipflags)
|
||||
{
|
||||
int i, c, side, *pindex;
|
||||
vec3_t acceptpt, rejectpt;
|
||||
mplane_t *plane;
|
||||
msurface_t *surf, **mark;
|
||||
mleaf_t *pleaf;
|
||||
double d, dot;
|
||||
double dot;
|
||||
#ifdef USE_PQ_OPT1
|
||||
int d_fxp;
|
||||
#else
|
||||
double d;
|
||||
vec3_t acceptpt, rejectpt;
|
||||
#endif
|
||||
|
||||
if (node->contents == CONTENTS_SOLID)
|
||||
return; // solid
|
||||
|
|
@ -477,16 +491,29 @@ void R_RecursiveWorldNode (mnode_t *node, int clipflags)
|
|||
|
||||
pindex = pfrustum_indexes[i];
|
||||
|
||||
#ifdef USE_PQ_OPT1
|
||||
d_fxp=node->minmaxs[pindex[0]]*clipplanes_fxp[i][0]+node->minmaxs[pindex[1]]*clipplanes_fxp[i][1]+node->minmaxs[pindex[2]]*clipplanes_fxp[i][2];
|
||||
d_fxp-=clipdist_fxp[i];
|
||||
|
||||
if (d_fxp <= 0)
|
||||
return;
|
||||
|
||||
d_fxp=node->minmaxs[pindex[3]]*clipplanes_fxp[i][0]+node->minmaxs[pindex[4]]*clipplanes_fxp[i][1]+node->minmaxs[pindex[5]]*clipplanes_fxp[i][2];
|
||||
d_fxp-=clipdist_fxp[i];
|
||||
|
||||
if (d_fxp >= 0)
|
||||
clipflags &= ~(1<<i); // node is entirely on screen
|
||||
#else
|
||||
rejectpt[0] = (float)node->minmaxs[pindex[0]];
|
||||
rejectpt[1] = (float)node->minmaxs[pindex[1]];
|
||||
rejectpt[2] = (float)node->minmaxs[pindex[2]];
|
||||
|
||||
|
||||
d = DotProduct (rejectpt, view_clipplanes[i].normal);
|
||||
d -= view_clipplanes[i].dist;
|
||||
|
||||
if (d <= 0)
|
||||
if (d <= 0)
|
||||
return;
|
||||
|
||||
|
||||
acceptpt[0] = (float)node->minmaxs[pindex[3+0]];
|
||||
acceptpt[1] = (float)node->minmaxs[pindex[3+1]];
|
||||
acceptpt[2] = (float)node->minmaxs[pindex[3+2]];
|
||||
|
|
@ -496,6 +523,7 @@ void R_RecursiveWorldNode (mnode_t *node, int clipflags)
|
|||
|
||||
if (d >= 0)
|
||||
clipflags &= ~(1<<i); // node is entirely on screen
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -656,10 +684,79 @@ void R_RenderWorld (void)
|
|||
|
||||
currententity = &cl_entities[0];
|
||||
VectorCopy (r_origin, modelorg);
|
||||
|
||||
#ifdef USE_PQ_OPT1
|
||||
modelorg_fxp[0]=(int)(r_origin[0]*524288.0);
|
||||
modelorg_fxp[1]=(int)(r_origin[1]*524288.0);
|
||||
modelorg_fxp[2]=(int)(r_origin[2]*524288.0);
|
||||
|
||||
//modelorg_fxp[0]=(int)(r_origin[0]*65536.0);
|
||||
//modelorg_fxp[1]=(int)(r_origin[1]*65536.0);
|
||||
//modelorg_fxp[2]=(int)(r_origin[2]*65536.0);
|
||||
|
||||
vright_fxp[0]=(int)(256.0/vright[0]);
|
||||
if (!vright_fxp[0]) vright_fxp[0]=0x7fffffff;
|
||||
vright_fxp[1]=(int)(256.0/vright[1]);
|
||||
if (!vright_fxp[1]) vright_fxp[1]=0x7fffffff;
|
||||
vright_fxp[2]=(int)(256.0/vright[2]);
|
||||
if (!vright_fxp[2]) vright_fxp[2]=0x7fffffff;
|
||||
|
||||
vpn_fxp[0]=(int)(256.0/vpn[0]);
|
||||
if (!vpn_fxp[0]) vpn_fxp[0]=0x7fffffff;
|
||||
vpn_fxp[1]=(int)(256.0/vpn[1]);
|
||||
if (!vpn_fxp[1]) vpn_fxp[1]=0x7fffffff;
|
||||
vpn_fxp[2]=(int)(256.0/vpn[2]);
|
||||
if (!vpn_fxp[2]) vpn_fxp[2]=0x7fffffff;
|
||||
|
||||
vup_fxp[0]=(int)(256.0/vup[0]);
|
||||
if (!vup_fxp[0]) vup_fxp[0]=0x7fffffff;
|
||||
vup_fxp[1]=(int)(256.0/vup[1]);
|
||||
if (!vup_fxp[1]) vup_fxp[1]=0x7fffffff;
|
||||
vup_fxp[2]=(int)(256.0/vup[2]);
|
||||
if (!vup_fxp[2]) vup_fxp[2]=0x7fffffff;
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
clmodel = currententity->model;
|
||||
r_pcurrentvertbase = clmodel->vertexes;
|
||||
|
||||
R_RecursiveWorldNode (clmodel->nodes, 15);
|
||||
#ifdef USE_PQ_OPT2
|
||||
r_pcurrentvertbase_fxp = clmodel->vertexes_fxp;
|
||||
#endif
|
||||
#ifdef USE_PQ_OPT1
|
||||
//Dan Fixed point conversion stuff
|
||||
for (i=0; i<4; i++) {
|
||||
clipplanes_fxp[i][0]=(int)(view_clipplanes[i].normal[0]*65536.0);
|
||||
clipplanes_fxp[i][1]=(int)(view_clipplanes[i].normal[1]*65536.0);
|
||||
clipplanes_fxp[i][2]=(int)(view_clipplanes[i].normal[2]*65536.0);
|
||||
clipdist_fxp[i] =(int)(view_clipplanes[i].dist*65536.0);
|
||||
#ifdef USE_PQ_OPT2
|
||||
view_clipplanes_fxp[i].leftedge=view_clipplanes[i].leftedge;
|
||||
view_clipplanes_fxp[i].rightedge=view_clipplanes[i].rightedge;
|
||||
if (!view_clipplanes[i].normal[0]) view_clipplanes_fxp[i].normal[0]=2<<29;
|
||||
else view_clipplanes_fxp[i].normal[0]=(int)(4096.0f/view_clipplanes[i].normal[0]);
|
||||
if (!view_clipplanes[i].normal[0]) view_clipplanes_fxp[i].normal[0]=2<<29;
|
||||
|
||||
if (!view_clipplanes[i].normal[1]) view_clipplanes_fxp[i].normal[1]=2<<29;
|
||||
else view_clipplanes_fxp[i].normal[1]=(int)(4096.0f/view_clipplanes[i].normal[1]);
|
||||
if (!view_clipplanes[i].normal[1]) view_clipplanes_fxp[i].normal[1]=2<<29;
|
||||
|
||||
if (!view_clipplanes[i].normal[2]) view_clipplanes_fxp[i].normal[2]=2<<29;
|
||||
else view_clipplanes_fxp[i].normal[2]=(int)(4096.0f/view_clipplanes[i].normal[2]);
|
||||
if (!view_clipplanes[i].normal[2]) view_clipplanes_fxp[i].normal[2]=2<<29;
|
||||
|
||||
view_clipplanes_fxp[i].dist=(int)(view_clipplanes[i].dist*128.0f);
|
||||
#endif
|
||||
#if defined(_X86_)&&defined(DEBUG)
|
||||
LogFloat(view_clipplanes[i].normal[0], "view_clipplanes[i].normal[0]", i, -1);
|
||||
LogFloat(view_clipplanes[i].normal[1], "view_clipplanes[i].normal[1]", i, -1);
|
||||
LogFloat(view_clipplanes[i].normal[2], "view_clipplanes[i].normal[2]", i, -1);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
R_RecursiveWorldNode (clmodel->nodes, 15);
|
||||
|
||||
// if the driver wants the polygons back to front, play the visible ones back
|
||||
// in that order
|
||||
|
|
|
|||
|
|
@ -44,6 +44,10 @@ clipplane_t *entity_clipplanes;
|
|||
clipplane_t view_clipplanes[4];
|
||||
clipplane_t world_clipplanes[16];
|
||||
|
||||
#ifdef USE_PQ_OPT2
|
||||
clipplane_fxp_t view_clipplanes_fxp[4];
|
||||
#endif
|
||||
|
||||
medge_t *r_pedge;
|
||||
|
||||
qboolean r_leftclipped, r_rightclipped;
|
||||
|
|
@ -67,6 +71,11 @@ float r_nearzi;
|
|||
float r_u1, r_v1, r_lzi1;
|
||||
int r_ceilv1;
|
||||
|
||||
#ifdef USE_PQ_OPT1
|
||||
int r_u1_fxp, r_v1_fxp, r_lzi1_fxp;
|
||||
extern int modelorg_fxp[3];
|
||||
#endif
|
||||
|
||||
qboolean r_lastvertvalid;
|
||||
|
||||
|
||||
|
|
@ -250,6 +259,306 @@ void R_EmitEdge (mvertex_t *pv0, mvertex_t *pv1)
|
|||
removeedges[v2] = edge;
|
||||
}
|
||||
|
||||
#ifdef USE_PQ_OPT1
|
||||
void R_EmitEdge_fxp (mvertex_t *pv0, mvertex_t *pv1)
|
||||
{
|
||||
edge_t *edge, *pcheck;
|
||||
int u_check;
|
||||
//float u, u_step;
|
||||
int u_fxp, u_step_fxp;
|
||||
//vec3_t local, transformed;
|
||||
int local_fxp[3], transformed_fxp[3];
|
||||
float *world;
|
||||
int v, v2, ceilv0;
|
||||
//float scale, lzi0, u0, v0;
|
||||
int scale_fxp, scale2_fxp, lzi0_fxp, u0_fxp, v0_fxp;
|
||||
int side;
|
||||
|
||||
if (r_lastvertvalid)
|
||||
{
|
||||
u0_fxp = r_u1_fxp;
|
||||
v0_fxp = r_v1_fxp;
|
||||
lzi0_fxp = r_lzi1_fxp;
|
||||
//lzi0 = r_lzi1;
|
||||
ceilv0 = r_ceilv1;
|
||||
}
|
||||
else
|
||||
{
|
||||
//world_fxp=(int)(pv0->position[0]*(float)(2^16));
|
||||
world = &pv0->position[0];
|
||||
|
||||
// transform and project
|
||||
//VectorSubtract (world, modelorg, local);
|
||||
//Vector Subtract (and convert)
|
||||
local_fxp[0]=((int)(world[0]*(524288.0)))-modelorg_fxp[0];
|
||||
local_fxp[1]=((int)(world[1]*(524288.0)))-modelorg_fxp[1];
|
||||
local_fxp[2]=((int)(world[2]*(524288.0)))-modelorg_fxp[2];
|
||||
|
||||
//TransformVector (local, transformed);
|
||||
//transformed_fxp[0] = (int)(local_fxp[0]*vright[0])+(int)(local_fxp[1]*vright[1])+(int)(local_fxp[2]*vright[2]);
|
||||
//transformed_fxp[1] = (int)(local_fxp[0]*vup[0])+(int)(local_fxp[1]*vup[1])+(int)(local_fxp[2]*vup[2]);
|
||||
//transformed_fxp[2] = (int)(local_fxp[0]*vpn[0])+(int)(local_fxp[1]*vpn[1])+(int)(local_fxp[2]*vpn[2]);
|
||||
|
||||
transformed_fxp[0] = local_fxp[0]/vright_fxp[0]+local_fxp[1]/vright_fxp[1]+local_fxp[2]/vright_fxp[2];
|
||||
//transformed_fxp[0]*=256;
|
||||
transformed_fxp[1] = local_fxp[0]/vup_fxp[0]+local_fxp[1]/vup_fxp[1]+local_fxp[2]/vup_fxp[2];
|
||||
//transformed_fxp[1]*=256;
|
||||
transformed_fxp[2] = local_fxp[0]/vpn_fxp[0]+local_fxp[1]/vpn_fxp[1]+local_fxp[2]/vpn_fxp[2];
|
||||
transformed_fxp[2]*=256;
|
||||
|
||||
if (transformed_fxp[2] < (int)(NEAR_CLIP*1048576.0))
|
||||
transformed_fxp[2] = (int)(NEAR_CLIP*1048576.0);
|
||||
|
||||
transformed_fxp[0]/=16;
|
||||
transformed_fxp[1]/=16;
|
||||
transformed_fxp[2]/=2048;
|
||||
|
||||
lzi0_fxp=transformed_fxp[2];
|
||||
//lzi0 = (float)(1.0 / transformed[2]);
|
||||
|
||||
// FIXME: build x/yscale into transform?
|
||||
//scale = xscale * lzi0;
|
||||
//u0 = (xcenter + scale*transformed[0]);
|
||||
|
||||
scale_fxp=xscale_fxp/transformed_fxp[2]; //9.23 / 24.8 = 17.15
|
||||
scale2_fxp=transformed_fxp[0]*(scale_fxp); // 25.7 * 17.15 = 10.22
|
||||
|
||||
if (transformed_fxp[0]<0) {
|
||||
if (scale2_fxp>0) scale2_fxp=-511*4194304;
|
||||
} else {
|
||||
if (scale2_fxp<0) scale2_fxp=511*4194304;
|
||||
}
|
||||
|
||||
u0_fxp=scale2_fxp+xcenter_fxp;
|
||||
|
||||
if (u0_fxp < r_refdef_fvrectx_adj_fxp)
|
||||
u0_fxp = r_refdef_fvrectx_adj_fxp;
|
||||
if (u0_fxp > r_refdef_fvrectright_adj_fxp)
|
||||
u0_fxp = r_refdef_fvrectright_adj_fxp;
|
||||
|
||||
//scale = yscale * lzi0;
|
||||
//v0 = (ycenter - scale*transformed[1]);
|
||||
scale_fxp=yscale_fxp/transformed_fxp[2]; //9.23 / 24.8 = 17.15
|
||||
scale2_fxp=transformed_fxp[1]*(scale_fxp); // 25.7 * 17.15 = 10.22
|
||||
|
||||
if (transformed_fxp[1]<0) {
|
||||
if (scale2_fxp>0) scale2_fxp=-511*4194304;
|
||||
} else {
|
||||
if (scale2_fxp<0) scale2_fxp=511*4194304; //255*8388608;
|
||||
}
|
||||
|
||||
v0_fxp = ycenter_fxp-scale2_fxp;
|
||||
|
||||
if (v0_fxp < r_refdef_fvrecty_adj_fxp)
|
||||
v0_fxp = r_refdef_fvrecty_adj_fxp;
|
||||
if (v0_fxp > r_refdef_fvrectbottom_adj_fxp)
|
||||
v0_fxp = r_refdef_fvrectbottom_adj_fxp;
|
||||
|
||||
ceilv0 = v0_fxp/4194304;
|
||||
if (v0_fxp&0x3FFFFF) ceilv0++;
|
||||
}
|
||||
|
||||
//world(pv1->position[0]*(float)(2^16));
|
||||
world = &pv1->position[0];
|
||||
|
||||
// transform and project
|
||||
//VectorSubtract (world, modelorg, local);
|
||||
//Vector Subtract (and convert)
|
||||
local_fxp[0]=((int)(world[0]*(524288.0)))-modelorg_fxp[0];
|
||||
local_fxp[1]=((int)(world[1]*(524288.0)))-modelorg_fxp[1];
|
||||
local_fxp[2]=((int)(world[2]*(524288.0)))-modelorg_fxp[2];
|
||||
|
||||
//TransformVector (local, transformed);
|
||||
//transformed_fxp[0] = ((int)(local_fxp[0]*vright[0]))+((int)(local_fxp[1]*vright[1]))+((int)(local_fxp[2]*vright[2]));
|
||||
//transformed_fxp[1] = ((int)(local_fxp[0]*vup[0]))+((int)(local_fxp[1]*vup[1]))+((int)(local_fxp[2]*vup[2]));
|
||||
//transformed_fxp[2] = ((int)(local_fxp[0]*vpn[0]))+((int)(local_fxp[1]*vpn[1]))+((int)(local_fxp[2]*vpn[2]));
|
||||
|
||||
transformed_fxp[0] = local_fxp[0]/vright_fxp[0]+local_fxp[1]/vright_fxp[1]+local_fxp[2]/vright_fxp[2];
|
||||
//transformed_fxp[0]*=256;
|
||||
transformed_fxp[1] = local_fxp[0]/vup_fxp[0]+local_fxp[1]/vup_fxp[1]+local_fxp[2]/vup_fxp[2];
|
||||
//transformed_fxp[1]*=256;
|
||||
transformed_fxp[2] = local_fxp[0]/vpn_fxp[0]+local_fxp[1]/vpn_fxp[1]+local_fxp[2]/vpn_fxp[2];
|
||||
transformed_fxp[2]*=256;
|
||||
|
||||
//transformed_fxp[2]=-transformed_fxp[2];
|
||||
//if (transformed[2] < NEAR_CLIP)
|
||||
// transformed[2] = (float)NEAR_CLIP;
|
||||
if (transformed_fxp[2] < (int)(NEAR_CLIP*524288.0))
|
||||
transformed_fxp[2] = (int)(NEAR_CLIP*524288.0);
|
||||
|
||||
transformed_fxp[0]/=16;
|
||||
transformed_fxp[1]/=16;
|
||||
transformed_fxp[2]/=2048;
|
||||
|
||||
r_lzi1_fxp=transformed_fxp[2];
|
||||
//r_lzi1 = (float)(1.0 / transformed[2]);
|
||||
//scale = xscale * r_lzi1;
|
||||
|
||||
scale_fxp=xscale_fxp/transformed_fxp[2]; //9.23 / 24.8 = 17.15
|
||||
scale2_fxp=transformed_fxp[0]*(scale_fxp); // 24.8 * 17.15 = 9.23 //21.11
|
||||
|
||||
if (transformed_fxp[0]<0) {
|
||||
if (scale2_fxp>0) scale2_fxp=-511*4194304;
|
||||
} else {
|
||||
if (scale2_fxp<0) scale2_fxp=511*4194304;
|
||||
}
|
||||
|
||||
//r_u1 = (xcenter + scale*transformed[0]);
|
||||
r_u1_fxp = xcenter_fxp + scale2_fxp;
|
||||
if (r_u1_fxp < r_refdef_fvrectx_adj_fxp)
|
||||
r_u1_fxp = r_refdef_fvrectx_adj_fxp;
|
||||
if (r_u1_fxp > r_refdef_fvrectright_adj_fxp)
|
||||
r_u1_fxp = r_refdef_fvrectright_adj_fxp;
|
||||
|
||||
//scale = yscale * r_lzi1;
|
||||
//r_v1 = (ycenter - scale*transformed[1]);
|
||||
|
||||
scale_fxp=yscale_fxp/transformed_fxp[2]; //9.23 / 24.8 = 17.15
|
||||
scale2_fxp=transformed_fxp[1]*(scale_fxp); // 23.9 * 17.15 = 9.23 //21.11
|
||||
|
||||
if (transformed_fxp[1]<0) {
|
||||
if (scale2_fxp>0) scale2_fxp=-511*4194304;
|
||||
} else {
|
||||
if (scale2_fxp<0) scale2_fxp=511*4194304;
|
||||
}
|
||||
|
||||
r_v1_fxp = ycenter_fxp - scale2_fxp;
|
||||
if (r_v1_fxp < r_refdef_fvrecty_adj_fxp)
|
||||
r_v1_fxp = r_refdef_fvrecty_adj_fxp;
|
||||
if (r_v1_fxp > r_refdef_fvrectbottom_adj_fxp)
|
||||
r_v1_fxp = r_refdef_fvrectbottom_adj_fxp;
|
||||
|
||||
//if (r_lzi1 > lzi0)
|
||||
// lzi0 = r_lzi1;
|
||||
if (r_lzi1_fxp < lzi0_fxp)
|
||||
lzi0_fxp = r_lzi1_fxp;
|
||||
|
||||
//if (lzi0 > r_nearzi) // for mipmap finding
|
||||
// r_nearzi = lzi0;
|
||||
if (128.0/lzi0_fxp > r_nearzi) { // for mipmap finding
|
||||
//if (!lzi0_fxp) r_nearzi=0;
|
||||
//else
|
||||
r_nearzi = (float)(128.0/lzi0_fxp);
|
||||
}
|
||||
|
||||
// for right edges, all we want is the effect on 1/z
|
||||
if (r_nearzionly)
|
||||
return;
|
||||
|
||||
r_emitted = 1;
|
||||
|
||||
//r_ceilv1 = (int) ceil(r_v1);
|
||||
r_ceilv1 = r_v1_fxp/4194304;
|
||||
if (r_v1_fxp&0x3FFFFF) r_ceilv1++;
|
||||
|
||||
|
||||
// create the edge
|
||||
if (ceilv0 == r_ceilv1)
|
||||
{
|
||||
// we cache unclipped horizontal edges as fully clipped
|
||||
if (cacheoffset != 0x7FFFFFFF)
|
||||
{
|
||||
cacheoffset = FULLY_CLIPPED_CACHED |
|
||||
(r_framecount & FRAMECOUNT_MASK);
|
||||
}
|
||||
|
||||
return; // horizontal edge
|
||||
}
|
||||
|
||||
side = ceilv0 > r_ceilv1;
|
||||
|
||||
edge = edge_p++;
|
||||
|
||||
edge->owner = NULL;
|
||||
|
||||
edge->owner = r_pedge;
|
||||
|
||||
edge->nearzi = (float)(128.0/lzi0_fxp);
|
||||
|
||||
{
|
||||
//float tmp;
|
||||
if (side == 0)
|
||||
{
|
||||
//int tmp;
|
||||
// trailing edge (go from p1 to p2)
|
||||
v = ceilv0;
|
||||
v2 = r_ceilv1 - 1;
|
||||
|
||||
edge->surfs[0] = surface_p - surfaces;
|
||||
edge->surfs[1] = 0;
|
||||
|
||||
//u_step = ((r_u1 - u0) / (r_v1 - v0));
|
||||
//u = u0 + ((float)v - v0) * u_step;
|
||||
|
||||
u_step_fxp=(r_u1_fxp - u0_fxp) / ((r_v1_fxp - v0_fxp)>>10); //10.22 / 15.12 = 22.10
|
||||
u_fxp = u0_fxp + ((v*4194304 - v0_fxp)>>12 * u_step_fxp>>12);
|
||||
|
||||
//tmp=(((r_u1_fxp - u0_fxp)/8388608.0) / ((r_v1_fxp - v0_fxp)/8388608.0));
|
||||
//u_step_fxp=(int)(tmp*8388608.0);
|
||||
//u_fxp = u0_fxp + (((float)v - v0_fxp/8388608.0) * tmp)*8388608.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
//int tmp;
|
||||
// leading edge (go from p2 to p1)
|
||||
v2 = ceilv0 - 1;
|
||||
v = r_ceilv1;
|
||||
|
||||
edge->surfs[0] = 0;
|
||||
edge->surfs[1] = surface_p - surfaces;
|
||||
|
||||
//u_step = ((u0 - r_u1) / (v0 - r_v1));
|
||||
//u = r_u1 + ((float)v - r_v1) * u_step;
|
||||
|
||||
u_step_fxp = (u0_fxp - r_u1_fxp) / ((v0_fxp - r_v1_fxp)>>10);
|
||||
u_fxp = r_u1_fxp + ((v*4194304 - r_v1_fxp)>>12 * u_step_fxp>>12);
|
||||
|
||||
//tmp=(((u0_fxp - r_u1_fxp)/8388608.0) / ((v0_fxp - r_v1_fxp)/8388608.0));
|
||||
//u_step_fxp = (int)(tmp*8388608.0);
|
||||
//u_fxp = r_u1_fxp + (((float)v - r_v1_fxp/8388608.0) * tmp)*8388608.0;
|
||||
}
|
||||
//edge->u_step = tmp*0x100000;
|
||||
//edge->u = (int)(/*(u_fxp/65536)*0x100000*/u_fxp/4 + 0xFFFFF);
|
||||
|
||||
edge->u_step = u_step_fxp*1024;///16; //tmp*0x100000;
|
||||
edge->u = (int)(/*(u_fxp/65536)*0x100000*/u_fxp/4 + 0xFFFFF);
|
||||
}
|
||||
|
||||
// we need to do this to avoid stepping off the edges if a very nearly
|
||||
// horizontal edge is less than epsilon above a scan, and numeric error causes
|
||||
// it to incorrectly extend to the scan, and the extension of the line goes off
|
||||
// the edge of the screen
|
||||
// FIXME: is this actually needed?
|
||||
if (edge->u < r_refdef.vrect_x_adj_shift20)
|
||||
edge->u = r_refdef.vrect_x_adj_shift20;
|
||||
if (edge->u > r_refdef.vrectright_adj_shift20)
|
||||
edge->u = r_refdef.vrectright_adj_shift20;
|
||||
|
||||
//
|
||||
// sort the edge in normally
|
||||
//
|
||||
u_check = edge->u;
|
||||
if (edge->surfs[0])
|
||||
u_check++; // sort trailers after leaders
|
||||
|
||||
if (!newedges[v] || newedges[v]->u >= u_check)
|
||||
{
|
||||
edge->next = newedges[v];
|
||||
newedges[v] = edge;
|
||||
}
|
||||
else
|
||||
{
|
||||
pcheck = newedges[v];
|
||||
while (pcheck->next && pcheck->next->u < u_check)
|
||||
pcheck = pcheck->next;
|
||||
edge->next = pcheck->next;
|
||||
pcheck->next = edge;
|
||||
}
|
||||
|
||||
edge->nextremove = removeedges[v2];
|
||||
removeedges[v2] = edge;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
================
|
||||
|
|
@ -349,7 +658,11 @@ static inline void R_ClipEdge (mvertex_t *pv0, mvertex_t *pv1, clipplane_t *clip
|
|||
}
|
||||
|
||||
// add the edge
|
||||
#ifndef USE_PQ_OPT1
|
||||
R_EmitEdge (pv0, pv1);
|
||||
#else
|
||||
R_EmitEdge_fxp (pv0, pv1);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // !id386
|
||||
|
|
|
|||
|
|
@ -96,6 +96,11 @@ typedef struct clipplane_s
|
|||
|
||||
extern clipplane_t view_clipplanes[4];
|
||||
|
||||
#ifdef USE_PQ_OPT2
|
||||
extern clipplane_fxp_t view_clipplanes_fxp[4];
|
||||
#endif
|
||||
|
||||
|
||||
//=============================================================================
|
||||
|
||||
void R_RenderWorld (void);
|
||||
|
|
@ -277,6 +282,10 @@ extern int r_outofsurfaces;
|
|||
extern int r_outofedges;
|
||||
|
||||
extern mvertex_t *r_pcurrentvertbase;
|
||||
extern mvertex_FPM_t *r_pcurrentvertbaseFPM;
|
||||
#ifdef USE_PQ_OPT2
|
||||
extern mvertex_fxp_t *r_pcurrentvertbase_fxp;
|
||||
#endif
|
||||
extern int r_maxvalidedgeoffset;
|
||||
|
||||
void R_AliasClipTriangle (mtriangle_t *ptri);
|
||||
|
|
|
|||
|
|
@ -62,6 +62,18 @@ vec3_t vup, base_vup;
|
|||
vec3_t vpn, base_vpn;
|
||||
vec3_t vright, base_vright;
|
||||
vec3_t r_origin;
|
||||
#ifdef USE_PQ_OPT1
|
||||
int vup_fxp[3];
|
||||
int vpn_fxp[3];
|
||||
int vright_fxp[3];
|
||||
int xscale_fxp, yscale_fxp;
|
||||
int xcenter_fxp, ycenter_fxp;
|
||||
int r_refdef_fvrectx_adj_fxp;
|
||||
int r_refdef_fvrectright_adj_fxp;
|
||||
int r_refdef_fvrecty_adj_fxp;
|
||||
int r_refdef_fvrectbottom_adj_fxp;
|
||||
extern int modelorg_fxp[3];
|
||||
#endif
|
||||
|
||||
//
|
||||
// screen size info
|
||||
|
|
@ -421,6 +433,17 @@ void R_ViewChanged (vrect_t *pvrect, int lineadj, float aspect)
|
|||
yscaleinv = 1.0 / yscale;
|
||||
xscaleshrink = (r_refdef.vrect.width-6)/r_refdef.horizontalFieldOfView;
|
||||
yscaleshrink = xscaleshrink*pixelAspect;
|
||||
|
||||
#ifdef USE_PQ_OPT1
|
||||
xscale_fxp=(int)(xscale*8388608.0); //9.23
|
||||
yscale_fxp=(int)(yscale*8388608.0); //9.23
|
||||
xcenter_fxp=(int)(xcenter*4194304.0); //10.22
|
||||
ycenter_fxp=(int)(ycenter*4194304.0); //10.22
|
||||
r_refdef_fvrectx_adj_fxp=(int)(r_refdef.fvrectx_adj*4194304.0);
|
||||
r_refdef_fvrectright_adj_fxp=(int)(r_refdef.fvrectright_adj*4194304.0);
|
||||
r_refdef_fvrecty_adj_fxp=(int)(r_refdef.fvrecty_adj*4194304.0);
|
||||
r_refdef_fvrectbottom_adj_fxp=(int)(r_refdef.fvrectbottom_adj*4194304.0);
|
||||
#endif
|
||||
|
||||
// left side clip
|
||||
screenedge[0].normal[0] = -1.0 / (xOrigin*r_refdef.horizontalFieldOfView);
|
||||
|
|
@ -789,6 +812,33 @@ void R_DrawBEntitiesOnList (void)
|
|||
// FIXME: stop transforming twice
|
||||
R_RotateBmodel ();
|
||||
|
||||
#ifdef USE_PQ_OPT1
|
||||
modelorg_fxp[0]=(int)(modelorg[0]*524288.0);
|
||||
modelorg_fxp[1]=(int)(modelorg[1]*524288.0);
|
||||
modelorg_fxp[2]=(int)(modelorg[2]*524288.0);
|
||||
|
||||
vright_fxp[0]=(int)(256.0/vright[0]);
|
||||
if (!vright_fxp[0]) vright_fxp[0]=0x7fffffff;
|
||||
vright_fxp[1]=(int)(256.0/vright[1]);
|
||||
if (!vright_fxp[1]) vright_fxp[1]=0x7fffffff;
|
||||
vright_fxp[2]=(int)(256.0/vright[2]);
|
||||
if (!vright_fxp[2]) vright_fxp[2]=0x7fffffff;
|
||||
|
||||
vpn_fxp[0]=(int)(256.0/vpn[0]);
|
||||
if (!vpn_fxp[0]) vpn_fxp[0]=0x7fffffff;
|
||||
vpn_fxp[1]=(int)(256.0/vpn[1]);
|
||||
if (!vpn_fxp[1]) vpn_fxp[1]=0x7fffffff;
|
||||
vpn_fxp[2]=(int)(256.0/vpn[2]);
|
||||
if (!vpn_fxp[2]) vpn_fxp[2]=0x7fffffff;
|
||||
|
||||
vup_fxp[0]=(int)(256.0/vup[0]);
|
||||
if (!vup_fxp[0]) vup_fxp[0]=0x7fffffff;
|
||||
vup_fxp[1]=(int)(256.0/vup[1]);
|
||||
if (!vup_fxp[1]) vup_fxp[1]=0x7fffffff;
|
||||
vup_fxp[2]=(int)(256.0/vup[2]);
|
||||
if (!vup_fxp[2]) vup_fxp[2]=0x7fffffff;
|
||||
#endif
|
||||
|
||||
// calculate dynamic lighting for bmodel if it's not an
|
||||
// instanced model
|
||||
if (clmodel->firstmodelsurface != 0)
|
||||
|
|
|
|||
|
|
@ -110,6 +110,15 @@ extern int reinit_surfcache;
|
|||
extern refdef_t r_refdef;
|
||||
extern vec3_t r_origin, vpn, vright, vup;
|
||||
|
||||
#ifdef USE_PQ_OPT1
|
||||
extern int vpn_fxp[3], vright_fxp[3], vup_fxp[3];
|
||||
extern int xscale_fxp, yscale_fxp, xcenter_fxp, ycenter_fxp;
|
||||
extern int r_refdef_fvrectx_adj_fxp;
|
||||
extern int r_refdef_fvrectright_adj_fxp;
|
||||
extern int r_refdef_fvrecty_adj_fxp;
|
||||
extern int r_refdef_fvrectbottom_adj_fxp;
|
||||
#endif
|
||||
|
||||
extern struct texture_s *r_notexture_mip;
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue