开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
r_main.c
资源名称：21.rar　[点击查看]
上传用户：xuyinpeng
上传日期：2021-05-12
资源大小：455k
文件大小：17k
源码类别：

射击游戏

开发平台：

Visual C++

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