Subversion Repositories Kolibri OS

Rev

Rev 298 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. // Emacs style mode select   -*- C++ -*-
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //      Rendering main loop and setup functions,
  21. //       utility functions (BSP, geometry, trigonometry).
  22. //      See tables.c, too.
  23. //
  24. //-----------------------------------------------------------------------------
  25.  
  26.  
  27. //static const char rcsid[] = "$Id: r_main.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
  28.  
  29.  
  30.  
  31. #include <stdlib.h>
  32. #include <math.h>
  33.  
  34.  
  35. #include "doomdef.h"
  36. #include "d_net.h"
  37.  
  38. #include "m_bbox.h"
  39.  
  40. #include "r_local.h"
  41. #include "r_sky.h"
  42.  
  43.  
  44.  
  45.  
  46.  
  47. // Fineangles in the SCREENWIDTH wide window.
  48. #define FIELDOFVIEW             2048    
  49.  
  50.  
  51.  
  52. int                     viewangleoffset;
  53.  
  54. // increment every time a check is made
  55. int                     validcount = 1;        
  56.  
  57.  
  58. lighttable_t*           fixedcolormap;
  59. extern lighttable_t**   walllights;
  60.  
  61. int                     centerx;
  62. int                     centery;
  63.  
  64. fixed_t                 centerxfrac;
  65. fixed_t                 centeryfrac;
  66. fixed_t                 projection;
  67.  
  68. // just for profiling purposes
  69. int                     framecount;    
  70.  
  71. int                     sscount;
  72. int                     linecount;
  73. int                     loopcount;
  74.  
  75. fixed_t                 viewx;
  76. fixed_t                 viewy;
  77. fixed_t                 viewz;
  78.  
  79. angle_t                 viewangle;
  80.  
  81. fixed_t                 viewcos;
  82. fixed_t                 viewsin;
  83.  
  84. player_t*               viewplayer;
  85.  
  86. // 0 = high, 1 = low
  87. int                     detailshift;    
  88.  
  89. //
  90. // precalculated math tables
  91. //
  92. angle_t                 clipangle;
  93.  
  94. // The viewangletox[viewangle + FINEANGLES/4] lookup
  95. // maps the visible view angles to screen X coordinates,
  96. // flattening the arc to a flat projection plane.
  97. // There will be many angles mapped to the same X.
  98. int                     viewangletox[FINEANGLES/2];
  99.  
  100. // The xtoviewangleangle[] table maps a screen pixel
  101. // to the lowest viewangle that maps back to x ranges
  102. // from clipangle to -clipangle.
  103. angle_t                 xtoviewangle[SCREENWIDTH+1];
  104.  
  105.  
  106. // UNUSED.
  107. // The finetangentgent[angle+FINEANGLES/4] table
  108. // holds the fixed_t tangent values for view angles,
  109. // ranging from MININT to 0 to MAXINT.
  110. // fixed_t              finetangent[FINEANGLES/2];
  111.  
  112. // fixed_t              finesine[5*FINEANGLES/4];
  113. fixed_t*                finecosine = &finesine[FINEANGLES/4];
  114.  
  115.  
  116. lighttable_t*           scalelight[LIGHTLEVELS][MAXLIGHTSCALE];
  117. lighttable_t*           scalelightfixed[MAXLIGHTSCALE];
  118. lighttable_t*           zlight[LIGHTLEVELS][MAXLIGHTZ];
  119.  
  120. // bumped light from gun blasts
  121. int                     extralight;                    
  122.  
  123.  
  124.  
  125. void (*colfunc) (void);
  126. void (*basecolfunc) (void);
  127. void (*fuzzcolfunc) (void);
  128. void (*transcolfunc) (void);
  129. void (*spanfunc) (void);
  130.  
  131.  
  132.  
  133. //
  134. // R_AddPointToBox
  135. // Expand a given bbox
  136. // so that it encloses a given point.
  137. //
  138. void
  139. R_AddPointToBox
  140. ( int           x,
  141.   int           y,
  142.   fixed_t*      box )
  143. {
  144.     if (x< box[BOXLEFT])
  145.         box[BOXLEFT] = x;
  146.     if (x> box[BOXRIGHT])
  147.         box[BOXRIGHT] = x;
  148.     if (y< box[BOXBOTTOM])
  149.         box[BOXBOTTOM] = y;
  150.     if (y> box[BOXTOP])
  151.         box[BOXTOP] = y;
  152. }
  153.  
  154.  
  155. //
  156. // R_PointOnSide
  157. // Traverse BSP (sub) tree,
  158. //  check point against partition plane.
  159. // Returns side 0 (front) or 1 (back).
  160. //
  161. int
  162. R_PointOnSide
  163. ( fixed_t       x,
  164.   fixed_t       y,
  165.   node_t*       node )
  166. {
  167.     fixed_t     dx;
  168.     fixed_t     dy;
  169.     fixed_t     left;
  170.     fixed_t     right;
  171.        
  172.     if (!node->dx)
  173.     {
  174.         if (x <= node->x)
  175.             return node->dy > 0;
  176.        
  177.         return node->dy < 0;
  178.     }
  179.     if (!node->dy)
  180.     {
  181.         if (y <= node->y)
  182.             return node->dx < 0;
  183.        
  184.         return node->dx > 0;
  185.     }
  186.        
  187.     dx = (x - node->x);
  188.     dy = (y - node->y);
  189.        
  190.     // Try to quickly decide by looking at sign bits.
  191.     if ( (node->dy ^ node->dx ^ dx ^ dy)&0x80000000 )
  192.     {
  193.         if  ( (node->dy ^ dx) & 0x80000000 )
  194.         {
  195.             // (left is negative)
  196.             return 1;
  197.         }
  198.         return 0;
  199.     }
  200.  
  201.     left = FixedMul ( node->dy>>FRACBITS , dx );
  202.     right = FixedMul ( dy , node->dx>>FRACBITS );
  203.        
  204.     if (right < left)
  205.     {
  206.         // front side
  207.         return 0;
  208.     }
  209.     // back side
  210.     return 1;                  
  211. }
  212.  
  213.  
  214. int
  215. R_PointOnSegSide
  216. ( fixed_t       x,
  217.   fixed_t       y,
  218.   seg_t*        line )
  219. {
  220.     fixed_t     lx;
  221.     fixed_t     ly;
  222.     fixed_t     ldx;
  223.     fixed_t     ldy;
  224.     fixed_t     dx;
  225.     fixed_t     dy;
  226.     fixed_t     left;
  227.     fixed_t     right;
  228.        
  229.     lx = line->v1->x;
  230.     ly = line->v1->y;
  231.        
  232.     ldx = line->v2->x - lx;
  233.     ldy = line->v2->y - ly;
  234.        
  235.     if (!ldx)
  236.     {
  237.         if (x <= lx)
  238.             return ldy > 0;
  239.        
  240.         return ldy < 0;
  241.     }
  242.     if (!ldy)
  243.     {
  244.         if (y <= ly)
  245.             return ldx < 0;
  246.        
  247.         return ldx > 0;
  248.     }
  249.        
  250.     dx = (x - lx);
  251.     dy = (y - ly);
  252.        
  253.     // Try to quickly decide by looking at sign bits.
  254.     if ( (ldy ^ ldx ^ dx ^ dy)&0x80000000 )
  255.     {
  256.         if  ( (ldy ^ dx) & 0x80000000 )
  257.         {
  258.             // (left is negative)
  259.             return 1;
  260.         }
  261.         return 0;
  262.     }
  263.  
  264.     left = FixedMul ( ldy>>FRACBITS , dx );
  265.     right = FixedMul ( dy , ldx>>FRACBITS );
  266.        
  267.     if (right < left)
  268.     {
  269.         // front side
  270.         return 0;
  271.     }
  272.     // back side
  273.     return 1;                  
  274. }
  275.  
  276.  
  277. //
  278. // R_PointToAngle
  279. // To get a global angle from cartesian coordinates,
  280. //  the coordinates are flipped until they are in
  281. //  the first octant of the coordinate system, then
  282. //  the y (<=x) is scaled and divided by x to get a
  283. //  tangent (slope) value which is looked up in the
  284. //  tantoangle[] table.
  285.  
  286. //
  287.  
  288.  
  289.  
  290.  
  291. angle_t
  292. R_PointToAngle
  293. ( fixed_t       x,
  294.   fixed_t       y )
  295. {      
  296.     x -= viewx;
  297.     y -= viewy;
  298.    
  299.     if ( (!x) && (!y) )
  300.         return 0;
  301.  
  302.     if (x>= 0)
  303.     {
  304.         // x >=0
  305.         if (y>= 0)
  306.         {
  307.             // y>= 0
  308.  
  309.             if (x>y)
  310.             {
  311.                 // octant 0
  312.                 return tantoangle[ SlopeDiv(y,x)];
  313.             }
  314.             else
  315.             {
  316.                 // octant 1
  317.                 return ANG90-1-tantoangle[ SlopeDiv(x,y)];
  318.             }
  319.         }
  320.         else
  321.         {
  322.             // y<0
  323.             y = -y;
  324.  
  325.             if (x>y)
  326.             {
  327.                 // octant 8
  328.                 return -tantoangle[SlopeDiv(y,x)];
  329.             }
  330.             else
  331.             {
  332.                 // octant 7
  333.                 return ANG270+tantoangle[ SlopeDiv(x,y)];
  334.             }
  335.         }
  336.     }
  337.     else
  338.     {
  339.         // x<0
  340.         x = -x;
  341.  
  342.         if (y>= 0)
  343.         {
  344.             // y>= 0
  345.             if (x>y)
  346.             {
  347.                 // octant 3
  348.                 return ANG180-1-tantoangle[ SlopeDiv(y,x)];
  349.             }
  350.             else
  351.             {
  352.                 // octant 2
  353.                 return ANG90+ tantoangle[ SlopeDiv(x,y)];
  354.             }
  355.         }
  356.         else
  357.         {
  358.             // y<0
  359.             y = -y;
  360.  
  361.             if (x>y)
  362.             {
  363.                 // octant 4
  364.                 return ANG180+tantoangle[ SlopeDiv(y,x)];
  365.             }
  366.             else
  367.             {
  368.                  // octant 5
  369.                 return ANG270-1-tantoangle[ SlopeDiv(x,y)];
  370.             }
  371.         }
  372.     }
  373.     return 0;
  374. }
  375.  
  376.  
  377. angle_t
  378. R_PointToAngle2
  379. ( fixed_t       x1,
  380.   fixed_t       y1,
  381.   fixed_t       x2,
  382.   fixed_t       y2 )
  383. {      
  384.     viewx = x1;
  385.     viewy = y1;
  386.    
  387.     return R_PointToAngle (x2, y2);
  388. }
  389.  
  390.  
  391. fixed_t
  392. R_PointToDist
  393. ( fixed_t       x,
  394.   fixed_t       y )
  395. {
  396.     int         angle;
  397.     fixed_t     dx;
  398.     fixed_t     dy;
  399.     fixed_t     temp;
  400.     fixed_t     dist;
  401.        
  402.     dx = abs(x - viewx);
  403.     dy = abs(y - viewy);
  404.        
  405.     if (dy>dx)
  406.     {
  407.         temp = dx;
  408.         dx = dy;
  409.         dy = temp;
  410.     }
  411.        
  412.     angle = (tantoangle[ FixedDiv(dy,dx)>>DBITS ]+ANG90) >> ANGLETOFINESHIFT;
  413.  
  414.     // use as cosine
  415.     dist = FixedDiv (dx, finesine[angle] );    
  416.        
  417.     return dist;
  418. }
  419.  
  420.  
  421.  
  422.  
  423. //
  424. // R_InitPointToAngle
  425. //
  426. void R_InitPointToAngle (void)
  427. {
  428.     // UNUSED - now getting from tables.c
  429. #if 0
  430.     int i;
  431.     long        t;
  432.     float       f;
  433. //
  434. // slope (tangent) to angle lookup
  435. //
  436.     for (i=0 ; i<=SLOPERANGE ; i++)
  437.     {
  438.         f = atan( (float)i/SLOPERANGE )/(3.141592657*2);
  439.         t = 0xffffffff*f;
  440.         tantoangle[i] = t;
  441.     }
  442. #endif
  443. }
  444.  
  445.  
  446. //
  447. // R_ScaleFromGlobalAngle
  448. // Returns the texture mapping scale
  449. //  for the current line (horizontal span)
  450. //  at the given angle.
  451. // rw_distance must be calculated first.
  452. //
  453. fixed_t R_ScaleFromGlobalAngle (angle_t visangle)
  454. {
  455.     fixed_t             scale;
  456.     int                 anglea;
  457.     int                 angleb;
  458.     int                 sinea;
  459.     int                 sineb;
  460.     fixed_t             num;
  461.     int                 den;
  462.  
  463.     // UNUSED
  464. #if 0
  465. {
  466.     fixed_t             dist;
  467.     fixed_t             z;
  468.     fixed_t             sinv;
  469.     fixed_t             cosv;
  470.        
  471.     sinv = finesine[(visangle-rw_normalangle)>>ANGLETOFINESHIFT];      
  472.     dist = FixedDiv (rw_distance, sinv);
  473.     cosv = finecosine[(viewangle-visangle)>>ANGLETOFINESHIFT];
  474.     z = abs(FixedMul (dist, cosv));
  475.     scale = FixedDiv(projection, z);
  476.     return scale;
  477. }
  478. #endif
  479.  
  480.     anglea = ANG90 + (visangle-viewangle);
  481.     angleb = ANG90 + (visangle-rw_normalangle);
  482.  
  483.     // both sines are allways positive
  484.     sinea = finesine[anglea>>ANGLETOFINESHIFT];
  485.     sineb = finesine[angleb>>ANGLETOFINESHIFT];
  486.     num = FixedMul(projection,sineb)<<detailshift;
  487.     den = FixedMul(rw_distance,sinea);
  488.  
  489.     if (den > num>>16)
  490.     {
  491.         scale = FixedDiv (num, den);
  492.  
  493.         if (scale > 64*FRACUNIT)
  494.             scale = 64*FRACUNIT;
  495.         else if (scale < 256)
  496.             scale = 256;
  497.     }
  498.     else
  499.         scale = 64*FRACUNIT;
  500.        
  501.     return scale;
  502. }
  503.  
  504.  
  505.  
  506. //
  507. // R_InitTables
  508. //
  509. void R_InitTables (void)
  510. {
  511.     // UNUSED: now getting from tables.c
  512. #if 0
  513.     int         i;
  514.     float       a;
  515.     float       fv;
  516.     int         t;
  517.    
  518.     // viewangle tangent table
  519.     for (i=0 ; i<FINEANGLES/2 ; i++)
  520.     {
  521.         a = (i-FINEANGLES/4+0.5)*PI*2/FINEANGLES;
  522.         fv = FRACUNIT*tan (a);
  523.         t = fv;
  524.         finetangent[i] = t;
  525.     }
  526.    
  527.     // finesine table
  528.     for (i=0 ; i<5*FINEANGLES/4 ; i++)
  529.     {
  530.         // OPTIMIZE: mirror...
  531.         a = (i+0.5)*PI*2/FINEANGLES;
  532.         t = FRACUNIT*sin (a);
  533.         finesine[i] = t;
  534.     }
  535. #endif
  536.  
  537. }
  538.  
  539.  
  540.  
  541. //
  542. // R_InitTextureMapping
  543. //
  544. void R_InitTextureMapping (void)
  545. {
  546.     int                 i;
  547.     int                 x;
  548.     int                 t;
  549.     fixed_t             focallength;
  550.    
  551.     // Use tangent table to generate viewangletox:
  552.     //  viewangletox will give the next greatest x
  553.     //  after the view angle.
  554.     //
  555.     // Calc focallength
  556.     //  so FIELDOFVIEW angles covers SCREENWIDTH.
  557.     focallength = FixedDiv (centerxfrac,
  558.                             finetangent[FINEANGLES/4+FIELDOFVIEW/2] );
  559.        
  560.     for (i=0 ; i<FINEANGLES/2 ; i++)
  561.     {
  562.         if (finetangent[i] > FRACUNIT*2)
  563.             t = -1;
  564.         else if (finetangent[i] < -FRACUNIT*2)
  565.             t = viewwidth+1;
  566.         else
  567.         {
  568.             t = FixedMul (finetangent[i], focallength);
  569.             t = (centerxfrac - t+FRACUNIT-1)>>FRACBITS;
  570.  
  571.             if (t < -1)
  572.                 t = -1;
  573.             else if (t>viewwidth+1)
  574.                 t = viewwidth+1;
  575.         }
  576.         viewangletox[i] = t;
  577.     }
  578.    
  579.     // Scan viewangletox[] to generate xtoviewangle[]:
  580.     //  xtoviewangle will give the smallest view angle
  581.     //  that maps to x.
  582.     for (x=0;x<=viewwidth;x++)
  583.     {
  584.         i = 0;
  585.         while (viewangletox[i]>x)
  586.             i++;
  587.         xtoviewangle[x] = (i<<ANGLETOFINESHIFT)-ANG90;
  588.     }
  589.    
  590.     // Take out the fencepost cases from viewangletox.
  591.     for (i=0 ; i<FINEANGLES/2 ; i++)
  592.     {
  593.         t = FixedMul (finetangent[i], focallength);
  594.         t = centerx - t;
  595.        
  596.         if (viewangletox[i] == -1)
  597.             viewangletox[i] = 0;
  598.         else if (viewangletox[i] == viewwidth+1)
  599.             viewangletox[i]  = viewwidth;
  600.     }
  601.        
  602.     clipangle = xtoviewangle[0];
  603. }
  604.  
  605.  
  606.  
  607. //
  608. // R_InitLightTables
  609. // Only inits the zlight table,
  610. //  because the scalelight table changes with view size.
  611. //
  612. #define DISTMAP         2
  613.  
  614. void R_InitLightTables (void)
  615. {
  616.     int         i;
  617.     int         j;
  618.     int         level;
  619.     int         startmap;      
  620.     int         scale;
  621.    
  622.     // Calculate the light levels to use
  623.     //  for each level / distance combination.
  624.     for (i=0 ; i< LIGHTLEVELS ; i++)
  625.     {
  626.         startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
  627.         for (j=0 ; j<MAXLIGHTZ ; j++)
  628.         {
  629.             scale = FixedDiv ((SCREENWIDTH/2*FRACUNIT), (j+1)<<LIGHTZSHIFT);
  630.             scale >>= LIGHTSCALESHIFT;
  631.             level = startmap - scale/DISTMAP;
  632.            
  633.             if (level < 0)
  634.                 level = 0;
  635.  
  636.             if (level >= NUMCOLORMAPS)
  637.                 level = NUMCOLORMAPS-1;
  638.  
  639.             zlight[i][j] = colormaps + level*256;
  640.         }
  641.     }
  642. }
  643.  
  644.  
  645.  
  646. //
  647. // R_SetViewSize
  648. // Do not really change anything here,
  649. //  because it might be in the middle of a refresh.
  650. // The change will take effect next refresh.
  651. //
  652. boolean         setsizeneeded;
  653. int             setblocks;
  654. int             setdetail;
  655.  
  656.  
  657. void
  658. R_SetViewSize
  659. ( int           blocks,
  660.   int           detail )
  661. {
  662.     setsizeneeded = true;
  663.     setblocks = blocks;
  664.     setdetail = detail;
  665. }
  666.  
  667.  
  668. //
  669. // R_ExecuteSetViewSize
  670. //
  671. void R_ExecuteSetViewSize (void)
  672. {
  673.     fixed_t     cosadj;
  674.     fixed_t     dy;
  675.     int         i;
  676.     int         j;
  677.     int         level;
  678.     int         startmap;      
  679.  
  680.     setsizeneeded = false;
  681.  
  682.     if (setblocks == 11)
  683.     {
  684.         scaledviewwidth = SCREENWIDTH;
  685.         viewheight = SCREENHEIGHT;
  686.     }
  687.     else
  688.     {
  689.         scaledviewwidth = setblocks*32;
  690.         viewheight = (setblocks*168/10)&~7;
  691.     }
  692.    
  693.     detailshift = setdetail;
  694.     viewwidth = scaledviewwidth>>detailshift;
  695.        
  696.     centery = viewheight/2;
  697.     centerx = viewwidth/2;
  698.     centerxfrac = centerx<<FRACBITS;
  699.     centeryfrac = centery<<FRACBITS;
  700.     projection = centerxfrac;
  701.  
  702.     if (!detailshift)
  703.     {
  704.         colfunc = basecolfunc = R_DrawColumn;
  705.         fuzzcolfunc = R_DrawFuzzColumn;
  706.         transcolfunc = R_DrawTranslatedColumn;
  707.         spanfunc = R_DrawSpan;
  708.     }
  709.     else
  710.     {
  711.         colfunc = basecolfunc = R_DrawColumnLow;
  712.         fuzzcolfunc = R_DrawFuzzColumn;
  713.         transcolfunc = R_DrawTranslatedColumn;
  714.         spanfunc = R_DrawSpanLow;
  715.     }
  716.  
  717.     R_InitBuffer (scaledviewwidth, viewheight);
  718.        
  719.     R_InitTextureMapping ();
  720.    
  721.     // psprite scales
  722.     pspritescale = FRACUNIT*viewwidth/SCREENWIDTH;
  723.     pspriteiscale = FRACUNIT*SCREENWIDTH/viewwidth;
  724.    
  725.     // thing clipping
  726.     for (i=0 ; i<viewwidth ; i++)
  727.         screenheightarray[i] = viewheight;
  728.    
  729.     // planes
  730.     for (i=0 ; i<viewheight ; i++)
  731.     {
  732.         dy = ((i-viewheight/2)<<FRACBITS)+FRACUNIT/2;
  733.         dy = abs(dy);
  734.         yslope[i] = FixedDiv ( (viewwidth<<detailshift)/2*FRACUNIT, dy);
  735.     }
  736.        
  737.     for (i=0 ; i<viewwidth ; i++)
  738.     {
  739.         cosadj = abs(finecosine[xtoviewangle[i]>>ANGLETOFINESHIFT]);
  740.         distscale[i] = FixedDiv (FRACUNIT,cosadj);
  741.     }
  742.    
  743.     // Calculate the light levels to use
  744.     //  for each level / scale combination.
  745.     for (i=0 ; i< LIGHTLEVELS ; i++)
  746.     {
  747.         startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
  748.         for (j=0 ; j<MAXLIGHTSCALE ; j++)
  749.         {
  750.             level = startmap - j*SCREENWIDTH/(viewwidth<<detailshift)/DISTMAP;
  751.            
  752.             if (level < 0)
  753.                 level = 0;
  754.  
  755.             if (level >= NUMCOLORMAPS)
  756.                 level = NUMCOLORMAPS-1;
  757.  
  758.             scalelight[i][j] = colormaps + level*256;
  759.         }
  760.     }
  761. }
  762.  
  763.  
  764.  
  765. //
  766. // R_Init
  767. //
  768. extern int      detailLevel;
  769. extern int      screenblocks;
  770.  
  771.  
  772.  
  773. void R_Init (void)
  774. {
  775.     R_InitData ();
  776.     printf ("R_InitData\n\r");
  777.     R_InitPointToAngle ();
  778.     printf ("R_InitPointToAngle\n\r");
  779.     R_InitTables ();
  780.     // viewwidth / viewheight / detailLevel are set by the defaults
  781.     printf ("R_InitTables\n\r");
  782.  
  783.     R_SetViewSize (screenblocks, detailLevel);
  784.     R_InitPlanes ();
  785.     printf ("R_InitPlanes\n\r");
  786.     R_InitLightTables ();
  787.     printf ("R_InitLightTables\n\r");
  788.     R_InitSkyMap ();
  789.     printf ("R_InitSkyMap\n\r");
  790.     R_InitTranslationTables ();
  791.     printf ("R_InitTranslationsTables\n\r");
  792.        
  793.     framecount = 0;
  794. }
  795.  
  796.  
  797. //
  798. // R_PointInSubsector
  799. //
  800. subsector_t*
  801. R_PointInSubsector
  802. ( fixed_t       x,
  803.   fixed_t       y )
  804. {
  805.     node_t*     node;
  806.     int         side;
  807.     int         nodenum;
  808.  
  809.     // single subsector is a special case
  810.     if (!numnodes)                              
  811.         return subsectors;
  812.                
  813.     nodenum = numnodes-1;
  814.  
  815.     while (! (nodenum & NF_SUBSECTOR) )
  816.     {
  817.         node = &nodes[nodenum];
  818.         side = R_PointOnSide (x, y, node);
  819.         nodenum = node->children[side];
  820.     }
  821.        
  822.     return &subsectors[nodenum & ~NF_SUBSECTOR];
  823. }
  824.  
  825.  
  826.  
  827. //
  828. // R_SetupFrame
  829. //
  830. void R_SetupFrame (player_t* player)
  831. {              
  832.     int         i;
  833.    
  834.     viewplayer = player;
  835.     viewx = player->mo->x;
  836.     viewy = player->mo->y;
  837.     viewangle = player->mo->angle + viewangleoffset;
  838.     extralight = player->extralight;
  839.  
  840.     viewz = player->viewz;
  841.    
  842.     viewsin = finesine[viewangle>>ANGLETOFINESHIFT];
  843.     viewcos = finecosine[viewangle>>ANGLETOFINESHIFT];
  844.        
  845.     sscount = 0;
  846.        
  847.     if (player->fixedcolormap)
  848.     {
  849.         fixedcolormap =
  850.             colormaps
  851.             + player->fixedcolormap*256*sizeof(lighttable_t);
  852.        
  853.         walllights = scalelightfixed;
  854.  
  855.         for (i=0 ; i<MAXLIGHTSCALE ; i++)
  856.             scalelightfixed[i] = fixedcolormap;
  857.     }
  858.     else
  859.         fixedcolormap = 0;
  860.                
  861.     framecount++;
  862.     validcount++;
  863. }
  864.  
  865.  
  866.  
  867. //
  868. // R_RenderView
  869. //
  870. void R_RenderPlayerView (player_t* player)
  871. {      
  872.     R_SetupFrame (player);
  873.  
  874.     // Clear buffers.
  875.     R_ClearClipSegs ();
  876.     R_ClearDrawSegs ();
  877.     R_ClearPlanes ();
  878.     R_ClearSprites ();
  879.    
  880.     // check for new console commands.
  881.     NetUpdate ();
  882.  
  883.     // The head node is the last node output.
  884.     R_RenderBSPNode (numnodes-1);
  885.    
  886.     // Check for new console commands.
  887.     NetUpdate ();
  888.    
  889.     R_DrawPlanes ();
  890.    
  891.     // Check for new console commands.
  892.     NetUpdate ();
  893.    
  894.     R_DrawMasked ();
  895.  
  896.     // Check for new console commands.
  897.     NetUpdate ();                              
  898. }
  899.