Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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 * tan (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 = sqrt ((double)(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.         double          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 + sin(i*3.14159*2/CYCLE)*AMP;
  1082.                 intsintable[i] = AMP2 + sin(i*3.14159*2/CYCLE)*AMP2;    // AMP2, not 20
  1083.         }
  1084. }
  1085.  
  1086.