2029 lines
51 KiB
C
2029 lines
51 KiB
C
/*
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
// r_main.c
|
|
|
|
#include "quakedef.h"
|
|
#include "r_local.h"
|
|
|
|
//#define PASSAGES
|
|
|
|
void *colormap;
|
|
vec3_t viewlightvec;
|
|
alight_t r_viewlighting = {128, 192, viewlightvec};
|
|
|
|
float r_time1;
|
|
int r_numallocatededges;
|
|
qboolean r_drawpolys;
|
|
qboolean r_drawculledpolys;
|
|
qboolean r_worldpolysbacktofront;
|
|
qboolean r_recursiveaffinetriangles = true;
|
|
int r_pixbytes = 1;
|
|
float r_aliasuvscale = 1.0;
|
|
int r_outofsurfaces;
|
|
int r_outofedges;
|
|
|
|
qboolean r_dowarp, r_dowarpold, r_viewchanged;
|
|
|
|
int numbtofpolys;
|
|
btofpoly_t *pbtofpolys;
|
|
mvertex_t *r_pcurrentvertbase;
|
|
#ifdef USE_PQ_OPT2
|
|
mvertex_fxp_t *r_pcurrentvertbase_fxp;
|
|
#endif
|
|
|
|
int c_surf;
|
|
int r_maxsurfsseen, r_maxedgesseen, r_cnumsurfs;
|
|
qboolean r_surfsonstack;
|
|
int r_clipflags;
|
|
|
|
byte *r_warpbuffer;
|
|
|
|
byte *r_stack_start;
|
|
|
|
qboolean r_fov_greater_than_90;
|
|
|
|
//
|
|
// view origin
|
|
//
|
|
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
|
|
//
|
|
refdef_t r_refdef;
|
|
float xcenter, ycenter;
|
|
float xscale, yscale;
|
|
float xscaleinv, yscaleinv;
|
|
float xscaleshrink, yscaleshrink;
|
|
float aliasxscale, aliasyscale, aliasxcenter, aliasycenter;
|
|
fixedpoint_t aliasxscaleFPM, aliasyscaleFPM, aliasxcenterFPM, aliasycenterFPM;
|
|
int screenwidth;
|
|
#ifdef USE_PQ_OPT3
|
|
int xscaleinv_fxp, yscaleinv_fxp;
|
|
int xcenter_fxp, ycenter_fxp;
|
|
#endif
|
|
|
|
float pixelAspect;
|
|
float screenAspect;
|
|
float verticalFieldOfView;
|
|
float xOrigin, yOrigin;
|
|
|
|
mplane_t screenedge[4];
|
|
|
|
//
|
|
// refresh flags
|
|
//
|
|
int r_framecount = 1; // so frame counts initialized to 0 don't match
|
|
int r_visframecount;
|
|
int d_spanpixcount;
|
|
int r_polycount;
|
|
int r_drawnpolycount;
|
|
int r_wholepolycount;
|
|
|
|
#define VIEWMODNAME_LENGTH 256
|
|
char viewmodname[VIEWMODNAME_LENGTH+1];
|
|
int modcount;
|
|
|
|
int *pfrustum_indexes[4];
|
|
int r_frustum_indexes[4*6];
|
|
|
|
int reinit_surfcache = 1; // if 1, surface cache is currently empty and
|
|
// must be reinitialized for current cache size
|
|
|
|
mleaf_t *r_viewleaf, *r_oldviewleaf;
|
|
|
|
texture_t *r_notexture_mip;
|
|
|
|
float r_aliastransition, r_resfudge;
|
|
|
|
|
|
#ifdef USEFPM
|
|
mleaf_FPM_t *r_viewleafFPM, *r_oldviewleafFPM;
|
|
mplane_FPM_t screenedgeFPM[4];
|
|
fixedpoint_t pixelAspectFPM;
|
|
fixedpoint_t screenAspectFPM;
|
|
fixedpoint_t verticalFieldOfViewFPM;
|
|
fixedpoint_t xOriginFPM, yOriginFPM;
|
|
fixedpoint_t aliasxscaleFPM, aliasyscaleFPM, aliasxcenterFPM, aliasycenterFPM;
|
|
fixedpoint_t r_aliastransitionFPM, r_resfudgeFPM;
|
|
fixedpoint_t aliasxscaleFPM, aliasyscaleFPM, aliasxcenterFPM, aliasycenterFPM;
|
|
fixedpoint_t xscaleshrinkFPM, yscaleshrinkFPM;
|
|
fixedpoint_t xscaleinvFPM, yscaleinvFPM;
|
|
fixedpoint_t xscaleFPM, yscaleFPM;
|
|
fixedpoint_t xcenterFPM, ycenterFPM;
|
|
refdef_FPM_t r_refdefFPM;
|
|
vec3_FPM_t vupFPM, base_vupFPM;
|
|
vec3_FPM_t vpnFPM, base_vpnFPM;
|
|
vec3_FPM_t vrightFPM, base_vrightFPM;
|
|
vec3_FPM_t r_originFPM;
|
|
mvertex_FPM_t *r_pcurrentvertbaseFPM;
|
|
btofpoly_FPM_t *pbtofpolysFPM;
|
|
fixedpoint_t r_aliasuvscaleFPM = FPM_FROMFLOATC(1.0);
|
|
vec3_FPM_t viewlightvecFPM;
|
|
alight_FPM_t r_viewlightingFPM = {FPM_FROMLONGC(128), FPM_FROMLONGC(192), viewlightvecFPM};
|
|
#endif //USEFPM
|
|
|
|
int d_lightstylevalue[256]; // 8.8 fraction of base light value
|
|
|
|
float dp_time1, dp_time2, db_time1, db_time2, rw_time1, rw_time2;
|
|
float se_time1, se_time2, de_time1, de_time2, dv_time1, dv_time2;
|
|
|
|
void R_MarkLeaves (void);
|
|
|
|
cvar_t r_draworder = {"r_draworder","0"};
|
|
cvar_t r_speeds = {"r_speeds","0"};
|
|
cvar_t r_timegraph = {"r_timegraph","0"};
|
|
cvar_t r_graphheight = {"r_graphheight","10"};
|
|
cvar_t r_clearcolor = {"r_clearcolor","2"};
|
|
cvar_t r_skycolor = {"r_skycolor", "4"};
|
|
cvar_t r_fastsky = {"r_fastsky", "0"};
|
|
cvar_t r_waterwarp = {"r_waterwarp", "0"};
|
|
cvar_t r_fullbright = {"r_fullbright","0"};
|
|
cvar_t r_drawentities = {"r_drawentities","1"};
|
|
cvar_t r_drawviewmodel = {"r_drawviewmodel","1"};
|
|
cvar_t r_aliasstats = {"r_polymodelstats","0"};
|
|
cvar_t r_dspeeds = {"r_dspeeds","0"};
|
|
cvar_t r_drawflat = {"r_drawflat", "0"};
|
|
cvar_t r_ambient = {"r_ambient", "0"};
|
|
cvar_t r_reportsurfout = {"r_reportsurfout", "0"};
|
|
cvar_t r_maxsurfs = {"r_maxsurfs", "0"};
|
|
cvar_t r_numsurfs = {"r_numsurfs", "0"};
|
|
cvar_t r_reportedgeout = {"r_reportedgeout", "0"};
|
|
cvar_t r_maxedges = {"r_maxedges", "0"};
|
|
cvar_t r_numedges = {"r_numedges", "0"};
|
|
cvar_t r_aliastransbase = {"r_aliastransbase", "200"};
|
|
cvar_t r_aliastransadj = {"r_aliastransadj", "100"};
|
|
cvar_t r_fastturb = {"r_fastturb", "0"};
|
|
|
|
//Dan East: Added:
|
|
cvar_t r_maxparticles = {"r_maxparticles","512"};
|
|
|
|
extern cvar_t scr_fov;
|
|
|
|
void CreatePassages (void);
|
|
void SetVisibilityByPassages (void);
|
|
|
|
/*
|
|
==================
|
|
R_InitTextures
|
|
==================
|
|
*/
|
|
void R_InitTextures (void)
|
|
{
|
|
int x,y, m;
|
|
byte *dest;
|
|
|
|
// create a simple checkerboard texture for the default
|
|
r_notexture_mip = Hunk_AllocName (sizeof(texture_t) + 16*16+8*8+4*4+2*2, "notexture");
|
|
|
|
r_notexture_mip->width = r_notexture_mip->height = 16;
|
|
r_notexture_mip->offsets[0] = sizeof(texture_t);
|
|
r_notexture_mip->offsets[1] = r_notexture_mip->offsets[0] + 16*16;
|
|
r_notexture_mip->offsets[2] = r_notexture_mip->offsets[1] + 8*8;
|
|
r_notexture_mip->offsets[3] = r_notexture_mip->offsets[2] + 4*4;
|
|
|
|
for (m=0 ; m<4 ; m++)
|
|
{
|
|
dest = (byte *)r_notexture_mip + r_notexture_mip->offsets[m];
|
|
for (y=0 ; y< (16>>m) ; y++)
|
|
for (x=0 ; x< (16>>m) ; x++)
|
|
{
|
|
if ( (y< (8>>m) ) ^ (x< (8>>m) ) )
|
|
*dest++ = 0;
|
|
else
|
|
*dest++ = 0xff;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
R_Init
|
|
===============
|
|
*/
|
|
void R_Init (void)
|
|
{
|
|
int dummy;
|
|
|
|
// get stack position so we can guess if we are going to overflow
|
|
r_stack_start = (byte *)&dummy;
|
|
|
|
R_InitTurb ();
|
|
|
|
Cmd_AddCommand ("timerefresh", R_TimeRefresh_f);
|
|
Cmd_AddCommand ("pointfile", R_ReadPointFile_f);
|
|
|
|
Cvar_RegisterVariable (&r_draworder);
|
|
Cvar_RegisterVariable (&r_speeds);
|
|
Cvar_RegisterVariable (&r_timegraph);
|
|
Cvar_RegisterVariable (&r_graphheight);
|
|
Cvar_RegisterVariable (&r_drawflat);
|
|
Cvar_RegisterVariable (&r_ambient);
|
|
Cvar_RegisterVariable (&r_clearcolor);
|
|
Cvar_RegisterVariable (&r_waterwarp);
|
|
Cvar_RegisterVariable (&r_skycolor);
|
|
Cvar_RegisterVariable (&r_fastsky);
|
|
Cvar_RegisterVariable (&r_fastturb);
|
|
Cvar_RegisterVariable (&r_fullbright);
|
|
Cvar_RegisterVariable (&r_drawentities);
|
|
Cvar_RegisterVariable (&r_drawviewmodel);
|
|
Cvar_RegisterVariable (&r_aliasstats);
|
|
Cvar_RegisterVariable (&r_dspeeds);
|
|
Cvar_RegisterVariable (&r_reportsurfout);
|
|
Cvar_RegisterVariable (&r_maxsurfs);
|
|
Cvar_RegisterVariable (&r_numsurfs);
|
|
Cvar_RegisterVariable (&r_reportedgeout);
|
|
Cvar_RegisterVariable (&r_maxedges);
|
|
Cvar_RegisterVariable (&r_numedges);
|
|
Cvar_RegisterVariable (&r_aliastransbase);
|
|
Cvar_RegisterVariable (&r_aliastransadj);
|
|
//Dan East:
|
|
Cvar_RegisterVariable (&r_maxparticles);
|
|
|
|
Cvar_SetValue ("r_maxedges", (float)NUMSTACKEDGES);
|
|
Cvar_SetValue ("r_maxsurfs", (float)NUMSTACKSURFACES);
|
|
|
|
view_clipplanes[0].leftedge = true;
|
|
view_clipplanes[1].rightedge = true;
|
|
view_clipplanes[1].leftedge = view_clipplanes[2].leftedge =
|
|
view_clipplanes[3].leftedge = false;
|
|
view_clipplanes[0].rightedge = view_clipplanes[2].rightedge =
|
|
view_clipplanes[3].rightedge = false;
|
|
|
|
r_refdef.xOrigin = XCENTERING;
|
|
r_refdef.yOrigin = YCENTERING;
|
|
|
|
R_InitParticles ();
|
|
|
|
// TODO: collect 386-specific code in one place
|
|
#if id386
|
|
Sys_MakeCodeWriteable ((long)R_EdgeCodeStart,
|
|
(long)R_EdgeCodeEnd - (long)R_EdgeCodeStart);
|
|
#endif // id386
|
|
|
|
D_Init ();
|
|
}
|
|
|
|
#ifdef USEFPM
|
|
void R_InitFPM (void)
|
|
{
|
|
int dummy;
|
|
|
|
// get stack position so we can guess if we are going to overflow
|
|
r_stack_start = (byte *)&dummy;
|
|
|
|
R_InitTurb ();
|
|
|
|
//#ifndef USEFLOAT
|
|
Cmd_AddCommand ("timerefresh", R_TimeRefresh_f);
|
|
Cmd_AddCommand ("pointfile", R_ReadPointFile_f);
|
|
|
|
Cvar_RegisterVariable (&r_draworder);
|
|
Cvar_RegisterVariable (&r_speeds);
|
|
Cvar_RegisterVariable (&r_timegraph);
|
|
Cvar_RegisterVariable (&r_graphheight);
|
|
Cvar_RegisterVariable (&r_drawflat);
|
|
Cvar_RegisterVariable (&r_ambient);
|
|
Cvar_RegisterVariable (&r_clearcolor);
|
|
Cvar_RegisterVariable (&r_waterwarp);
|
|
Cvar_RegisterVariable (&r_skycolor);
|
|
Cvar_RegisterVariable (&r_fastsky);
|
|
Cvar_RegisterVariable (&r_fastturb);
|
|
Cvar_RegisterVariable (&r_fullbright);
|
|
Cvar_RegisterVariable (&r_drawentities);
|
|
Cvar_RegisterVariable (&r_drawviewmodel);
|
|
Cvar_RegisterVariable (&r_aliasstats);
|
|
Cvar_RegisterVariable (&r_dspeeds);
|
|
Cvar_RegisterVariable (&r_reportsurfout);
|
|
Cvar_RegisterVariable (&r_maxsurfs);
|
|
Cvar_RegisterVariable (&r_numsurfs);
|
|
Cvar_RegisterVariable (&r_reportedgeout);
|
|
Cvar_RegisterVariable (&r_maxedges);
|
|
Cvar_RegisterVariable (&r_numedges);
|
|
Cvar_RegisterVariable (&r_aliastransbase);
|
|
Cvar_RegisterVariable (&r_aliastransadj);
|
|
|
|
Cvar_SetValue ("r_maxedges", (float)NUMSTACKEDGES);
|
|
Cvar_SetValue ("r_maxsurfs", (float)NUMSTACKSURFACES);
|
|
//#endif
|
|
|
|
view_clipplanesFPM[0].leftedge = true;
|
|
view_clipplanesFPM[1].rightedge = true;
|
|
view_clipplanesFPM[1].leftedge = view_clipplanesFPM[2].leftedge =
|
|
view_clipplanesFPM[3].leftedge = false;
|
|
view_clipplanesFPM[0].rightedge = view_clipplanesFPM[2].rightedge =
|
|
view_clipplanesFPM[3].rightedge = false;
|
|
|
|
r_refdefFPM.xOrigin = XCENTERINGFPM;
|
|
r_refdefFPM.yOrigin = YCENTERINGFPM;
|
|
|
|
R_InitParticlesFPM ();
|
|
|
|
// TODO: collect 386-specific code in one place
|
|
//Dan: id386 not defined for our builds
|
|
#if id386
|
|
Sys_MakeCodeWriteable ((long)R_EdgeCodeStart,
|
|
(long)R_EdgeCodeEnd - (long)R_EdgeCodeStart);
|
|
#endif // id386
|
|
|
|
D_InitFPM ();
|
|
}
|
|
#endif //USEFPM
|
|
|
|
/*
|
|
===============
|
|
R_NewMap
|
|
===============
|
|
*/
|
|
void R_NewMap (void)
|
|
{
|
|
int i;
|
|
|
|
// clear out efrags in case the level hasn't been reloaded
|
|
// FIXME: is this one short?
|
|
for (i=0 ; i<cl.worldmodel->numleafs ; i++)
|
|
cl.worldmodel->leafs[i].efrags = NULL;
|
|
|
|
r_viewleaf = NULL;
|
|
R_ClearParticles ();
|
|
|
|
r_cnumsurfs = (int)r_maxsurfs.value;
|
|
|
|
if (r_cnumsurfs <= MINSURFACES)
|
|
r_cnumsurfs = MINSURFACES;
|
|
|
|
// //Dan: testing:
|
|
// r_cnumsurfs=100;
|
|
if (r_cnumsurfs > NUMSTACKSURFACES)
|
|
{
|
|
surfaces = Hunk_AllocName (r_cnumsurfs * sizeof(surf_t), "surfaces");
|
|
surface_p = surfaces;
|
|
surf_max = &surfaces[r_cnumsurfs];
|
|
r_surfsonstack = false;
|
|
// surface 0 doesn't really exist; it's just a dummy because index 0
|
|
// is used to indicate no edge attached to surface
|
|
surfaces--;
|
|
R_SurfacePatch ();
|
|
}
|
|
else
|
|
{
|
|
r_surfsonstack = true;
|
|
}
|
|
|
|
r_maxedgesseen = 0;
|
|
r_maxsurfsseen = 0;
|
|
|
|
r_numallocatededges = (int)r_maxedges.value;
|
|
|
|
if (r_numallocatededges < MINEDGES)
|
|
r_numallocatededges = MINEDGES;
|
|
|
|
// //Dan: testing:
|
|
// r_numallocatededges=600;
|
|
|
|
if (r_numallocatededges <= NUMSTACKEDGES)
|
|
{
|
|
auxedges = NULL;
|
|
}
|
|
else
|
|
{
|
|
auxedges = Hunk_AllocName (r_numallocatededges * sizeof(edge_t),
|
|
"edges");
|
|
}
|
|
|
|
r_dowarpold = false;
|
|
r_viewchanged = false;
|
|
#ifdef PASSAGES
|
|
CreatePassages ();
|
|
#endif
|
|
}
|
|
|
|
#ifdef USEFPM
|
|
void R_NewMapFPM (void)
|
|
{
|
|
int i;
|
|
|
|
// clear out efrags in case the level hasn't been reloaded
|
|
// FIXME: is this one short?
|
|
for (i=0 ; i<clFPM.worldmodel->numleafs ; i++)
|
|
clFPM.worldmodel->leafs[i].efrags = NULL;
|
|
|
|
r_viewleafFPM = NULL;
|
|
R_ClearParticlesFPM ();
|
|
|
|
r_cnumsurfs = (int)r_maxsurfs.value;
|
|
|
|
if (r_cnumsurfs <= MINSURFACES)
|
|
r_cnumsurfs = MINSURFACES;
|
|
|
|
if (r_cnumsurfs > NUMSTACKSURFACES)
|
|
{
|
|
surfacesFPM = Hunk_AllocName (r_cnumsurfs * sizeof(surf_FPM_t), "surfaces");
|
|
surface_FPM_p = surfacesFPM;
|
|
surf_maxFPM = &surfacesFPM[r_cnumsurfs];
|
|
r_surfsonstack = false;
|
|
// surface 0 doesn't really exist; it's just a dummy because index 0
|
|
// is used to indicate no edge attached to surface
|
|
surfacesFPM--;
|
|
R_SurfacePatchFPM ();
|
|
}
|
|
else
|
|
{
|
|
r_surfsonstack = true;
|
|
}
|
|
|
|
r_maxedgesseen = 0;
|
|
r_maxsurfsseen = 0;
|
|
|
|
r_numallocatededges = (int)r_maxedges.value;
|
|
|
|
if (r_numallocatededges < MINEDGES)
|
|
r_numallocatededges = MINEDGES;
|
|
|
|
if (r_numallocatededges <= NUMSTACKEDGES)
|
|
{
|
|
auxedgesFPM = NULL;
|
|
}
|
|
else
|
|
{
|
|
auxedgesFPM = Hunk_AllocName (r_numallocatededges * sizeof(edge_FPM_t),
|
|
"edges");
|
|
}
|
|
|
|
r_dowarpold = false;
|
|
r_viewchanged = false;
|
|
//Dan: not defined for our builds
|
|
#ifdef PASSAGES
|
|
CreatePassages ();
|
|
#endif
|
|
}
|
|
#endif //USEFPM
|
|
|
|
/*
|
|
===============
|
|
R_SetVrect
|
|
===============
|
|
*/
|
|
void R_SetVrect (vrect_t *pvrectin, vrect_t *pvrect, int lineadj)
|
|
{
|
|
int h;
|
|
float size;
|
|
|
|
size = scr_viewsize.value > 100 ? 100 : scr_viewsize.value;
|
|
if (cl.intermission)
|
|
{
|
|
size = 100;
|
|
lineadj = 0;
|
|
}
|
|
size /= 100;
|
|
|
|
h = pvrectin->height - lineadj;
|
|
pvrect->width = (int)(pvrectin->width * size);
|
|
if (pvrect->width < 96)
|
|
{
|
|
size = (float)(96.0 / pvrectin->width);
|
|
pvrect->width = 96; // min for icons
|
|
}
|
|
pvrect->width &= ~7;
|
|
pvrect->height = (int)(pvrectin->height * size);
|
|
if (pvrect->height > pvrectin->height - lineadj)
|
|
pvrect->height = pvrectin->height - lineadj;
|
|
|
|
pvrect->height &= ~1;
|
|
|
|
pvrect->x = (pvrectin->width - pvrect->width)/2;
|
|
pvrect->y = (h - pvrect->height)/2;
|
|
|
|
{
|
|
if (lcd_x.value)
|
|
{
|
|
pvrect->y >>= 1;
|
|
pvrect->height >>= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef USEFPM
|
|
void R_SetVrectFPM (vrect_t *pvrectin, vrect_t *pvrect, int lineadj)
|
|
{
|
|
int h;
|
|
fixedpoint_t size;
|
|
fixedpoint_t tmp;
|
|
|
|
tmp=FPM_FROMFLOAT(scr_viewsize.value);
|
|
size = tmp > FPM_FROMLONGC(100) ? FPM_FROMLONGC(100) : tmp;
|
|
if (clFPM.intermission)
|
|
{
|
|
size = FPM_FROMLONGC(100);
|
|
lineadj = 0;
|
|
}
|
|
size = FPM_DIVINT(size, 100);
|
|
|
|
h = pvrectin->height - lineadj;
|
|
pvrect->width = FPM_TOLONG(FPM_MUL(FPM_FROMLONG(pvrectin->width), size));
|
|
if (pvrect->width < 96)
|
|
{
|
|
size = FPM_DIVINT(FPM_FROMFLOATC(96.0), pvrectin->width);
|
|
pvrect->width = 96; // min for icons
|
|
}
|
|
pvrect->width &= ~7;
|
|
pvrect->height = FPM_TOLONG(FPM_DIV(FPM_FROMLONG(pvrectin->height), size));
|
|
if (pvrect->height > pvrectin->height - lineadj)
|
|
pvrect->height = pvrectin->height - lineadj;
|
|
|
|
pvrect->height &= ~1;
|
|
|
|
pvrect->x = (pvrectin->width - pvrect->width)/2;
|
|
pvrect->y = (h - pvrect->height)/2;
|
|
|
|
{
|
|
if (lcd_x.value)
|
|
{
|
|
pvrect->y >>= 1;
|
|
pvrect->height >>= 1;
|
|
}
|
|
}
|
|
}
|
|
#endif //USEFPM
|
|
|
|
/*
|
|
===============
|
|
R_ViewChanged
|
|
|
|
Called every time the vid structure or r_refdef changes.
|
|
Guaranteed to be called before the first refresh
|
|
===============
|
|
*/
|
|
#ifndef USE_PQ_OPT
|
|
void R_ViewChanged (vrect_t *pvrect, int lineadj, float aspect)
|
|
{
|
|
int i;
|
|
float res_scale;
|
|
|
|
r_viewchanged = true;
|
|
|
|
R_SetVrect (pvrect, &r_refdef.vrect, lineadj);
|
|
|
|
r_refdef.horizontalFieldOfView = (float)(2.0 * tan (r_refdef.fov_x/360*M_PI));
|
|
r_refdef.fvrectx = (float)r_refdef.vrect.x;
|
|
r_refdef.fvrectx_adj = (float)(r_refdef.vrect.x - 0.5);
|
|
r_refdef.vrect_x_adj_shift20 = (r_refdef.vrect.x<<20) + (1<<19) - 1;
|
|
r_refdef.fvrecty = (float)r_refdef.vrect.y;
|
|
r_refdef.fvrecty_adj = (float)(r_refdef.vrect.y - 0.5);
|
|
r_refdef.vrectright = r_refdef.vrect.x + r_refdef.vrect.width;
|
|
r_refdef.vrectright_adj_shift20 = (r_refdef.vrectright<<20) + (1<<19) - 1;
|
|
r_refdef.fvrectright = (float)r_refdef.vrectright;
|
|
r_refdef.fvrectright_adj = (float)(r_refdef.vrectright - 0.5);
|
|
r_refdef.vrectrightedge = (float)(r_refdef.vrectright - 0.99);
|
|
r_refdef.vrectbottom = r_refdef.vrect.y + r_refdef.vrect.height;
|
|
r_refdef.fvrectbottom = (float)r_refdef.vrectbottom;
|
|
r_refdef.fvrectbottom_adj = (float)(r_refdef.vrectbottom - 0.5);
|
|
|
|
r_refdef.aliasvrect.x = (int)(r_refdef.vrect.x * r_aliasuvscale);
|
|
r_refdef.aliasvrect.y = (int)(r_refdef.vrect.y * r_aliasuvscale);
|
|
r_refdef.aliasvrect.width = (int)(r_refdef.vrect.width * r_aliasuvscale);
|
|
r_refdef.aliasvrect.height = (int)(r_refdef.vrect.height * r_aliasuvscale);
|
|
r_refdef.aliasvrectright = r_refdef.aliasvrect.x +
|
|
r_refdef.aliasvrect.width;
|
|
r_refdef.aliasvrectbottom = r_refdef.aliasvrect.y +
|
|
r_refdef.aliasvrect.height;
|
|
|
|
pixelAspect = aspect;
|
|
xOrigin = r_refdef.xOrigin;
|
|
yOrigin = r_refdef.yOrigin;
|
|
|
|
screenAspect = r_refdef.vrect.width*pixelAspect /
|
|
r_refdef.vrect.height;
|
|
// 320*200 1.0 pixelAspect = 1.6 screenAspect
|
|
// 320*240 1.0 pixelAspect = 1.3333 screenAspect
|
|
// proper 320*200 pixelAspect = 0.8333333
|
|
|
|
verticalFieldOfView = r_refdef.horizontalFieldOfView / screenAspect;
|
|
|
|
// values for perspective projection
|
|
// if math were exact, the values would range from 0.5 to to range+0.5
|
|
// hopefully they wll be in the 0.000001 to range+.999999 and truncate
|
|
// the polygon rasterization will never render in the first row or column
|
|
// but will definately render in the [range] row and column, so adjust the
|
|
// buffer origin to get an exact edge to edge fill
|
|
xcenter = (float)(((float)r_refdef.vrect.width * XCENTERING) +
|
|
r_refdef.vrect.x - 0.5);
|
|
aliasxcenter = xcenter * r_aliasuvscale;
|
|
ycenter = (float)(((float)r_refdef.vrect.height * YCENTERING) +
|
|
r_refdef.vrect.y - 0.5);
|
|
aliasycenter = ycenter * r_aliasuvscale;
|
|
|
|
xscale = r_refdef.vrect.width / r_refdef.horizontalFieldOfView;
|
|
aliasxscale = xscale * r_aliasuvscale;
|
|
xscaleinv = (float)(1.0 / xscale);
|
|
yscale = xscale * pixelAspect;
|
|
aliasyscale = yscale * r_aliasuvscale;
|
|
yscaleinv = (float)(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] = (float)(-1.0 / (xOrigin*r_refdef.horizontalFieldOfView));
|
|
screenedge[0].normal[1] = 0;
|
|
screenedge[0].normal[2] = 1;
|
|
screenedge[0].type = PLANE_ANYZ;
|
|
|
|
// right side clip
|
|
screenedge[1].normal[0] =
|
|
(float)(1.0 / ((1.0-xOrigin)*r_refdef.horizontalFieldOfView));
|
|
screenedge[1].normal[1] = 0;
|
|
screenedge[1].normal[2] = 1;
|
|
screenedge[1].type = PLANE_ANYZ;
|
|
|
|
// top side clip
|
|
screenedge[2].normal[0] = 0;
|
|
screenedge[2].normal[1] = (float)(-1.0 / (yOrigin*verticalFieldOfView));
|
|
screenedge[2].normal[2] = 1;
|
|
screenedge[2].type = PLANE_ANYZ;
|
|
|
|
// bottom side clip
|
|
screenedge[3].normal[0] = 0;
|
|
screenedge[3].normal[1] = (float)(1.0 / ((1.0-yOrigin)*verticalFieldOfView));
|
|
screenedge[3].normal[2] = 1;
|
|
screenedge[3].type = PLANE_ANYZ;
|
|
|
|
for (i=0 ; i<4 ; i++)
|
|
VectorNormalize (screenedge[i].normal);
|
|
|
|
res_scale = (float)(sqrt ((double)(r_refdef.vrect.width * r_refdef.vrect.height) /
|
|
(320.0 * 152.0)) *
|
|
(2.0 / r_refdef.horizontalFieldOfView));
|
|
r_aliastransition = r_aliastransbase.value * res_scale;
|
|
r_resfudge = r_aliastransadj.value * res_scale;
|
|
|
|
if (scr_fov.value <= 90.0)
|
|
r_fov_greater_than_90 = false;
|
|
else
|
|
r_fov_greater_than_90 = true;
|
|
|
|
// TODO: collect 386-specific code in one place
|
|
#if id386
|
|
if (r_pixbytes == 1)
|
|
{
|
|
Sys_MakeCodeWriteable ((long)R_Surf8Start,
|
|
(long)R_Surf8End - (long)R_Surf8Start);
|
|
colormap = vid.colormap;
|
|
R_Surf8Patch ();
|
|
}
|
|
else
|
|
{
|
|
Sys_MakeCodeWriteable ((long)R_Surf16Start,
|
|
(long)R_Surf16End - (long)R_Surf16Start);
|
|
colormap = vid.colormap16;
|
|
R_Surf16Patch ();
|
|
}
|
|
#endif // id386
|
|
|
|
D_ViewChanged ();
|
|
}
|
|
#else
|
|
//JB: Optimization
|
|
void R_ViewChanged (vrect_t *pvrect, int lineadj, float aspect)
|
|
{
|
|
int i;
|
|
float res_scale;
|
|
|
|
r_viewchanged = true;
|
|
|
|
R_SetVrect (pvrect, &r_refdef.vrect, lineadj);
|
|
|
|
r_refdef.horizontalFieldOfView = (float)(2.0 * tan (r_refdef.fov_x/360*M_PI));
|
|
r_refdef.fvrectx = (float)r_refdef.vrect.x;
|
|
r_refdef.fvrectx_adj = (float)(r_refdef.vrect.x - 0.5);
|
|
r_refdef.vrect_x_adj_shift20 = (r_refdef.vrect.x<<20) + (1<<19) - 1;
|
|
r_refdef.fvrecty = (float)r_refdef.vrect.y;
|
|
r_refdef.fvrecty_adj = (float)(r_refdef.vrect.y - 0.5);
|
|
r_refdef.vrectright = r_refdef.vrect.x + r_refdef.vrect.width;
|
|
r_refdef.vrectright_adj_shift20 = (r_refdef.vrectright<<20) + (1<<19) - 1;
|
|
r_refdef.fvrectright = (float)r_refdef.vrectright;
|
|
r_refdef.fvrectright_adj = (float)(r_refdef.vrectright - 0.5);
|
|
r_refdef.vrectrightedge = (float)(r_refdef.vrectright - 0.99);
|
|
r_refdef.vrectbottom = r_refdef.vrect.y + r_refdef.vrect.height;
|
|
r_refdef.fvrectbottom = (float)r_refdef.vrectbottom;
|
|
r_refdef.fvrectbottom_adj = (float)(r_refdef.vrectbottom - 0.5);
|
|
|
|
r_refdef.aliasvrect.x = (int)(r_refdef.vrect.x * r_aliasuvscale);
|
|
r_refdef.aliasvrect.y = (int)(r_refdef.vrect.y * r_aliasuvscale);
|
|
r_refdef.aliasvrect.width = (int)(r_refdef.vrect.width * r_aliasuvscale);
|
|
r_refdef.aliasvrect.height = (int)(r_refdef.vrect.height * r_aliasuvscale);
|
|
r_refdef.aliasvrectright = r_refdef.aliasvrect.x +
|
|
r_refdef.aliasvrect.width;
|
|
r_refdef.aliasvrectbottom = r_refdef.aliasvrect.y +
|
|
r_refdef.aliasvrect.height;
|
|
|
|
pixelAspect = aspect;
|
|
xOrigin = r_refdef.xOrigin;
|
|
yOrigin = r_refdef.yOrigin;
|
|
|
|
screenAspect = r_refdef.vrect.width*pixelAspect /
|
|
r_refdef.vrect.height;
|
|
// 320*200 1.0 pixelAspect = 1.6 screenAspect
|
|
// 320*240 1.0 pixelAspect = 1.3333 screenAspect
|
|
// proper 320*200 pixelAspect = 0.8333333
|
|
|
|
verticalFieldOfView = r_refdef.horizontalFieldOfView / screenAspect;
|
|
|
|
// values for perspective projection
|
|
// if math were exact, the values would range from 0.5 to to range+0.5
|
|
// hopefully they wll be in the 0.000001 to range+.999999 and truncate
|
|
// the polygon rasterization will never render in the first row or column
|
|
// but will definately render in the [range] row and column, so adjust the
|
|
// buffer origin to get an exact edge to edge fill
|
|
xcenter = (float)(((float)r_refdef.vrect.width * XCENTERING) +
|
|
r_refdef.vrect.x - 0.5);
|
|
fpxcenter = (int)(64.0f * xcenter);
|
|
aliasxcenter = xcenter * r_aliasuvscale;
|
|
ycenter = (float)(((float)r_refdef.vrect.height * YCENTERING) +
|
|
r_refdef.vrect.y - 0.5);
|
|
fpycenter = (int)(64.0f * ycenter);
|
|
aliasycenter = ycenter * r_aliasuvscale;
|
|
|
|
xscale = r_refdef.vrect.width / r_refdef.horizontalFieldOfView;
|
|
aliasxscale = xscale * r_aliasuvscale;
|
|
xscaleinv = (float)(1.0 / xscale);
|
|
yscale = xscale * pixelAspect;
|
|
fpxscale = (int)(1024.0f * xscale);
|
|
fpyscale = (int)(1024.0f * yscale);
|
|
aliasyscale = yscale * r_aliasuvscale;
|
|
yscaleinv = (float)(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);
|
|
yscale_fxp=(int)(yscale*8388608.0);
|
|
xcenter_fxp=(int)(xcenter*8388608.0);
|
|
ycenter_fxp=(int)(ycenter*8388608.0);
|
|
r_refdef_fvrectx_adj_fxp=(int)(r_refdef.fvrectx_adj*8388608.0);
|
|
r_refdef_fvrectright_adj_fxp=(int)(r_refdef.fvrectright_adj*8388608.0);
|
|
r_refdef_fvrecty_adj_fxp=(int)(r_refdef.fvrecty_adj*8388608.0);
|
|
r_refdef_fvrectbottom_adj_fxp=(int)(r_refdef.fvrectbottom_adj*8388608.0);
|
|
#endif
|
|
|
|
// left side clip
|
|
screenedge[0].normal[0] = (float)(-1.0 / (xOrigin*r_refdef.horizontalFieldOfView));
|
|
screenedge[0].normal[1] = 0;
|
|
screenedge[0].normal[2] = 1;
|
|
screenedge[0].type = PLANE_ANYZ;
|
|
|
|
// right side clip
|
|
screenedge[1].normal[0] =
|
|
(float)(1.0 / ((1.0-xOrigin)*r_refdef.horizontalFieldOfView));
|
|
screenedge[1].normal[1] = 0;
|
|
screenedge[1].normal[2] = 1;
|
|
screenedge[1].type = PLANE_ANYZ;
|
|
|
|
// top side clip
|
|
screenedge[2].normal[0] = 0;
|
|
screenedge[2].normal[1] = (float)(-1.0 / (yOrigin*verticalFieldOfView));
|
|
screenedge[2].normal[2] = 1;
|
|
screenedge[2].type = PLANE_ANYZ;
|
|
|
|
// bottom side clip
|
|
screenedge[3].normal[0] = 0;
|
|
screenedge[3].normal[1] = (float)(1.0 / ((1.0-yOrigin)*verticalFieldOfView));
|
|
screenedge[3].normal[2] = 1;
|
|
screenedge[3].type = PLANE_ANYZ;
|
|
|
|
for (i=0 ; i<4 ; i++)
|
|
VectorNormalize (screenedge[i].normal);
|
|
|
|
res_scale = (float)(sqrt ((double)(r_refdef.vrect.width * r_refdef.vrect.height) /
|
|
(320.0 * 152.0)) *
|
|
(2.0 / r_refdef.horizontalFieldOfView));
|
|
r_aliastransition = r_aliastransbase.value * res_scale;
|
|
r_resfudge = r_aliastransadj.value * res_scale;
|
|
|
|
if (scr_fov.value <= 90.0)
|
|
r_fov_greater_than_90 = false;
|
|
else
|
|
r_fov_greater_than_90 = true;
|
|
|
|
// TODO: collect 386-specific code in one place
|
|
#if id386
|
|
if (r_pixbytes == 1)
|
|
{
|
|
Sys_MakeCodeWriteable ((long)R_Surf8Start,
|
|
(long)R_Surf8End - (long)R_Surf8Start);
|
|
colormap = vid.colormap;
|
|
R_Surf8Patch ();
|
|
}
|
|
else
|
|
{
|
|
Sys_MakeCodeWriteable ((long)R_Surf16Start,
|
|
(long)R_Surf16End - (long)R_Surf16Start);
|
|
colormap = vid.colormap16;
|
|
R_Surf16Patch ();
|
|
}
|
|
#endif // id386
|
|
|
|
D_ViewChanged ();
|
|
}
|
|
#endif
|
|
/*
|
|
===============
|
|
R_MarkLeaves
|
|
===============
|
|
*/
|
|
void R_MarkLeaves (void)
|
|
{
|
|
byte *vis;
|
|
mnode_t *node;
|
|
int i;
|
|
|
|
if (r_oldviewleaf == r_viewleaf)
|
|
return;
|
|
|
|
r_visframecount++;
|
|
r_oldviewleaf = r_viewleaf;
|
|
|
|
vis = Mod_LeafPVS (r_viewleaf, cl.worldmodel);
|
|
|
|
for (i=0 ; i<cl.worldmodel->numleafs ; i++)
|
|
{
|
|
if (vis[i>>3] & (1<<(i&7)))
|
|
{
|
|
node = (mnode_t *)&cl.worldmodel->leafs[i+1];
|
|
do
|
|
{
|
|
if (node->visframe == r_visframecount)
|
|
break;
|
|
node->visframe = r_visframecount;
|
|
node = node->parent;
|
|
} while (node);
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef USEFPM
|
|
void R_MarkLeavesFPM (void)
|
|
{
|
|
byte *vis;
|
|
mnode_FPM_t *node;
|
|
int i;
|
|
|
|
if (r_oldviewleafFPM == r_viewleafFPM)
|
|
return;
|
|
|
|
r_visframecount++;
|
|
r_oldviewleafFPM = r_viewleafFPM;
|
|
|
|
vis = Mod_LeafPVSFPM (r_viewleafFPM, clFPM.worldmodel);
|
|
|
|
for (i=0 ; i<clFPM.worldmodel->numleafs ; i++)
|
|
{
|
|
if (vis[i>>3] & (1<<(i&7)))
|
|
{
|
|
node = (mnode_FPM_t *)&clFPM.worldmodel->leafs[i+1];
|
|
do
|
|
{
|
|
if (node->visframe == r_visframecount)
|
|
break;
|
|
node->visframe = r_visframecount;
|
|
node = node->parent;
|
|
} while (node);
|
|
}
|
|
}
|
|
}
|
|
#endif //USEFPM
|
|
|
|
/*
|
|
=============
|
|
R_DrawEntitiesOnList
|
|
=============
|
|
*/
|
|
void R_DrawEntitiesOnList (void)
|
|
{
|
|
int i, j;
|
|
int lnum;
|
|
alight_t lighting;
|
|
// FIXME: remove and do real lighting
|
|
float lightvec[3] = {-1, 0, 0};
|
|
vec3_t dist;
|
|
float add;
|
|
|
|
if (!r_drawentities.value)
|
|
return;
|
|
|
|
for (i=0 ; i<cl_numvisedicts ; i++)
|
|
{
|
|
|
|
currententity = cl_visedicts[i];
|
|
|
|
if (currententity == &cl_entities[cl.viewentity])
|
|
continue; // don't draw the player
|
|
|
|
switch (currententity->model->type)
|
|
{
|
|
case mod_sprite:
|
|
VectorCopy (currententity->origin, r_entorigin);
|
|
VectorSubtract (r_origin, r_entorigin, modelorg);
|
|
R_DrawSprite ();
|
|
break;
|
|
|
|
case mod_alias:
|
|
VectorCopy (currententity->origin, r_entorigin);
|
|
VectorSubtract (r_origin, r_entorigin, modelorg);
|
|
|
|
// see if the bounding box lets us trivially reject, also sets
|
|
// trivial accept status
|
|
|
|
if (R_AliasCheckBBox ())
|
|
{
|
|
|
|
j = R_LightPoint (currententity->origin);
|
|
|
|
lighting.ambientlight = j;
|
|
lighting.shadelight = j;
|
|
|
|
lighting.plightvec = lightvec;
|
|
|
|
for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
|
|
{
|
|
if (cl_dlights[lnum].die >= cl.time)
|
|
{
|
|
VectorSubtract (currententity->origin,
|
|
cl_dlights[lnum].origin,
|
|
dist);
|
|
add = cl_dlights[lnum].radius - Length(dist);
|
|
|
|
if (add > 0)
|
|
lighting.ambientlight += (int)add;
|
|
}
|
|
}
|
|
|
|
|
|
// clamp lighting so it doesn't overbright as much
|
|
if (lighting.ambientlight > 128)
|
|
lighting.ambientlight = 128;
|
|
if (lighting.ambientlight + lighting.shadelight > 192)
|
|
lighting.shadelight = 192 - lighting.ambientlight;
|
|
|
|
R_AliasDrawModel (&lighting);
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef USEFPM
|
|
void R_DrawEntitiesOnListFPM (void)
|
|
{
|
|
int i, j;
|
|
int lnum;
|
|
alight_FPM_t lighting;
|
|
// FIXME: remove and do real lighting (not Dan's comment)
|
|
fixedpoint_t lightvec[3] = {FPM_FROMLONGC(-1), 0, 0};
|
|
vec3_FPM_t dist;
|
|
fixedpoint_t add;
|
|
|
|
if (!r_drawentities.value)
|
|
return;
|
|
|
|
for (i=0 ; i<cl_numvisedicts ; i++)
|
|
{
|
|
currententityFPM = cl_visedictsFPM[i];
|
|
|
|
if (currententityFPM == &cl_entitiesFPM[clFPM.viewentity])
|
|
continue; // don't draw the player
|
|
|
|
switch (currententityFPM->model->type)
|
|
{
|
|
case mod_sprite:
|
|
VectorCopy (currententityFPM->origin, r_entoriginFPM);
|
|
VectorSubtractFPM (r_originFPM, r_entoriginFPM, modelorgFPM);
|
|
R_DrawSpriteFPM ();
|
|
break;
|
|
|
|
case mod_alias:
|
|
VectorCopy (currententityFPM->origin, r_entoriginFPM);
|
|
VectorSubtractFPM (r_originFPM, r_entoriginFPM, modelorgFPM);
|
|
|
|
// see if the bounding box lets us trivially reject, also sets
|
|
// trivial accept status
|
|
if (R_AliasCheckBBoxFPM ())
|
|
{
|
|
j = R_LightPointFPM (currententityFPM->origin);
|
|
|
|
lighting.ambientlight = j;
|
|
lighting.shadelight = j;
|
|
|
|
lighting.plightvec = lightvec;
|
|
|
|
for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
|
|
{
|
|
if (cl_dlightsFPM[lnum].die >= cl.time)
|
|
{
|
|
VectorSubtractFPM (currententityFPM->origin,
|
|
cl_dlightsFPM[lnum].origin,
|
|
dist);
|
|
add = cl_dlightsFPM[lnum].radius - LengthFPM(dist);
|
|
|
|
if (add > 0)
|
|
lighting.ambientlight += (int)add;
|
|
}
|
|
}
|
|
|
|
// clamp lighting so it doesn't overbright as much
|
|
if (lighting.ambientlight > 128)
|
|
lighting.ambientlight = 128;
|
|
if (lighting.ambientlight + lighting.shadelight > 192)
|
|
lighting.shadelight = 192 - lighting.ambientlight;
|
|
|
|
R_AliasDrawModelFPM (&lighting);
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif //USEFPM
|
|
|
|
/*
|
|
=============
|
|
R_DrawViewModel
|
|
=============
|
|
*/
|
|
void R_DrawViewModel (void)
|
|
{
|
|
// FIXME: remove and do real lighting
|
|
float lightvec[3] = {-1, 0, 0};
|
|
int j;
|
|
int lnum;
|
|
vec3_t dist;
|
|
float add;
|
|
dlight_t *dl;
|
|
|
|
if (!r_drawviewmodel.value || r_fov_greater_than_90)
|
|
return;
|
|
|
|
if (cl.items & IT_INVISIBILITY)
|
|
return;
|
|
|
|
if (cl.stats[STAT_HEALTH] <= 0)
|
|
return;
|
|
|
|
currententity = &cl.viewent;
|
|
if (!currententity->model)
|
|
return;
|
|
|
|
VectorCopy (currententity->origin, r_entorigin);
|
|
VectorSubtract (r_origin, r_entorigin, modelorg);
|
|
|
|
VectorCopy (vup, viewlightvec);
|
|
VectorInverse (viewlightvec);
|
|
|
|
j = R_LightPoint (currententity->origin);
|
|
|
|
if (j < 24)
|
|
j = 24; // allways give some light on gun
|
|
r_viewlighting.ambientlight = j;
|
|
r_viewlighting.shadelight = j;
|
|
|
|
// add dynamic lights
|
|
for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
|
|
{
|
|
dl = &cl_dlights[lnum];
|
|
if (!dl->radius)
|
|
continue;
|
|
if (!dl->radius)
|
|
continue;
|
|
if (dl->die < cl.time)
|
|
continue;
|
|
|
|
VectorSubtract (currententity->origin, dl->origin, dist);
|
|
add = dl->radius - Length(dist);
|
|
if (add > 0)
|
|
r_viewlighting.ambientlight += (int)add;
|
|
}
|
|
|
|
// clamp lighting so it doesn't overbright as much
|
|
if (r_viewlighting.ambientlight > 128)
|
|
r_viewlighting.ambientlight = 128;
|
|
if (r_viewlighting.ambientlight + r_viewlighting.shadelight > 192)
|
|
r_viewlighting.shadelight = 192 - r_viewlighting.ambientlight;
|
|
|
|
r_viewlighting.plightvec = lightvec;
|
|
|
|
#ifdef QUAKE2
|
|
cl.light_level = r_viewlighting.ambientlight;
|
|
#endif
|
|
|
|
R_AliasDrawModel (&r_viewlighting);
|
|
}
|
|
|
|
#ifdef USEFPM
|
|
void R_DrawViewModelFPM (void)
|
|
{
|
|
// FIXME: remove and do real lighting
|
|
fixedpoint_t lightvec[3] = {FPM_FROMLONG(-1), 0, 0};
|
|
int j;
|
|
int lnum;
|
|
vec3_FPM_t dist;
|
|
fixedpoint_t add;
|
|
dlight_FPM_t *dl;
|
|
|
|
if (!r_drawviewmodel.value || r_fov_greater_than_90)
|
|
return;
|
|
|
|
if (clFPM.items & IT_INVISIBILITY)
|
|
return;
|
|
|
|
if (clFPM.stats[STAT_HEALTH] <= 0)
|
|
return;
|
|
|
|
currententityFPM = &clFPM.viewent;
|
|
if (!currententityFPM->model)
|
|
return;
|
|
|
|
VectorCopy (currententityFPM->origin, r_entoriginFPM);
|
|
VectorSubtractFPM (r_originFPM, r_entoriginFPM, modelorgFPM);
|
|
|
|
VectorCopy (vupFPM, viewlightvecFPM);
|
|
VectorInverseFPM (viewlightvecFPM);
|
|
|
|
j = R_LightPointFPM (currententityFPM->origin);
|
|
|
|
if (j < 24)
|
|
j = 24; // allways give some light on gun
|
|
r_viewlightingFPM.ambientlight = j;
|
|
r_viewlightingFPM.shadelight = j;
|
|
|
|
// add dynamic lights
|
|
for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
|
|
{
|
|
dl = &cl_dlightsFPM[lnum];
|
|
if (!dl->radius)
|
|
continue;
|
|
if (!dl->radius)
|
|
continue;
|
|
if (dl->die < cl.time)
|
|
continue;
|
|
|
|
VectorSubtractFPM (currententityFPM->origin, dl->origin, dist);
|
|
add = dl->radius - LengthFPM(dist);
|
|
if (add > 0)
|
|
r_viewlightingFPM.ambientlight += (int)add;
|
|
}
|
|
|
|
// clamp lighting so it doesn't overbright as much
|
|
if (r_viewlightingFPM.ambientlight > 128)
|
|
r_viewlightingFPM.ambientlight = 128;
|
|
if (r_viewlightingFPM.ambientlight + r_viewlightingFPM.shadelight > 192)
|
|
r_viewlightingFPM.shadelight = 192 - r_viewlightingFPM.ambientlight;
|
|
|
|
r_viewlightingFPM.plightvec = lightvec;
|
|
|
|
#ifdef QUAKE2
|
|
clFPM.light_level = r_viewlightingFPM.ambientlight;
|
|
#endif
|
|
|
|
R_AliasDrawModelFPM (&r_viewlightingFPM);
|
|
}
|
|
#endif //USEFPM
|
|
|
|
/*
|
|
=============
|
|
R_BmodelCheckBBox
|
|
=============
|
|
*/
|
|
int R_BmodelCheckBBox (model_t *clmodel, float *minmaxs)
|
|
{
|
|
int i, *pindex, clipflags;
|
|
vec3_t acceptpt, rejectpt;
|
|
double d;
|
|
|
|
clipflags = 0;
|
|
|
|
if (currententity->angles[0] || currententity->angles[1]
|
|
|| currententity->angles[2])
|
|
{
|
|
for (i=0 ; i<4 ; i++)
|
|
{
|
|
d = DotProduct (currententity->origin, view_clipplanes[i].normal);
|
|
d -= view_clipplanes[i].dist;
|
|
|
|
if (d <= -clmodel->radius)
|
|
return BMODEL_FULLY_CLIPPED;
|
|
|
|
if (d <= clmodel->radius)
|
|
clipflags |= (1<<i);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i=0 ; i<4 ; i++)
|
|
{
|
|
// generate accept and reject points
|
|
// FIXME: do with fast look-ups or integer tests based on the sign bit
|
|
// of the floating point values
|
|
|
|
pindex = pfrustum_indexes[i];
|
|
|
|
rejectpt[0] = minmaxs[pindex[0]];
|
|
rejectpt[1] = minmaxs[pindex[1]];
|
|
rejectpt[2] = minmaxs[pindex[2]];
|
|
|
|
d = DotProduct (rejectpt, view_clipplanes[i].normal);
|
|
d -= view_clipplanes[i].dist;
|
|
|
|
if (d <= 0)
|
|
return BMODEL_FULLY_CLIPPED;
|
|
|
|
acceptpt[0] = minmaxs[pindex[3+0]];
|
|
acceptpt[1] = minmaxs[pindex[3+1]];
|
|
acceptpt[2] = minmaxs[pindex[3+2]];
|
|
|
|
d = DotProduct (acceptpt, view_clipplanes[i].normal);
|
|
d -= view_clipplanes[i].dist;
|
|
|
|
if (d <= 0)
|
|
clipflags |= (1<<i);
|
|
}
|
|
}
|
|
|
|
return clipflags;
|
|
}
|
|
|
|
#ifdef USEFPM
|
|
int R_BmodelCheckBBoxFPM (model_FPM_t *clmodel, fixedpoint_t *minmaxs)
|
|
{
|
|
int i, *pindex, clipflags;
|
|
vec3_FPM_t acceptpt, rejectpt;
|
|
fixedpoint_t d; //Dan: potential overflow / underflow (was a double)
|
|
|
|
clipflags = 0;
|
|
|
|
if (currententityFPM->angles[0] || currententityFPM->angles[1]
|
|
|| currententityFPM->angles[2])
|
|
{
|
|
for (i=0 ; i<4 ; i++)
|
|
{
|
|
d = DotProductFPM (currententityFPM->origin, view_clipplanesFPM[i].normal);
|
|
d = FPM_SUB(d, view_clipplanesFPM[i].dist);
|
|
|
|
if (d <= -clmodel->radius)
|
|
return BMODEL_FULLY_CLIPPED;
|
|
|
|
if (d <= clmodel->radius)
|
|
clipflags |= (1<<i);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i=0 ; i<4 ; i++)
|
|
{
|
|
__int64 accum, mul;
|
|
// generate accept and reject points
|
|
// FIXME: do with fast look-ups or integer tests based on the sign bit
|
|
// of the floating point values
|
|
|
|
pindex = pfrustum_indexes[i];
|
|
|
|
rejectpt[0] = minmaxs[pindex[0]];
|
|
rejectpt[1] = minmaxs[pindex[1]];
|
|
rejectpt[2] = minmaxs[pindex[2]];
|
|
|
|
//Dan: Overflow / underflow problem with 16.16 fxp. This calculation
|
|
//is only used to make a logic decision, so we'll use 32.32 code.
|
|
//This code includes Dot Product.
|
|
accum=rejectpt[0];
|
|
accum*=view_clipplanesFPM[i].normal[0];
|
|
mul=rejectpt[1];
|
|
mul*=view_clipplanesFPM[i].normal[1];
|
|
accum+=mul;
|
|
mul=rejectpt[2];
|
|
mul*=view_clipplanesFPM[i].normal[2];
|
|
accum+=mul;
|
|
mul=view_clipplanesFPM[i].dist;
|
|
mul<<=16; //16.16 -> 32.32
|
|
accum-=mul;
|
|
if (accum<=0)
|
|
return BMODEL_FULLY_CLIPPED;
|
|
|
|
//d = DotProductFPM (rejectpt, view_clipplanesFPM[i].normal);
|
|
//d = FPM_SUB(d, view_clipplanesFPM[i].dist);
|
|
|
|
//if (d <= 0)
|
|
// return BMODEL_FULLY_CLIPPED;
|
|
|
|
acceptpt[0] = minmaxs[pindex[3+0]];
|
|
acceptpt[1] = minmaxs[pindex[3+1]];
|
|
acceptpt[2] = minmaxs[pindex[3+2]];
|
|
|
|
accum=acceptpt[0];
|
|
accum*=view_clipplanesFPM[i].normal[0];
|
|
mul=acceptpt[1];
|
|
mul*=view_clipplanesFPM[i].normal[1];
|
|
accum+=mul;
|
|
mul=acceptpt[2];
|
|
mul*=view_clipplanesFPM[i].normal[2];
|
|
accum+=mul;
|
|
mul=view_clipplanesFPM[i].dist;
|
|
mul<<=16; //16.16 -> 32.32
|
|
accum-=mul;
|
|
if (accum <= 0)
|
|
clipflags |= (1<<i);
|
|
|
|
//d = DotProductFPM (acceptpt, view_clipplanesFPM[i].normal);
|
|
//d = FPM_SUB(d, view_clipplanesFPM[i].dist);
|
|
|
|
//if (d <= 0)
|
|
// clipflags |= (1<<i);
|
|
}
|
|
}
|
|
|
|
return clipflags;
|
|
}
|
|
#endif //USEFPM
|
|
|
|
/*
|
|
=============
|
|
R_DrawBEntitiesOnList
|
|
=============
|
|
*/
|
|
void R_DrawBEntitiesOnList (void)
|
|
{
|
|
int i, j, k, clipflags;
|
|
vec3_t oldorigin;
|
|
model_t *clmodel;
|
|
float minmaxs[6];
|
|
|
|
if (!r_drawentities.value)
|
|
return;
|
|
|
|
VectorCopy (modelorg, oldorigin);
|
|
insubmodel = true;
|
|
r_dlightframecount = r_framecount;
|
|
|
|
for (i=0 ; i<cl_numvisedicts ; i++)
|
|
{
|
|
currententity = cl_visedicts[i];
|
|
|
|
switch (currententity->model->type)
|
|
{
|
|
case mod_brush:
|
|
|
|
clmodel = currententity->model;
|
|
|
|
// see if the bounding box lets us trivially reject, also sets
|
|
// trivial accept status
|
|
for (j=0 ; j<3 ; j++)
|
|
{
|
|
minmaxs[j] = currententity->origin[j] +
|
|
clmodel->mins[j];
|
|
minmaxs[3+j] = currententity->origin[j] +
|
|
clmodel->maxs[j];
|
|
}
|
|
|
|
clipflags = R_BmodelCheckBBox (clmodel, minmaxs);
|
|
|
|
if (clipflags != BMODEL_FULLY_CLIPPED)
|
|
{
|
|
VectorCopy (currententity->origin, r_entorigin);
|
|
VectorSubtract (r_origin, r_entorigin, modelorg);
|
|
// FIXME: is this needed?
|
|
VectorCopy (modelorg, r_worldmodelorg);
|
|
|
|
r_pcurrentvertbase = clmodel->vertexes;
|
|
|
|
#ifdef USE_PQ_OPT2
|
|
r_pcurrentvertbase_fxp = clmodel->vertexes_fxp;
|
|
#endif
|
|
// 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)
|
|
{
|
|
for (k=0 ; k<MAX_DLIGHTS ; k++)
|
|
{
|
|
if ((cl_dlights[k].die < cl.time) ||
|
|
(!cl_dlights[k].radius))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
R_MarkLights (&cl_dlights[k], 1<<k,
|
|
clmodel->nodes + clmodel->hulls[0].firstclipnode);
|
|
}
|
|
}
|
|
|
|
// if the driver wants polygons, deliver those. Z-buffering is on
|
|
// at this point, so no clipping to the world tree is needed, just
|
|
// frustum clipping
|
|
if (r_drawpolys | r_drawculledpolys)
|
|
{
|
|
R_ZDrawSubmodelPolys (clmodel);
|
|
}
|
|
else
|
|
{
|
|
r_pefragtopnode = NULL;
|
|
|
|
for (j=0 ; j<3 ; j++)
|
|
{
|
|
r_emins[j] = minmaxs[j];
|
|
r_emaxs[j] = minmaxs[3+j];
|
|
}
|
|
|
|
R_SplitEntityOnNode2 (cl.worldmodel->nodes);
|
|
|
|
if (r_pefragtopnode)
|
|
{
|
|
currententity->topnode = r_pefragtopnode;
|
|
|
|
if (r_pefragtopnode->contents >= 0)
|
|
{
|
|
// not a leaf; has to be clipped to the world BSP
|
|
r_clipflags = clipflags;
|
|
R_DrawSolidClippedSubmodelPolygons (clmodel);
|
|
}
|
|
else
|
|
{
|
|
// falls entirely in one leaf, so we just put all the
|
|
// edges in the edge list and let 1/z sorting handle
|
|
// drawing order
|
|
R_DrawSubmodelPolygons (clmodel, clipflags);
|
|
}
|
|
|
|
currententity->topnode = NULL;
|
|
}
|
|
}
|
|
|
|
// put back world rotation and frustum clipping
|
|
// FIXME: R_RotateBmodel should just work off base_vxx
|
|
VectorCopy (base_vpn, vpn);
|
|
VectorCopy (base_vup, vup);
|
|
VectorCopy (base_vright, vright);
|
|
VectorCopy (base_modelorg, modelorg);
|
|
VectorCopy (oldorigin, modelorg);
|
|
R_TransformFrustum ();
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
insubmodel = false;
|
|
|
|
}
|
|
|
|
|
|
//extern edge_t *ledges;
|
|
//extern surf_t *lsurfs;
|
|
|
|
|
|
/*
|
|
================
|
|
R_EdgeDrawing
|
|
================
|
|
*/
|
|
void R_EdgeDrawing (void)
|
|
{
|
|
/*
|
|
edge_t ledges[NUMSTACKEDGES + ((CACHE_SIZE - 1) / sizeof(edge_t)) + 1];
|
|
surf_t lsurfs[NUMSTACKSURFACES + ((CACHE_SIZE - 1) / sizeof(surf_t)) + 1];
|
|
edge_t *ledges;
|
|
surf_t *lsurfs;
|
|
ledges = malloc( (sizeof(edge_t)*NUMSTACKEDGES) + (sizeof(edge_t)*(((CACHE_SIZE - 1) / sizeof(edge_t)) + 1)));
|
|
lsurfs = malloc( (sizeof(edge_t)*NUMSTACKSURFACES) + (sizeof(edge_t)*(((CACHE_SIZE - 1) / sizeof(surf_t)) + 1)));
|
|
*/
|
|
|
|
#ifdef USEFPM
|
|
edge_FPM_t ledges[NUMSTACKEDGES +
|
|
((CACHE_SIZE - 1) / sizeof(edge_FPM_t)) + 1];
|
|
surf_FPM_t lsurfs[NUMSTACKSURFACES +
|
|
((CACHE_SIZE - 1) / sizeof(surf_FPM_t)) + 1];
|
|
#else
|
|
edge_t ledges[NUMSTACKEDGES + ((CACHE_SIZE - 1) / sizeof(edge_t)) + 1];
|
|
surf_t lsurfs[NUMSTACKSURFACES + ((CACHE_SIZE - 1) / sizeof(surf_t)) + 1];
|
|
|
|
#endif
|
|
|
|
// Cache_Report();
|
|
|
|
|
|
if (auxedges)
|
|
{
|
|
r_edges = auxedges;
|
|
}
|
|
else
|
|
{
|
|
r_edges = (edge_t *)
|
|
(((long)&ledges[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
|
|
}
|
|
|
|
if (r_surfsonstack)
|
|
{
|
|
surfaces = (surf_t *)
|
|
(((long)&lsurfs[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
|
|
surf_max = &surfaces[r_cnumsurfs];
|
|
// surface 0 doesn't really exist; it's just a dummy because index 0
|
|
// is used to indicate no edge attached to surface
|
|
surfaces--;
|
|
R_SurfacePatch ();
|
|
}
|
|
|
|
// Cache_Report();
|
|
|
|
R_BeginEdgeFrame ();
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
rw_time1 = (float)Sys_FloatTime ();
|
|
}
|
|
|
|
// Cache_Report();
|
|
|
|
R_RenderWorld ();
|
|
|
|
if (r_drawculledpolys){
|
|
R_ScanEdges ();
|
|
}
|
|
|
|
// only the world can be drawn back to front with no z reads or compares, just
|
|
// z writes, so have the driver turn z compares on now
|
|
D_TurnZOn ();
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
rw_time2 = (float)Sys_FloatTime ();
|
|
db_time1 = rw_time2;
|
|
}
|
|
|
|
// Cache_Report();
|
|
|
|
R_DrawBEntitiesOnList ();
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
db_time2 = (float)Sys_FloatTime ();
|
|
se_time1 = db_time2;
|
|
}
|
|
|
|
if (!r_dspeeds.value)
|
|
{
|
|
VID_UnlockBuffer ();
|
|
S_ExtraUpdate (); // don't let sound get messed up if going slow
|
|
VID_LockBuffer ();
|
|
}
|
|
|
|
// Cache_Report();
|
|
|
|
|
|
if (!(r_drawpolys | r_drawculledpolys)) {
|
|
R_ScanEdges ();
|
|
}
|
|
|
|
/* free(ledges);
|
|
free(lsurfs);
|
|
*/
|
|
|
|
}
|
|
|
|
#ifdef USEFPM
|
|
void R_EdgeDrawingFPM (void)
|
|
{
|
|
|
|
// int i=NUMSTACKEDGES +
|
|
// ((CACHE_SIZE - 1) / sizeof(edge_t)) + 1;
|
|
|
|
if (auxedgesFPM)
|
|
{
|
|
r_edgesFPM = auxedgesFPM;
|
|
}
|
|
else
|
|
{
|
|
r_edgesFPM = (edge_FPM_t *)
|
|
(((long)&ledges[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
|
|
}
|
|
|
|
if (r_surfsonstack)
|
|
{
|
|
surfacesFPM = (surf_FPM_t *)
|
|
(((long)&lsurfs[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
|
|
surf_maxFPM = &surfacesFPM[r_cnumsurfs];
|
|
// surface 0 doesn't really exist; it's just a dummy because index 0
|
|
// is used to indicate no edge attached to surface
|
|
surfacesFPM--;
|
|
R_SurfacePatchFPM ();
|
|
}
|
|
|
|
R_BeginEdgeFrameFPM ();
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
rw_time1 = (float)Sys_FloatTime ();
|
|
}
|
|
|
|
//R_RenderWorldFPM (); // FPM doesn't exist
|
|
R_RenderWorld ();
|
|
|
|
if (r_drawculledpolys)
|
|
R_ScanEdgesFPM ();
|
|
|
|
// only the world can be drawn back to front with no z reads or compares, just
|
|
// z writes, so have the driver turn z compares on now
|
|
//D_TurnZOn (); //Dan: empty func
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
rw_time2 = (float)Sys_FloatTime ();
|
|
db_time1 = rw_time2;
|
|
}
|
|
|
|
//R_DrawBEntitiesOnListFPM (); // FPM doesn't exist
|
|
R_DrawBEntitiesOnList ();
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
db_time2 = (float)Sys_FloatTime ();
|
|
se_time1 = db_time2;
|
|
}
|
|
|
|
if (!r_dspeeds.value)
|
|
{
|
|
VID_UnlockBuffer ();
|
|
S_ExtraUpdate (); // don't let sound get messed up if going slow
|
|
VID_LockBuffer ();
|
|
}
|
|
|
|
if (!(r_drawpolys | r_drawculledpolys))
|
|
R_ScanEdgesFPM ();
|
|
|
|
}
|
|
#endif //USEFPM
|
|
|
|
extern int r_numparticles, r_allocatedparticles;
|
|
/*
|
|
================
|
|
R_RenderView
|
|
|
|
r_refdef must be set before the first call
|
|
================
|
|
*/
|
|
|
|
|
|
void R_RenderView_ (void)
|
|
{
|
|
byte warpbuffer[WARP_WIDTH * WARP_HEIGHT];
|
|
//Dan:
|
|
// byte warpbuffer[WARP_WIDTH * WARP_HEIGHT];
|
|
|
|
//Dan East: Here we see if the new r_maxparticles var has changed,
|
|
//if so we change the max value. I guess this is as good a place
|
|
//as any to perform this check.
|
|
if (r_numparticles != (int)r_maxparticles.value) {
|
|
r_numparticles = (int)r_maxparticles.value;
|
|
//Check to see if we have enough particles allocated
|
|
if (r_numparticles>=r_allocatedparticles)
|
|
//We don't (they've exceeded MAX_PARTICLES or the original -particles value)
|
|
r_numparticles=r_allocatedparticles;
|
|
R_ClearParticles();
|
|
}
|
|
|
|
r_warpbuffer = warpbuffer;
|
|
|
|
if (r_timegraph.value || r_speeds.value || r_dspeeds.value)
|
|
r_time1 = (float)Sys_FloatTime ();
|
|
|
|
R_SetupFrame ();
|
|
|
|
#ifdef PASSAGES
|
|
SetVisibilityByPassages ();
|
|
#else
|
|
R_MarkLeaves (); // done here so we know if we're in water
|
|
#endif
|
|
|
|
// make FDIV fast. This reduces timing precision after we've been running for a
|
|
// while, so we don't do it globally. This also sets chop mode, and we do it
|
|
// here so that setup stuff like the refresh area calculations match what's
|
|
// done in screen.c
|
|
// Sys_LowFPPrecision ();
|
|
|
|
if (!cl_entities[0].model || !cl.worldmodel)
|
|
Sys_Error ("R_RenderView: NULL worldmodel");
|
|
|
|
if (!r_dspeeds.value)
|
|
{
|
|
VID_UnlockBuffer ();
|
|
S_ExtraUpdate (); // don't let sound get messed up if going slow
|
|
VID_LockBuffer ();
|
|
}
|
|
|
|
R_EdgeDrawing ();
|
|
|
|
if (!r_dspeeds.value)
|
|
{
|
|
VID_UnlockBuffer ();
|
|
S_ExtraUpdate (); // don't let sound get messed up if going slow
|
|
VID_LockBuffer ();
|
|
}
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
se_time2 = (float)Sys_FloatTime ();
|
|
de_time1 = se_time2;
|
|
}
|
|
|
|
R_DrawEntitiesOnList ();
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
de_time2 = (float)Sys_FloatTime ();
|
|
dv_time1 = de_time2;
|
|
}
|
|
|
|
R_DrawViewModel ();
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
dv_time2 = (float)Sys_FloatTime ();
|
|
dp_time1 = (float)Sys_FloatTime ();
|
|
}
|
|
|
|
R_DrawParticles ();
|
|
|
|
if (r_dspeeds.value)
|
|
dp_time2 = (float)Sys_FloatTime ();
|
|
|
|
|
|
if (r_dowarp)
|
|
D_WarpScreen ();
|
|
|
|
|
|
V_SetContentsColor (r_viewleaf->contents);
|
|
|
|
|
|
if (r_timegraph.value)
|
|
R_TimeGraph ();
|
|
|
|
if (r_aliasstats.value)
|
|
R_PrintAliasStats ();
|
|
|
|
if (r_speeds.value)
|
|
R_PrintTimes ();
|
|
|
|
if (r_dspeeds.value)
|
|
R_PrintDSpeeds ();
|
|
|
|
if (r_reportsurfout.value && r_outofsurfaces)
|
|
Con_Printf ("Short %d surfaces\n", r_outofsurfaces);
|
|
|
|
if (r_reportedgeout.value && r_outofedges)
|
|
Con_Printf ("Short roughly %d edges\n", r_outofedges * 2 / 3);
|
|
|
|
// back to high floating-point precision
|
|
// Sys_HighFPPrecision ();
|
|
|
|
}
|
|
|
|
#ifdef USEFPM
|
|
void R_RenderViewFPM_ (void)
|
|
{
|
|
//Dan:
|
|
// byte *warpbuffer=malloc(WARP_WIDTH * WARP_HEIGHT);
|
|
// byte warpbuffer[WARP_WIDTH * WARP_HEIGHT];
|
|
|
|
r_warpbuffer = warpbuffer;
|
|
|
|
if (r_timegraph.value || r_speeds.value || r_dspeeds.value)
|
|
r_time1 = (float)Sys_FloatTime ();
|
|
|
|
// R_SetupFrameFPM (); // FPM doesn't exist
|
|
R_SetupFrame ();
|
|
|
|
#ifdef PASSAGES
|
|
SetVisibilityByPassages ();
|
|
#else
|
|
R_MarkLeavesFPM (); // done here so we know if we're in water
|
|
#endif
|
|
|
|
// make FDIV fast. This reduces timing precision after we've been running for a
|
|
// while, so we don't do it globally. This also sets chop mode, and we do it
|
|
// here so that setup stuff like the refresh area calculations match what's
|
|
// done in screen.c
|
|
Sys_LowFPPrecision ();
|
|
|
|
if (!cl_entitiesFPM[0].model || !clFPM.worldmodel)
|
|
Sys_Error ("R_RenderView: NULL worldmodel");
|
|
|
|
if (!r_dspeeds.value)
|
|
{
|
|
VID_UnlockBuffer ();
|
|
S_ExtraUpdate (); // don't let sound get messed up if going slow
|
|
VID_LockBuffer ();
|
|
}
|
|
|
|
R_EdgeDrawingFPM ();
|
|
|
|
if (!r_dspeeds.value)
|
|
{
|
|
VID_UnlockBuffer ();
|
|
S_ExtraUpdate (); // don't let sound get messed up if going slow
|
|
VID_LockBuffer ();
|
|
}
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
se_time2 = (float)Sys_FloatTime ();
|
|
de_time1 = se_time2;
|
|
}
|
|
|
|
R_DrawEntitiesOnListFPM ();
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
de_time2 = (float)Sys_FloatTime ();
|
|
dv_time1 = de_time2;
|
|
}
|
|
|
|
R_DrawViewModelFPM ();
|
|
|
|
if (r_dspeeds.value)
|
|
{
|
|
dv_time2 = (float)Sys_FloatTime ();
|
|
dp_time1 = (float)Sys_FloatTime ();
|
|
}
|
|
|
|
R_DrawParticlesFPM ();
|
|
|
|
if (r_dspeeds.value)
|
|
dp_time2 = (float)Sys_FloatTime ();
|
|
|
|
if (r_dowarp)
|
|
D_WarpScreen ();
|
|
|
|
V_SetContentsColorFPM (r_viewleafFPM->contents);
|
|
|
|
if (r_timegraph.value)
|
|
//R_TimeGraphFPM (); // FPM doesn't exist
|
|
R_TimeGraph ();
|
|
|
|
if (r_aliasstats.value)
|
|
R_PrintAliasStats ();
|
|
|
|
if (r_speeds.value)
|
|
R_PrintTimes ();
|
|
|
|
if (r_dspeeds.value)
|
|
R_PrintDSpeeds ();
|
|
|
|
if (r_reportsurfout.value && r_outofsurfaces)
|
|
Con_Printf ("Short %d surfaces\n", r_outofsurfaces);
|
|
|
|
if (r_reportedgeout.value && r_outofedges)
|
|
Con_Printf ("Short roughly %d edges\n", r_outofedges * 2 / 3);
|
|
|
|
// back to high floating-point precision
|
|
Sys_HighFPPrecision ();
|
|
}
|
|
#endif //USEFPM
|
|
|
|
void R_RenderView (void)
|
|
{
|
|
int dummy;
|
|
int delta;
|
|
|
|
delta = (byte *)&dummy - r_stack_start;
|
|
if (delta < -10000 || delta > 10000)
|
|
Sys_Error ("R_RenderView: called without enough stack");
|
|
|
|
if ( Hunk_LowMark() & 3 )
|
|
Sys_Error ("Hunk is missaligned");
|
|
|
|
if ( (long)(&dummy) & 3 )
|
|
Sys_Error ("Stack is missaligned");
|
|
|
|
if ( (long)(&r_warpbuffer) & 3 )
|
|
Sys_Error ("Globals are missaligned");
|
|
|
|
R_RenderView_ ();
|
|
}
|
|
|
|
#ifdef USEFPM
|
|
void R_RenderViewFPM (void)
|
|
{
|
|
int dummy;
|
|
int delta;
|
|
|
|
delta = (byte *)&dummy - r_stack_start;
|
|
if (delta < -10000 || delta > 10000)
|
|
Sys_Error ("R_RenderView: called without enough stack");
|
|
|
|
if ( Hunk_LowMark() & 3 )
|
|
Sys_Error ("Hunk is missaligned");
|
|
|
|
if ( (long)(&dummy) & 3 )
|
|
Sys_Error ("Stack is missaligned");
|
|
|
|
if ( (long)(&r_warpbuffer) & 3 )
|
|
Sys_Error ("Globals are missaligned");
|
|
|
|
R_RenderViewFPM_ ();
|
|
}
|
|
#endif //USEFPM
|
|
|
|
/*
|
|
================
|
|
R_InitTurb
|
|
================
|
|
*/
|
|
void R_InitTurb (void)
|
|
{
|
|
int i;
|
|
|
|
for (i=0 ; i<(SIN_BUFFER_SIZE) ; i++)
|
|
{
|
|
sintable[i] = (int)(AMP + sin(i*3.14159*2/CYCLE)*AMP);
|
|
intsintable[i] = (int)(AMP2 + sin(i*3.14159*2/CYCLE)*AMP2); // AMP2, not 20
|
|
}
|
|
}
|
|
|