r_main.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // r_main.c
  21
  22 #include "quakedef.h"
  23 #include "r_local.h"
  24
  25 //define        PASSAGES
  26
  27 void            *colormap;
  28 vec3_t          viewlightvec;
  29 alight_t        r_viewlighting = {128, 192, viewlightvec};
  30 float           r_time1;
  31 int                     r_numallocatededges;
  32 qboolean        r_drawpolys;
  33 qboolean        r_drawculledpolys;
  34 qboolean        r_worldpolysbacktofront;
  35 qboolean        r_recursiveaffinetriangles = true;
  36 int                     r_pixbytes = 1;
  37 float           r_aliasuvscale = 1.0;
  38 int                     r_outofsurfaces;
  39 int                     r_outofedges;
  40
  41 qboolean        r_dowarp, r_dowarpold, r_viewchanged;
  42
  43 int                     numbtofpolys;
  44 btofpoly_t      *pbtofpolys;
  45 mvertex_t       *r_pcurrentvertbase;
  46
  47 int                     c_surf;
  48 int                     r_maxsurfsseen, r_maxedgesseen, r_cnumsurfs;
  49 qboolean        r_surfsonstack;
  50 int                     r_clipflags;
  51
  52 byte            *r_warpbuffer;
  53
  54 byte            *r_stack_start;
  55
  56 qboolean        r_fov_greater_than_90;
  57
  58 //
  59 // view origin
  60 //
  61 vec3_t  vup, base_vup;
  62 vec3_t  vpn, base_vpn;
  63 vec3_t  vright, base_vright;
  64 vec3_t  r_origin;
  65
  66 //
  67 // screen size info
  68 //
  69 refdef_t        r_refdef;
  70 float           xcenter, ycenter;
  71 float           xscale, yscale;
  72 float           xscaleinv, yscaleinv;
  73 float           xscaleshrink, yscaleshrink;
  74 float           aliasxscale, aliasyscale, aliasxcenter, aliasycenter;
  75
  76 int             screenwidth;
  77
  78 float   pixelAspect;
  79 float   screenAspect;
  80 float   verticalFieldOfView;
  81 float   xOrigin, yOrigin;
  82
  83 mplane_t        screenedge[4];
  84
  85 //
  86 // refresh flags
  87 //
  88 int             r_framecount = 1;       // so frame counts initialized to 0 don't match
  89 int             r_visframecount;
  90 int             d_spanpixcount;
  91 int             r_polycount;
  92 int             r_drawnpolycount;
  93 int             r_wholepolycount;
  94
  95 #define         VIEWMODNAME_LENGTH      256
  96 char            viewmodname[VIEWMODNAME_LENGTH+1];
  97 int                     modcount;
  98
  99 int                     *pfrustum_indexes[4];
 100 int                     r_frustum_indexes[4*6];
 101
 102 int             reinit_surfcache = 1;   // if 1, surface cache is currently empty and
 103                                                                 // must be reinitialized for current cache size
 104
 105 mleaf_t         *r_viewleaf, *r_oldviewleaf;
 106
 107 texture_t       *r_notexture_mip;
 108
 109 float           r_aliastransition, r_resfudge;
 110
 111 int             d_lightstylevalue[256]; // 8.8 fraction of base light value
 112
 113 float   dp_time1, dp_time2, db_time1, db_time2, rw_time1, rw_time2;
 114 float   se_time1, se_time2, de_time1, de_time2, dv_time1, dv_time2;
 115
 116 void R_MarkLeaves (void);
 117
 118 cvar_t  r_draworder = {"r_draworder","0"};
 119 cvar_t  r_speeds = {"r_speeds","0"};
 120 cvar_t  r_timegraph = {"r_timegraph","0"};
 121 cvar_t  r_graphheight = {"r_graphheight","10"};
 122 cvar_t  r_clearcolor = {"r_clearcolor","2"};
 123 cvar_t  r_waterwarp = {"r_waterwarp","1"};
 124 cvar_t  r_fullbright = {"r_fullbright","0"};
 125 cvar_t  r_drawentities = {"r_drawentities","1"};
 126 cvar_t  r_drawviewmodel = {"r_drawviewmodel","1"};
 127 cvar_t  r_aliasstats = {"r_polymodelstats","0"};
 128 cvar_t  r_dspeeds = {"r_dspeeds","0"};
 129 cvar_t  r_drawflat = {"r_drawflat", "0"};
 130 cvar_t  r_ambient = {"r_ambient", "0"};
 131 cvar_t  r_reportsurfout = {"r_reportsurfout", "0"};
 132 cvar_t  r_maxsurfs = {"r_maxsurfs", "0"};
 133 cvar_t  r_numsurfs = {"r_numsurfs", "0"};
 134 cvar_t  r_reportedgeout = {"r_reportedgeout", "0"};
 135 cvar_t  r_maxedges = {"r_maxedges", "0"};
 136 cvar_t  r_numedges = {"r_numedges", "0"};
 137 cvar_t  r_aliastransbase = {"r_aliastransbase", "200"};
 138 cvar_t  r_aliastransadj = {"r_aliastransadj", "100"};
 139
 140 extern cvar_t   scr_fov;
 141
 142 void CreatePassages (void);
 143 void SetVisibilityByPassages (void);
 144
 145 /*
 146 ==================
 147 R_InitTextures
 148 ==================
 149 */
 150 void    R_InitTextures (void)
 151 {
 152         int             x,y, m;
 153         byte    *dest;
 154
 155 // create a simple checkerboard texture for the default
 156         r_notexture_mip = Hunk_AllocName (sizeof(texture_t) + 16*16+8*8+4*4+2*2, "notexture");
 157
 158         r_notexture_mip->width = r_notexture_mip->height = 16;
 159         r_notexture_mip->offsets[0] = sizeof(texture_t);
 160         r_notexture_mip->offsets[1] = r_notexture_mip->offsets[0] + 16*16;
 161         r_notexture_mip->offsets[2] = r_notexture_mip->offsets[1] + 8*8;
 162         r_notexture_mip->offsets[3] = r_notexture_mip->offsets[2] + 4*4;
 163
 164         for (m=0 ; m<4 ; m++)
 165         {
 166                 dest = (byte *)r_notexture_mip + r_notexture_mip->offsets[m];
 167                 for (y=0 ; y< (16>>m) ; y++)
 168                         for (x=0 ; x< (16>>m) ; x++)
 169                         {
 170                                 if (  (y< (8>>m) ) ^ (x< (8>>m) ) )
 171                                         *dest++ = 0;
 172                                 else
 173                                         *dest++ = 0xff;
 174                         }
 175         }
 176 }
 177
 178 /*
 179 ===============
 180 R_Init
 181 ===============
 182 */
 183 void R_Init (void)
 184 {
 185         int             dummy;
 186
 187 // get stack position so we can guess if we are going to overflow
 188         r_stack_start = (byte *)&dummy;
 189
 190         R_InitTurb ();
 191
 192         Cmd_AddCommand ("timerefresh", R_TimeRefresh_f);
 193         Cmd_AddCommand ("pointfile", R_ReadPointFile_f);
 194
 195         Cvar_RegisterVariable (&r_draworder);
 196         Cvar_RegisterVariable (&r_speeds);
 197         Cvar_RegisterVariable (&r_timegraph);
 198         Cvar_RegisterVariable (&r_graphheight);
 199         Cvar_RegisterVariable (&r_drawflat);
 200         Cvar_RegisterVariable (&r_ambient);
 201         Cvar_RegisterVariable (&r_clearcolor);
 202         Cvar_RegisterVariable (&r_waterwarp);
 203         Cvar_RegisterVariable (&r_fullbright);
 204         Cvar_RegisterVariable (&r_drawentities);
 205         Cvar_RegisterVariable (&r_drawviewmodel);
 206         Cvar_RegisterVariable (&r_aliasstats);
 207         Cvar_RegisterVariable (&r_dspeeds);
 208         Cvar_RegisterVariable (&r_reportsurfout);
 209         Cvar_RegisterVariable (&r_maxsurfs);
 210         Cvar_RegisterVariable (&r_numsurfs);
 211         Cvar_RegisterVariable (&r_reportedgeout);
 212         Cvar_RegisterVariable (&r_maxedges);
 213         Cvar_RegisterVariable (&r_numedges);
 214         Cvar_RegisterVariable (&r_aliastransbase);
 215         Cvar_RegisterVariable (&r_aliastransadj);
 216
 217         Cvar_SetValue ("r_maxedges", (float)NUMSTACKEDGES);
 218         Cvar_SetValue ("r_maxsurfs", (float)NUMSTACKSURFACES);
 219
 220         view_clipplanes[0].leftedge = true;
 221         view_clipplanes[1].rightedge = true;
 222         view_clipplanes[1].leftedge = view_clipplanes[2].leftedge =
 223                         view_clipplanes[3].leftedge = false;
 224         view_clipplanes[0].rightedge = view_clipplanes[2].rightedge =
 225                         view_clipplanes[3].rightedge = false;
 226
 227         r_refdef.xOrigin = XCENTERING;
 228         r_refdef.yOrigin = YCENTERING;
 229
 230         R_InitParticles ();
 231
 232 // TODO: collect 386-specific code in one place
 233 #if     id386
 234         Sys_MakeCodeWriteable ((long)R_EdgeCodeStart,
 235                                              (long)R_EdgeCodeEnd - (long)R_EdgeCodeStart);
 236 #endif  // id386
 237
 238         D_Init ();
 239 }
 240
 241 /*
 242 ===============
 243 R_NewMap
 244 ===============
 245 */
 246 void R_NewMap (void)
 247 {
 248         int             i;
 249
 250 // clear out efrags in case the level hasn't been reloaded
 251 // FIXME: is this one short?
 252         for (i=0 ; i<cl.worldmodel->numleafs ; i++)
 253                 cl.worldmodel->leafs[i].efrags = NULL;
 254
 255         r_viewleaf = NULL;
 256         R_ClearParticles ();
 257
 258         r_cnumsurfs = r_maxsurfs.value;
 259
 260         if (r_cnumsurfs <= MINSURFACES)
 261                 r_cnumsurfs = MINSURFACES;
 262
 263         if (r_cnumsurfs > NUMSTACKSURFACES)
 264         {
 265                 surfaces = Hunk_AllocName (r_cnumsurfs * sizeof(surf_t), "surfaces");
 266                 surface_p = surfaces;
 267                 surf_max = &surfaces[r_cnumsurfs];
 268                 r_surfsonstack = false;
 269         // surface 0 doesn't really exist; it's just a dummy because index 0
 270         // is used to indicate no edge attached to surface
 271                 surfaces--;
 272                 R_SurfacePatch ();
 273         }
 274         else
 275         {
 276                 r_surfsonstack = true;
 277         }
 278
 279         r_maxedgesseen = 0;
 280         r_maxsurfsseen = 0;
 281
 282         r_numallocatededges = r_maxedges.value;
 283
 284         if (r_numallocatededges < MINEDGES)
 285                 r_numallocatededges = MINEDGES;
 286
 287         if (r_numallocatededges <= NUMSTACKEDGES)
 288         {
 289                 auxedges = NULL;
 290         }
 291         else
 292         {
 293                 auxedges = Hunk_AllocName (r_numallocatededges * sizeof(edge_t),
 294                                                                    "edges");
 295         }
 296
 297         r_dowarpold = false;
 298         r_viewchanged = false;
 299 #ifdef PASSAGES
 300 CreatePassages ();
 301 #endif
 302 }
 303
 304
 305 /*
 306 ===============
 307 R_SetVrect
 308 ===============
 309 */
 310 void R_SetVrect (vrect_t *pvrectin, vrect_t *pvrect, int lineadj)
 311 {
 312         int             h;
 313         float   size;
 314
 315         size = scr_viewsize.value > 100 ? 100 : scr_viewsize.value;
 316         if (cl.intermission)
 317         {
 318                 size = 100;
 319                 lineadj = 0;
 320         }
 321         size /= 100;
 322
 323         h = pvrectin->height - lineadj;
 324         pvrect->width = pvrectin->width * size;
 325         if (pvrect->width < 96)
 326         {
 327                 size = 96.0 / pvrectin->width;
 328                 pvrect->width = 96;     // min for icons
 329         }
 330         pvrect->width &= ~7;
 331         pvrect->height = pvrectin->height * size;
 332         if (pvrect->height > pvrectin->height - lineadj)
 333                 pvrect->height = pvrectin->height - lineadj;
 334
 335         pvrect->height &= ~1;
 336
 337         pvrect->x = (pvrectin->width - pvrect->width)/2;
 338         pvrect->y = (h - pvrect->height)/2;
 339
 340         {
 341                 if (lcd_x.value)
 342                 {
 343                         pvrect->y >>= 1;
 344                         pvrect->height >>= 1;
 345                 }
 346         }
 347 }
 348
 349
 350 /*
 351 ===============
 352 R_ViewChanged
 353
 354 Called every time the vid structure or r_refdef changes.
 355 Guaranteed to be called before the first refresh
 356 ===============
 357 */
 358 void R_ViewChanged (vrect_t *pvrect, int lineadj, float aspect)
 359 {
 360         int             i;
 361         float   res_scale;
 362
 363         r_viewchanged = true;
 364
 365         R_SetVrect (pvrect, &r_refdef.vrect, lineadj);
 366
 367         r_refdef.horizontalFieldOfView = 2.0 * tanf (r_refdef.fov_x/360*M_PI);
 368         r_refdef.fvrectx = (float)r_refdef.vrect.x;
 369         r_refdef.fvrectx_adj = (float)r_refdef.vrect.x - 0.5;
 370         r_refdef.vrect_x_adj_shift20 = (r_refdef.vrect.x<<20) + (1<<19) - 1;
 371         r_refdef.fvrecty = (float)r_refdef.vrect.y;
 372         r_refdef.fvrecty_adj = (float)r_refdef.vrect.y - 0.5;
 373         r_refdef.vrectright = r_refdef.vrect.x + r_refdef.vrect.width;
 374         r_refdef.vrectright_adj_shift20 = (r_refdef.vrectright<<20) + (1<<19) - 1;
 375         r_refdef.fvrectright = (float)r_refdef.vrectright;
 376         r_refdef.fvrectright_adj = (float)r_refdef.vrectright - 0.5;
 377         r_refdef.vrectrightedge = (float)r_refdef.vrectright - 0.99;
 378         r_refdef.vrectbottom = r_refdef.vrect.y + r_refdef.vrect.height;
 379         r_refdef.fvrectbottom = (float)r_refdef.vrectbottom;
 380         r_refdef.fvrectbottom_adj = (float)r_refdef.vrectbottom - 0.5;
 381
 382         r_refdef.aliasvrect.x = (int)(r_refdef.vrect.x * r_aliasuvscale);
 383         r_refdef.aliasvrect.y = (int)(r_refdef.vrect.y * r_aliasuvscale);
 384         r_refdef.aliasvrect.width = (int)(r_refdef.vrect.width * r_aliasuvscale);
 385         r_refdef.aliasvrect.height = (int)(r_refdef.vrect.height * r_aliasuvscale);
 386         r_refdef.aliasvrectright = r_refdef.aliasvrect.x +
 387                         r_refdef.aliasvrect.width;
 388         r_refdef.aliasvrectbottom = r_refdef.aliasvrect.y +
 389                         r_refdef.aliasvrect.height;
 390
 391         pixelAspect = aspect;
 392         xOrigin = r_refdef.xOrigin;
 393         yOrigin = r_refdef.yOrigin;
 394
 395         screenAspect = r_refdef.vrect.width*pixelAspect /
 396                         r_refdef.vrect.height;
 397 // 320*200 1.0 pixelAspect = 1.6 screenAspect
 398 // 320*240 1.0 pixelAspect = 1.3333 screenAspect
 399 // proper 320*200 pixelAspect = 0.8333333
 400
 401         verticalFieldOfView = r_refdef.horizontalFieldOfView / screenAspect;
 402
 403 // values for perspective projection
 404 // if math were exact, the values would range from 0.5 to to range+0.5
 405 // hopefully they wll be in the 0.000001 to range+.999999 and truncate
 406 // the polygon rasterization will never render in the first row or column
 407 // but will definately render in the [range] row and column, so adjust the
 408 // buffer origin to get an exact edge to edge fill
 409         xcenter = ((float)r_refdef.vrect.width * XCENTERING) +
 410                         r_refdef.vrect.x - 0.5;
 411         aliasxcenter = xcenter * r_aliasuvscale;
 412         ycenter = ((float)r_refdef.vrect.height * YCENTERING) +
 413                         r_refdef.vrect.y - 0.5;
 414         aliasycenter = ycenter * r_aliasuvscale;
 415
 416         xscale = r_refdef.vrect.width / r_refdef.horizontalFieldOfView;
 417         aliasxscale = xscale * r_aliasuvscale;
 418         xscaleinv = 1.0 / xscale;
 419         yscale = xscale * pixelAspect;
 420         aliasyscale = yscale * r_aliasuvscale;
 421         yscaleinv = 1.0 / yscale;
 422         xscaleshrink = (r_refdef.vrect.width-6)/r_refdef.horizontalFieldOfView;
 423         yscaleshrink = xscaleshrink*pixelAspect;
 424
 425 // left side clip
 426         screenedge[0].normal[0] = -1.0 / (xOrigin*r_refdef.horizontalFieldOfView);
 427         screenedge[0].normal[1] = 0;
 428         screenedge[0].normal[2] = 1;
 429         screenedge[0].type = PLANE_ANYZ;
 430
 431 // right side clip
 432         screenedge[1].normal[0] =
 433                         1.0 / ((1.0-xOrigin)*r_refdef.horizontalFieldOfView);
 434         screenedge[1].normal[1] = 0;
 435         screenedge[1].normal[2] = 1;
 436         screenedge[1].type = PLANE_ANYZ;
 437
 438 // top side clip
 439         screenedge[2].normal[0] = 0;
 440         screenedge[2].normal[1] = -1.0 / (yOrigin*verticalFieldOfView);
 441         screenedge[2].normal[2] = 1;
 442         screenedge[2].type = PLANE_ANYZ;
 443
 444 // bottom side clip
 445         screenedge[3].normal[0] = 0;
 446         screenedge[3].normal[1] = 1.0 / ((1.0-yOrigin)*verticalFieldOfView);
 447         screenedge[3].normal[2] = 1;
 448         screenedge[3].type = PLANE_ANYZ;
 449
 450         for (i=0 ; i<4 ; i++)
 451                 VectorNormalize (screenedge[i].normal);
 452
 453         res_scale = sqrtf ((float)(r_refdef.vrect.width * r_refdef.vrect.height) /
 454                                   (320.0 * 152.0)) *
 455                         (2.0 / r_refdef.horizontalFieldOfView);
 456         r_aliastransition = r_aliastransbase.value * res_scale;
 457         r_resfudge = r_aliastransadj.value * res_scale;
 458
 459         if (scr_fov.value <= 90.0)
 460                 r_fov_greater_than_90 = false;
 461         else
 462                 r_fov_greater_than_90 = true;
 463
 464 // TODO: collect 386-specific code in one place
 465 #if     id386
 466         if (r_pixbytes == 1)
 467         {
 468                 Sys_MakeCodeWriteable ((long)R_Surf8Start,
 469                                                      (long)R_Surf8End - (long)R_Surf8Start);
 470                 colormap = vid.colormap;
 471                 R_Surf8Patch ();
 472         }
 473         else
 474         {
 475                 Sys_MakeCodeWriteable ((long)R_Surf16Start,
 476                                                      (long)R_Surf16End - (long)R_Surf16Start);
 477                 colormap = vid.colormap16;
 478                 R_Surf16Patch ();
 479         }
 480 #endif  // id386
 481
 482         D_ViewChanged ();
 483 }
 484
 485
 486 /*
 487 ===============
 488 R_MarkLeaves
 489 ===============
 490 */
 491 void R_MarkLeaves (void)
 492 {
 493         byte    *vis;
 494         mnode_t *node;
 495         int             i;
 496
 497         if (r_oldviewleaf == r_viewleaf)
 498                 return;
 499
 500         r_visframecount++;
 501         r_oldviewleaf = r_viewleaf;
 502
 503         vis = Mod_LeafPVS (r_viewleaf, cl.worldmodel);
 504
 505         for (i=0 ; i<cl.worldmodel->numleafs ; i++)
 506         {
 507                 if (vis[i>>3] & (1<<(i&7)))
 508                 {
 509                         node = (mnode_t *)&cl.worldmodel->leafs[i+1];
 510                         do
 511                         {
 512                                 if (node->visframe == r_visframecount)
 513                                         break;
 514                                 node->visframe = r_visframecount;
 515                                 node = node->parent;
 516                         } while (node);
 517                 }
 518         }
 519 }
 520
 521
 522 /*
 523 =============
 524 R_DrawEntitiesOnList
 525 =============
 526 */
 527 void R_DrawEntitiesOnList (void)
 528 {
 529         int                     i, j;
 530         int                     lnum;
 531         alight_t        lighting;
 532 // FIXME: remove and do real lighting
 533         float           lightvec[3] = {-1, 0, 0};
 534         vec3_t          dist;
 535         float           add;
 536
 537         if (!r_drawentities.value)
 538                 return;
 539
 540         for (i=0 ; i<cl_numvisedicts ; i++)
 541         {
 542                 currententity = cl_visedicts[i];
 543
 544                 if (currententity == &cl_entities[cl.viewentity])
 545                         continue;       // don't draw the player
 546
 547                 switch (currententity->model->type)
 548                 {
 549                 case mod_sprite:
 550                         VectorCopy (currententity->origin, r_entorigin);
 551                         VectorSubtract (r_origin, r_entorigin, modelorg);
 552                         R_DrawSprite ();
 553                         break;
 554
 555                 case mod_alias:
 556                         VectorCopy (currententity->origin, r_entorigin);
 557                         VectorSubtract (r_origin, r_entorigin, modelorg);
 558
 559                 // see if the bounding box lets us trivially reject, also sets
 560                 // trivial accept status
 561                         if (R_AliasCheckBBox ())
 562                         {
 563                                 j = R_LightPoint (currententity->origin);
 564
 565                                 lighting.ambientlight = j;
 566                                 lighting.shadelight = j;
 567
 568                                 lighting.plightvec = lightvec;
 569
 570                                 for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
 571                                 {
 572                                         if (cl_dlights[lnum].die >= cl.time)
 573                                         {
 574                                                 VectorSubtract (currententity->origin,
 575                                                                                 cl_dlights[lnum].origin,
 576                                                                                 dist);
 577                                                 add = cl_dlights[lnum].radius - Length(dist);
 578
 579                                                 if (add > 0)
 580                                                         lighting.ambientlight += add;
 581                                         }
 582                                 }
 583
 584                         // clamp lighting so it doesn't overbright as much
 585                                 if (lighting.ambientlight > 128)
 586                                         lighting.ambientlight = 128;
 587                                 if (lighting.ambientlight + lighting.shadelight > 192)
 588                                         lighting.shadelight = 192 - lighting.ambientlight;
 589
 590                                 R_AliasDrawModel (&lighting);
 591                         }
 592
 593                         break;
 594
 595                 default:
 596                         break;
 597                 }
 598         }
 599 }
 600
 601 /*
 602 =============
 603 R_DrawViewModel
 604 =============
 605 */
 606 void R_DrawViewModel (void)
 607 {
 608 // FIXME: remove and do real lighting
 609         float           lightvec[3] = {-1, 0, 0};
 610         int                     j;
 611         int                     lnum;
 612         vec3_t          dist;
 613         float           add;
 614         dlight_t        *dl;
 615
 616         if (!r_drawviewmodel.value || r_fov_greater_than_90)
 617                 return;
 618
 619         if (cl.items & IT_INVISIBILITY)
 620                 return;
 621
 622         if (cl.stats[STAT_HEALTH] <= 0)
 623                 return;
 624
 625         currententity = &cl.viewent;
 626         if (!currententity->model)
 627                 return;
 628
 629         VectorCopy (currententity->origin, r_entorigin);
 630         VectorSubtract (r_origin, r_entorigin, modelorg);
 631
 632         VectorCopy (vup, viewlightvec);
 633         VectorInverse (viewlightvec);
 634
 635         j = R_LightPoint (currententity->origin);
 636
 637         if (j < 24)
 638                 j = 24;         // allways give some light on gun
 639         r_viewlighting.ambientlight = j;
 640         r_viewlighting.shadelight = j;
 641
 642 // add dynamic lights
 643         for (lnum=0 ; lnum<MAX_DLIGHTS ; lnum++)
 644         {
 645                 dl = &cl_dlights[lnum];
 646                 if (!dl->radius)
 647                         continue;
 648                 if (!dl->radius)
 649                         continue;
 650                 if (dl->die < cl.time)
 651                         continue;
 652
 653                 VectorSubtract (currententity->origin, dl->origin, dist);
 654                 add = dl->radius - Length(dist);
 655                 if (add > 0)
 656                         r_viewlighting.ambientlight += add;
 657         }
 658
 659 // clamp lighting so it doesn't overbright as much
 660         if (r_viewlighting.ambientlight > 128)
 661                 r_viewlighting.ambientlight = 128;
 662         if (r_viewlighting.ambientlight + r_viewlighting.shadelight > 192)
 663                 r_viewlighting.shadelight = 192 - r_viewlighting.ambientlight;
 664
 665         r_viewlighting.plightvec = lightvec;
 666
 667 #ifdef QUAKE2
 668         cl.light_level = r_viewlighting.ambientlight;
 669 #endif
 670
 671         R_AliasDrawModel (&r_viewlighting);
 672 }
 673
 674
 675 /*
 676 =============
 677 R_BmodelCheckBBox
 678 =============
 679 */
 680 int R_BmodelCheckBBox (model_t *clmodel, float *minmaxs)
 681 {
 682         int                     i, *pindex, clipflags;
 683         vec3_t          acceptpt, rejectpt;
 684         float           d;
 685
 686         clipflags = 0;
 687
 688         if (currententity->angles[0] || currententity->angles[1]
 689                 || currententity->angles[2])
 690         {
 691                 for (i=0 ; i<4 ; i++)
 692                 {
 693                         d = DotProduct (currententity->origin, view_clipplanes[i].normal);
 694                         d -= view_clipplanes[i].dist;
 695
 696                         if (d <= -clmodel->radius)
 697                                 return BMODEL_FULLY_CLIPPED;
 698
 699                         if (d <= clmodel->radius)
 700                                 clipflags |= (1<<i);
 701                 }
 702         }
 703         else
 704         {
 705                 for (i=0 ; i<4 ; i++)
 706                 {
 707                 // generate accept and reject points
 708                 // FIXME: do with fast look-ups or integer tests based on the sign bit
 709                 // of the floating point values
 710
 711                         pindex = pfrustum_indexes[i];
 712
 713                         rejectpt[0] = minmaxs[pindex[0]];
 714                         rejectpt[1] = minmaxs[pindex[1]];
 715                         rejectpt[2] = minmaxs[pindex[2]];
 716
 717                         d = DotProduct (rejectpt, view_clipplanes[i].normal);
 718                         d -= view_clipplanes[i].dist;
 719
 720                         if (d <= 0)
 721                                 return BMODEL_FULLY_CLIPPED;
 722
 723                         acceptpt[0] = minmaxs[pindex[3+0]];
 724                         acceptpt[1] = minmaxs[pindex[3+1]];
 725                         acceptpt[2] = minmaxs[pindex[3+2]];
 726
 727                         d = DotProduct (acceptpt, view_clipplanes[i].normal);
 728                         d -= view_clipplanes[i].dist;
 729
 730                         if (d <= 0)
 731                                 clipflags |= (1<<i);
 732                 }
 733         }
 734
 735         return clipflags;
 736 }
 737
 738
 739 /*
 740 =============
 741 R_DrawBEntitiesOnList
 742 =============
 743 */
 744 void R_DrawBEntitiesOnList (void)
 745 {
 746         int                     i, j, k, clipflags;
 747         vec3_t          oldorigin;
 748         model_t         *clmodel;
 749         float           minmaxs[6];
 750
 751         if (!r_drawentities.value)
 752                 return;
 753
 754         VectorCopy (modelorg, oldorigin);
 755         insubmodel = true;
 756         r_dlightframecount = r_framecount;
 757
 758         for (i=0 ; i<cl_numvisedicts ; i++)
 759         {
 760                 currententity = cl_visedicts[i];
 761
 762                 switch (currententity->model->type)
 763                 {
 764                 case mod_brush:
 765
 766                         clmodel = currententity->model;
 767
 768                 // see if the bounding box lets us trivially reject, also sets
 769                 // trivial accept status
 770                         for (j=0 ; j<3 ; j++)
 771                         {
 772                                 minmaxs[j] = currententity->origin[j] +
 773                                                 clmodel->mins[j];
 774                                 minmaxs[3+j] = currententity->origin[j] +
 775                                                 clmodel->maxs[j];
 776                         }
 777
 778                         clipflags = R_BmodelCheckBBox (clmodel, minmaxs);
 779
 780                         if (clipflags != BMODEL_FULLY_CLIPPED)
 781                         {
 782                                 VectorCopy (currententity->origin, r_entorigin);
 783                                 VectorSubtract (r_origin, r_entorigin, modelorg);
 784                         // FIXME: is this needed?
 785                                 VectorCopy (modelorg, r_worldmodelorg);
 786
 787                                 r_pcurrentvertbase = clmodel->vertexes;
 788
 789                         // FIXME: stop transforming twice
 790                                 R_RotateBmodel ();
 791
 792                         // calculate dynamic lighting for bmodel if it's not an
 793                         // instanced model
 794                                 if (clmodel->firstmodelsurface != 0)
 795                                 {
 796                                         for (k=0 ; k<MAX_DLIGHTS ; k++)
 797                                         {
 798                                                 if ((cl_dlights[k].die < cl.time) ||
 799                                                         (!cl_dlights[k].radius))
 800                                                 {
 801                                                         continue;
 802                                                 }
 803
 804                                                 R_MarkLights (&cl_dlights[k], 1<<k,
 805                                                         clmodel->nodes + clmodel->hulls[0].firstclipnode);
 806                                         }
 807                                 }
 808
 809                         // if the driver wants polygons, deliver those. Z-buffering is on
 810                         // at this point, so no clipping to the world tree is needed, just
 811                         // frustum clipping
 812                                 if (r_drawpolys | r_drawculledpolys)
 813                                 {
 814                                         R_ZDrawSubmodelPolys (clmodel);
 815                                 }
 816                                 else
 817                                 {
 818                                         r_pefragtopnode = NULL;
 819
 820                                         for (j=0 ; j<3 ; j++)
 821                                         {
 822                                                 r_emins[j] = minmaxs[j];
 823                                                 r_emaxs[j] = minmaxs[3+j];
 824                                         }
 825
 826                                         R_SplitEntityOnNode2 (cl.worldmodel->nodes);
 827
 828                                         if (r_pefragtopnode)
 829                                         {
 830                                                 currententity->topnode = r_pefragtopnode;
 831
 832                                                 if (r_pefragtopnode->contents >= 0)
 833                                                 {
 834                                                 // not a leaf; has to be clipped to the world BSP
 835                                                         r_clipflags = clipflags;
 836                                                         R_DrawSolidClippedSubmodelPolygons (clmodel);
 837                                                 }
 838                                                 else
 839                                                 {
 840                                                 // falls entirely in one leaf, so we just put all the
 841                                                 // edges in the edge list and let 1/z sorting handle
 842                                                 // drawing order
 843                                                         R_DrawSubmodelPolygons (clmodel, clipflags);
 844                                                 }
 845
 846                                                 currententity->topnode = NULL;
 847                                         }
 848                                 }
 849
 850                         // put back world rotation and frustum clipping
 851                         // FIXME: R_RotateBmodel should just work off base_vxx
 852                                 VectorCopy (base_vpn, vpn);
 853                                 VectorCopy (base_vup, vup);
 854                                 VectorCopy (base_vright, vright);
 855                                 VectorCopy (base_modelorg, modelorg);
 856                                 VectorCopy (oldorigin, modelorg);
 857                                 R_TransformFrustum ();
 858                         }
 859
 860                         break;
 861
 862                 default:
 863                         break;
 864                 }
 865         }
 866
 867         insubmodel = false;
 868 }
 869
 870
 871 /*
 872 ================
 873 R_EdgeDrawing
 874 ================
 875 */
 876 void R_EdgeDrawing (void)
 877 {
 878         edge_t  ledges[NUMSTACKEDGES +
 879                                 ((CACHE_SIZE - 1) / sizeof(edge_t)) + 1];
 880         surf_t  lsurfs[NUMSTACKSURFACES +
 881                                 ((CACHE_SIZE - 1) / sizeof(surf_t)) + 1];
 882
 883         if (auxedges)
 884         {
 885                 r_edges = auxedges;
 886         }
 887         else
 888         {
 889                 r_edges =  (edge_t *)
 890                                 (((long)&ledges[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
 891         }
 892
 893         if (r_surfsonstack)
 894         {
 895                 surfaces =  (surf_t *)
 896                                 (((long)&lsurfs[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
 897                 surf_max = &surfaces[r_cnumsurfs];
 898         // surface 0 doesn't really exist; it's just a dummy because index 0
 899         // is used to indicate no edge attached to surface
 900                 surfaces--;
 901                 R_SurfacePatch ();
 902         }
 903
 904         R_BeginEdgeFrame ();
 905
 906         if (r_dspeeds.value)
 907         {
 908                 rw_time1 = Sys_FloatTime ();
 909         }
 910
 911         R_RenderWorld ();
 912
 913         if (r_drawculledpolys)
 914                 R_ScanEdges ();
 915
 916 // only the world can be drawn back to front with no z reads or compares, just
 917 // z writes, so have the driver turn z compares on now
 918         D_TurnZOn ();
 919
 920         if (r_dspeeds.value)
 921         {
 922                 rw_time2 = Sys_FloatTime ();
 923                 db_time1 = rw_time2;
 924         }
 925
 926         R_DrawBEntitiesOnList ();
 927
 928         if (r_dspeeds.value)
 929         {
 930                 db_time2 = Sys_FloatTime ();
 931                 se_time1 = db_time2;
 932         }
 933
 934         if (!r_dspeeds.value)
 935         {
 936                 VID_UnlockBuffer ();
 937                 S_ExtraUpdate ();       // don't let sound get messed up if going slow
 938                 VID_LockBuffer ();
 939         }
 940
 941         if (!(r_drawpolys | r_drawculledpolys))
 942                 R_ScanEdges ();
 943 }
 944
 945
 946 /*
 947 ================
 948 R_RenderView
 949
 950 r_refdef must be set before the first call
 951 ================
 952 */
 953 void R_RenderView_ (void)
 954 {
 955         byte    warpbuffer[WARP_WIDTH * WARP_HEIGHT];
 956
 957         r_warpbuffer = warpbuffer;
 958
 959         if (r_timegraph.value || r_speeds.value || r_dspeeds.value)
 960                 r_time1 = Sys_FloatTime ();
 961
 962         R_SetupFrame ();
 963
 964 #ifdef PASSAGES
 965 SetVisibilityByPassages ();
 966 #else
 967         R_MarkLeaves ();        // done here so we know if we're in water
 968 #endif
 969
 970 // make FDIV fast. This reduces timing precision after we've been running for a
 971 // while, so we don't do it globally.  This also sets chop mode, and we do it
 972 // here so that setup stuff like the refresh area calculations match what's
 973 // done in screen.c
 974         Sys_LowFPPrecision ();
 975
 976         if (!cl_entities[0].model || !cl.worldmodel)
 977                 Sys_Error ("R_RenderView: NULL worldmodel");
 978
 979         if (!r_dspeeds.value)
 980         {
 981                 VID_UnlockBuffer ();
 982                 S_ExtraUpdate ();       // don't let sound get messed up if going slow
 983                 VID_LockBuffer ();
 984         }
 985
 986         R_EdgeDrawing ();
 987
 988         if (!r_dspeeds.value)
 989         {
 990                 VID_UnlockBuffer ();
 991                 S_ExtraUpdate ();       // don't let sound get messed up if going slow
 992                 VID_LockBuffer ();
 993         }
 994
 995         if (r_dspeeds.value)
 996         {
 997                 se_time2 = Sys_FloatTime ();
 998                 de_time1 = se_time2;
 999         }
1000
1001         R_DrawEntitiesOnList ();
1002
1003         if (r_dspeeds.value)
1004         {
1005                 de_time2 = Sys_FloatTime ();
1006                 dv_time1 = de_time2;
1007         }
1008
1009         R_DrawViewModel ();
1010
1011         if (r_dspeeds.value)
1012         {
1013                 dv_time2 = Sys_FloatTime ();
1014                 dp_time1 = Sys_FloatTime ();
1015         }
1016
1017         R_DrawParticles ();
1018
1019         if (r_dspeeds.value)
1020                 dp_time2 = Sys_FloatTime ();
1021
1022         if (r_dowarp)
1023                 D_WarpScreen ();
1024
1025         V_SetContentsColor (r_viewleaf->contents);
1026
1027         if (r_timegraph.value)
1028                 R_TimeGraph ();
1029
1030         if (r_aliasstats.value)
1031                 R_PrintAliasStats ();
1032
1033         if (r_speeds.value)
1034                 R_PrintTimes ();
1035
1036         if (r_dspeeds.value)
1037                 R_PrintDSpeeds ();
1038
1039         if (r_reportsurfout.value && r_outofsurfaces)
1040                 Con_Printf ("Short %d surfaces\n", r_outofsurfaces);
1041
1042         if (r_reportedgeout.value && r_outofedges)
1043                 Con_Printf ("Short roughly %d edges\n", r_outofedges * 2 / 3);
1044
1045 // back to high floating-point precision
1046         Sys_HighFPPrecision ();
1047 }
1048
1049 void R_RenderView (void)
1050 {
1051         int             dummy;
1052         int             delta;
1053
1054         delta = (byte *)&dummy - r_stack_start;
1055         if (delta < -10000 || delta > 10000)
1056                 Sys_Error ("R_RenderView: called without enough stack");
1057
1058         if ( Hunk_LowMark() & 3 )
1059                 Sys_Error ("Hunk is missaligned");
1060
1061         if ( (long)(&dummy) & 3 )
1062                 Sys_Error ("Stack is missaligned");
1063
1064         if ( (long)(&r_warpbuffer) & 3 )
1065                 Sys_Error ("Globals are missaligned");
1066
1067         R_RenderView_ ();
1068 }
1069
1070 /*
1071 ================
1072 R_InitTurb
1073 ================
1074 */
1075 void R_InitTurb (void)
1076 {
1077         int             i;
1078
1079         for (i=0 ; i<(SIN_BUFFER_SIZE) ; i++)
1080         {
1081                 sintable[i] = AMP + sinf(i*3.14159*2/CYCLE)*AMP;
1082                 intsintable[i] = AMP2 + sinf(i*3.14159*2/CYCLE)*AMP2;   // AMP2, not 20
1083         }
1084 }
1085