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

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

射击游戏

开发平台：

Visual C++

r_things.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. // Refresh of things, i.e. objects represented by sprites.
  21. //
  22. //-----------------------------------------------------------------------------
  25. static const char
  26. rcsid[] = "$Id: r_things.c,v 1.5 1997/02/03 16:47:56 b1 Exp $";
  29. #include <stdio.h>
  30. #include <stdlib.h>
  33. #include "doomdef.h"
  34. #include "m_swap.h"
  36. #include "i_system.h"
  37. #include "z_zone.h"
  38. #include "w_wad.h"
  40. #include "r_local.h"
  42. #include "doomstat.h"
  46. #define MINZ (FRACUNIT*4)
  47. //#define BASEYCENTER (SCREENHEIGHT/2)
  48. #define BASEYCENTER 100
  49. //#define BASEYCENTER (100-((SCREENHEIGHT-200)/256))
  50. //void R_DrawColumn (void);
  51. //void R_DrawFuzzColumn (void);
  54. char MsgText[256];
  55. void WriteDebug(char *);
  57. typedef struct
  58. {
  59.     int x1;
  60.     int x2;
  62.     int column;
  63.     int topclip;
  64.     int bottomclip;
  66. } maskdraw_t;
  70. //
  71. // Sprite rotation 0 is facing the viewer,
  72. //  rotation 1 is one angle turn CLOCKWISE around the axis.
  73. // This is not the same as the angle,
  74. //  which increases counter clockwise (protractor).
  75. // There was a lot of stuff grabbed wrong, so I changed it...
  76. //
  77. fixed_t pspritescale;
  78. fixed_t pspriteiscale;
  80. lighttable_t** spritelights;
  82. // constant arrays
  83. //  used for psprite clipping and initializing clipping
  84. short      *negonearray;
  85. short      *screenheightarray;
  86. //short negonearray[SCREENWIDTH];
  87. //short screenheightarray[SCREENWIDTH];
  90. //
  91. // INITIALIZATION FUNCTIONS
  92. //
  94. // variables used to look up
  95. //  and range check thing_t sprites patches
  96. spritedef_t* sprites;
  97. int numsprites;
  99. spriteframe_t sprtemp[29];
  100. int maxframe;
  101. char* spritename;
  106. //
  107. // R_InstallSpriteLump
  108. // Local function for R_InitSprites.
  109. //
  110. void
  111. R_InstallSpriteLump
  112. ( int lump,
  113.   unsigned frame,
  114.   unsigned rotation,
  115.   boolean flipped )
  116. {
  117.     int r;
  119.     if (frame >= 29 || rotation > 8)
  120. I_Error("R_InstallSpriteLump: "
  121. "Bad frame characters in lump %i", lump);
  123.     if ((int)frame > maxframe)
  124. maxframe = frame;
  126.     if (rotation == 0)
  127.     {
  128. // the lump should be used for all rotations
  129. if (sprtemp[frame].rotate == false)
  130.     I_Error ("R_InitSprites: Sprite %s frame %c has "
  131.      "multip rot=0 lump", spritename, 'A'+frame);
  133. if (sprtemp[frame].rotate == true)
  134.     I_Error ("R_InitSprites: Sprite %s frame %c has rotations "
  135.      "and a rot=0 lump", spritename, 'A'+frame);
  137. sprtemp[frame].rotate = false;
  138. for (r=0 ; r<8 ; r++)
  139. {
  140.     sprtemp[frame].lump[r] = lump - firstspritelump;
  141.     sprtemp[frame].flip[r] = (byte)flipped;
  142. }
  143. return;
  144.     }
  146.     // the lump is only used for one rotation
  147.     if (sprtemp[frame].rotate == false)
  148. I_Error ("R_InitSprites: Sprite %s frame %c has rotations "
  149.  "and a rot=0 lump", spritename, 'A'+frame);
  151.     sprtemp[frame].rotate = true;
  153.     // make 0 based
  154.     rotation--;
  155.     if (sprtemp[frame].lump[rotation] != -1)
  156. I_Error ("R_InitSprites: Sprite %s : %c : %c "
  157.  "has two lumps mapped to it",
  158.  spritename, 'A'+frame, '1'+rotation);
  160.     sprtemp[frame].lump[rotation] = lump - firstspritelump;
  161.     sprtemp[frame].flip[rotation] = (byte)flipped;
  162. }
  167. //
  168. // R_InitSpriteDefs
  169. // Pass a null terminated list of sprite names
  170. //  (4 chars exactly) to be used.
  171. // Builds the sprite rotation matrixes to account
  172. //  for horizontally flipped sprites.
  173. // Will report an error if the lumps are inconsistant. 
  174. // Only called at startup.
  175. //
  176. // Sprite lump names are 4 characters for the actor,
  177. //  a letter for the frame, and a number for the rotation.
  178. // A sprite that is flippable will have an additional
  179. //  letter/number appended.
  180. // The rotation character can be 0 to signify no rotations.
  181. //
  182. void R_InitSpriteDefs (char** namelist) 
  183. { 
  184.     char** check;
  185.     int i;
  186.     int l;
  187.     int intname;
  188.     int frame;
  189.     int rotation;
  190.     int start;
  191.     int end;
  192.     int patched;
  194.     // count the number of sprite names
  195.     check = namelist;
  196.     while (*check != NULL)
  197. check++;
  199.     numsprites = check-namelist;
  201.     if (!numsprites)
  202. return;
  204.     sprites = Z_Malloc(numsprites *sizeof(*sprites), PU_STATIC, NULL);
  206.     start = firstspritelump-1;
  207.     end = lastspritelump+1;
  209.     // scan all the lump names for each of the names,
  210.     //  noting the highest frame letter.
  211.     // Just compare 4 characters as ints
  212.     for (i=0 ; i<numsprites ; i++)
  213.     {
  214. spritename = namelist[i];
  215. memset (sprtemp,-1, sizeof(sprtemp));
  217. maxframe = -1;
  218. intname = *(int *)namelist[i];
  220. // scan the lumps,
  221. //  filling in the frames for whatever is found
  222. for (l=start+1 ; l<end ; l++)
  223. {
  224.     if (*(int *)lumpinfo[l].name == intname)
  225.     {
  226. frame = lumpinfo[l].name[4] - 'A';
  227. rotation = lumpinfo[l].name[5] - '0';
  229. if (modifiedgame)
  230.     patched = W_GetNumForName (lumpinfo[l].name);
  231. else
  232.     patched = l;
  234. R_InstallSpriteLump (patched, frame, rotation, false);
  236. if (lumpinfo[l].name[6])
  237. {
  238.     frame = lumpinfo[l].name[6] - 'A';
  239.     rotation = lumpinfo[l].name[7] - '0';
  240.     R_InstallSpriteLump (l, frame, rotation, true);
  241. }
  242.     }
  243. }
  245. // check the frames that were found for completeness
  246. if (maxframe == -1)
  247. {
  248.     sprites[i].numframes = 0;
  249.     continue;
  250. }
  252. maxframe++;
  254. for (frame = 0 ; frame < maxframe ; frame++)
  255. {
  256.     switch ((int)sprtemp[frame].rotate)
  257.     {
  258.       case -1:
  259. // no rotations were found for that frame at all
  260. I_Error ("R_InitSprites: No patches found "
  261.  "for %s frame %c", namelist[i], frame+'A');
  262. break;
  264.       case 0:
  265. // only the first rotation is needed
  266. break;
  268.       case 1:
  269. // must have all 8 frames
  270. for (rotation=0 ; rotation<8 ; rotation++)
  271.     if (sprtemp[frame].lump[rotation] == -1)
  272. I_Error ("R_InitSprites: Sprite %s frame %c "
  273.  "is missing rotations",
  274.  namelist[i], frame+'A');
  275. break;
  276.     }
  277. }
  279. // allocate space for the frames present and copy sprtemp to it
  280. sprites[i].numframes = maxframe;
  281. sprites[i].spriteframes = 
  282.     Z_Malloc (maxframe * sizeof(spriteframe_t), PU_STATIC, NULL);
  283. memcpy (sprites[i].spriteframes, sprtemp, maxframe*sizeof(spriteframe_t));
  284.     }
  286. }
  291. //
  292. // GAME FUNCTIONS
  293. //
  294. vissprite_t vissprites[MAXVISSPRITES];
  295. vissprite_t* vissprite_p;
  296. int newvissprite;
  300. //
  301. // R_InitSprites
  302. // Called at program start.
  303. //
  304. void R_InitSprites (char** namelist)
  305. {
  306.     int i;
  308.     xtoviewangle = (angle_t *)calloc(SCREENWIDTH+1,sizeof(angle_t));
  309.     negonearray = (short *)calloc(SCREENWIDTH,sizeof(short));
  310.     screenheightarray = (short *)calloc(SCREENWIDTH,sizeof(short));
  311.     for (i=0 ; i<SCREENWIDTH ; i++)
  312.     {
  313. negonearray[i] = -1;
  314.     }
  316.     R_InitSpriteDefs (namelist);
  317. }
  321. //
  322. // R_ClearSprites
  323. // Called at frame start.
  324. //
  325. void R_ClearSprites (void)
  326. {
  327.     vissprite_p = vissprites;
  328. }
  331. //
  332. // R_NewVisSprite
  333. //
  334. vissprite_t overflowsprite;
  336. vissprite_t* R_NewVisSprite (void)
  337. {
  338.     if (vissprite_p == &vissprites[MAXVISSPRITES])
  339. return &overflowsprite;
  340.     
  341.     vissprite_p++;
  342.     return vissprite_p-1;
  343. }
  347. //
  348. // R_DrawMaskedColumn
  349. // Used for sprites and masked mid textures.
  350. // Masked means: partly transparent, i.e. stored
  351. //  in posts/runs of opaque pixels.
  352. //
  353. short* mfloorclip;
  354. short* mceilingclip;
  356. fixed_t spryscale;
  357. fixed_t sprtopscreen;
  359. void R_DrawMaskedColumn (column_t* column)
  360. {
  361.     int topscreen;
  362.     int  bottomscreen;
  363.     fixed_t basetexturemid;
  365.     basetexturemid = dc_texturemid;
  367.     for ( ; column->topdelta != 0xff ; ) 
  368.     {
  369. // calculate unclipped screen coordinates
  370. //  for post
  371. topscreen = sprtopscreen + spryscale*column->topdelta;
  372. bottomscreen = topscreen + spryscale*column->length;
  374. dc_yl = (topscreen+FRACUNIT-1)>>FRACBITS;
  375. dc_yh = (bottomscreen-1)>>FRACBITS;
  377. if (dc_yh >= mfloorclip[dc_x])
  378.     dc_yh = mfloorclip[dc_x]-1;
  379. if (dc_yl <= mceilingclip[dc_x])
  380.     dc_yl = mceilingclip[dc_x]+1;
  382. if (dc_yl <= dc_yh)
  383. {
  384.     dc_source = (byte *)column + 3;
  385.     dc_texturemid = basetexturemid - (column->topdelta<<FRACBITS);
  386.     // dc_source = (byte *)column + 3 - column->topdelta;
  388.     // Drawn by either R_DrawColumn
  389.     //  or (SHADOW) R_DrawFuzzColumn.
  390.     colfunc ();
  391. }
  392. column = (column_t *)(  (byte *)column + column->length + 4);
  393.     }
  395.     dc_texturemid = basetexturemid;
  396. }
  400. //
  401. // R_DrawVisSprite
  402. //  mfloorclip and mceilingclip should also be set.
  403. //
  404. void
  405. R_DrawVisSprite
  406. ( vissprite_t* vis,
  407.   int x1,
  408.   int x2 )
  409. {
  410.     column_t* column;
  411.     int texturecolumn;
  412.     fixed_t frac;
  413.     patch_t* patch;
  416.     patch = W_CacheLumpNum (vis->patch+firstspritelump, PU_CACHE);
  418.     dc_colormap = vis->colormap;
  419.     
  420.     if (!dc_colormap)
  421.     {
  422. // NULL colormap = shadow draw
  423. colfunc = fuzzcolfunc;
  424.     }
  425.     else if (vis->mobjflags & MF_TRANSLATION)
  426.     {
  427. colfunc = R_DrawTranslatedColumn;
  428. dc_translation = translationtables - 256 +
  429.     ( (vis->mobjflags & MF_TRANSLATION) >> (MF_TRANSSHIFT-8) );
  430.     }
  432.     dc_iscale = abs(vis->xiscale)>>detailshift;
  433.     dc_texturemid = vis->texturemid;
  434.     frac = vis->startfrac;
  435.     spryscale = vis->scale;
  436.     sprtopscreen = centeryfrac - FixedMul(dc_texturemid,spryscale);
  438.     for (dc_x=vis->x1 ; dc_x<=vis->x2 ; dc_x++, frac += vis->xiscale)
  439.     {
  440. texturecolumn = frac>>FRACBITS;
  441. #ifdef RANGECHECK
  442. if (texturecolumn < 0 || texturecolumn >= SHORT(patch->width))
  443.     I_Error ("R_DrawSpriteRange: bad texturecolumn");
  444. #endif
  445. column = (column_t *) ((byte *)patch +
  446.        LONG(patch->columnofs[texturecolumn]));
  447. R_DrawMaskedColumn (column);
  448.     }
  450.     colfunc = basecolfunc;
  451. }
  455. //
  456. // R_ProjectSprite
  457. // Generates a vissprite for a thing
  458. //  if it might be visible.
  459. //
  460. void R_ProjectSprite (mobj_t* thing)
  461. {
  462.     fixed_t tr_x;
  463.     fixed_t tr_y;
  464.     
  465.     fixed_t gxt;
  466.     fixed_t gyt;
  467.     
  468.     fixed_t tx;
  469.     fixed_t tz;
  471.     fixed_t xscale;
  472.     
  473.     int x1;
  474.     int x2;
  476.     spritedef_t* sprdef;
  477.     spriteframe_t* sprframe;
  478.     int lump;
  479.     
  480.     unsigned rot;
  481.     boolean flip;
  482.     
  483.     int index;
  485.     vissprite_t* vis;
  486.     
  487.     angle_t ang;
  488.     fixed_t iscale;
  489.     
  490.     // transform the origin point
  491.     tr_x = thing->x - viewx;
  492.     tr_y = thing->y - viewy;
  494.     gxt = FixedMul(tr_x,viewcos); 
  495.     gyt = -FixedMul(tr_y,viewsin);
  496.     
  497.     tz = gxt-gyt; 
  499.     // thing is behind view plane?
  500.     if (tz < MINZ)
  501. return;
  502.     
  503.     xscale = FixedDiv(projection, tz);
  505.     gxt = -FixedMul(tr_x,viewsin); 
  506.     gyt = FixedMul(tr_y,viewcos); 
  507.     tx = -(gyt+gxt); 
  509.     // too far off the side?
  510.     if (abs(tx)>(tz<<2))
  511. return;
  512.     
  513.     // decide which patch to use for sprite relative to player
  514. #ifdef RANGECHECK
  515.     if ((unsigned)thing->sprite >= (unsigned)numsprites)
  516. I_Error ("R_ProjectSprite: invalid sprite number %i ",
  517.  thing->sprite);
  518. #endif
  519.     sprdef = &sprites[thing->sprite];
  520. #ifdef RANGECHECK
  521.     if ( (thing->frame&FF_FRAMEMASK) >= sprdef->numframes )
  522. I_Error ("R_ProjectSprite: invalid sprite frame %i : %i ",
  523.  thing->sprite, thing->frame);
  524. #endif
  525.     sprframe = &sprdef->spriteframes[ thing->frame & FF_FRAMEMASK];
  527.     if (sprframe->rotate)
  528.     {
  529. // choose a different rotation based on player view
  530. ang = R_PointToAngle (thing->x, thing->y);
  531. rot = (ang-thing->angle+(unsigned)(ANG45/2)*9)>>29;
  532. lump = sprframe->lump[rot];
  533. flip = (boolean)sprframe->flip[rot];
  534.     }
  535.     else
  536.     {
  537. // use single rotation for all views
  538. lump = sprframe->lump[0];
  539. flip = (boolean)sprframe->flip[0];
  540.     }
  541.     
  542.     // calculate edges of the shape
  543.     tx -= spriteoffset[lump];
  544.     x1 = (centerxfrac + FixedMul (tx,xscale) ) >>FRACBITS;
  546.     // off the right side?
  547.     if (x1 > viewwidth)
  548. return;
  549.     
  550.     tx +=  spritewidth[lump];
  551.     x2 = ((centerxfrac + FixedMul (tx,xscale) ) >>FRACBITS) - 1;
  553.     // off the left side
  554.     if (x2 < 0)
  555. return;
  556.     
  557.     // store information in a vissprite
  558.     vis = R_NewVisSprite ();
  559.     vis->mobjflags = thing->flags;
  560.     vis->scale = xscale<<detailshift;
  561.     vis->gx = thing->x;
  562.     vis->gy = thing->y;
  563.     vis->gz = thing->z;
  564.     vis->gzt = thing->z + spritetopoffset[lump];
  565.     vis->texturemid = vis->gzt - viewz;
  566.     vis->x1 = x1 < 0 ? 0 : x1;
  567.     vis->x2 = x2 >= viewwidth ? viewwidth-1 : x2;
  568.     iscale = FixedDiv (FRACUNIT, xscale);
  570.     if (flip)
  571.     {
  572. vis->startfrac = spritewidth[lump]-1;
  573. vis->xiscale = -iscale;
  574.     }
  575.     else
  576.     {
  577. vis->startfrac = 0;
  578. vis->xiscale = iscale;
  579.     }
  581.     if (vis->x1 > x1)
  582. vis->startfrac += vis->xiscale*(vis->x1-x1);
  583.     vis->patch = lump;
  584.     
  585.     // get light level
  586.     if (thing->flags & MF_SHADOW)
  587.     {
  588. // shadow draw
  589. vis->colormap = NULL;
  590.     }
  591.     else if (fixedcolormap)
  592.     {
  593. // fixed map
  594. vis->colormap = fixedcolormap;
  595.     }
  596.     else if (thing->frame & FF_FULLBRIGHT)
  597.     {
  598. // full bright
  599. vis->colormap = colormaps;
  600.     }
  601.     
  602.     else
  603.     {
  604. // diminished light
  605. index = xscale>>(LIGHTSCALESHIFT-detailshift);
  607. if (index >= MAXLIGHTSCALE) 
  608.     index = MAXLIGHTSCALE-1;
  610. vis->colormap = spritelights[index];
  611.     }
  612. }
  617. //
  618. // R_AddSprites
  619. // During BSP traversal, this adds sprites by sector.
  620. //
  621. void R_AddSprites (sector_t* sec)
  622. {
  623.     mobj_t* thing;
  624.     int lightnum;
  626.     // BSP is traversed by subsector.
  627.     // A sector might have been split into several
  628.     //  subsectors during BSP building.
  629.     // Thus we check whether its already added.
  630.     if (sec->validcount == validcount)
  631. return;
  633.     // Well, now it will be done.
  634.     sec->validcount = validcount;
  636.     lightnum = (sec->lightlevel >> LIGHTSEGSHIFT)+extralight;
  638.     if (lightnum < 0)
  639. spritelights = scalelight[0];
  640.     else if (lightnum >= LIGHTLEVELS)
  641. spritelights = scalelight[LIGHTLEVELS-1];
  642.     else
  643. spritelights = scalelight[lightnum];
  645.     // Handle all things in sector.
  646.     for (thing = sec->thinglist ; thing ; thing = thing->snext)
  647. R_ProjectSprite (thing);
  648. }
  651. //
  652. // R_DrawPSprite
  653. //
  654. void R_DrawPSprite (pspdef_t* psp)
  655. {
  656.     fixed_t tx;
  657.     int x1;
  658.     int x2;
  659.     spritedef_t* sprdef;
  660.     spriteframe_t* sprframe;
  661.     int lump;
  662.     boolean flip;
  663.     vissprite_t* vis;
  664.     vissprite_t avis;
  665.     
  666.     // decide which patch to use
  667. #ifdef RANGECHECK
  668.     if ( (unsigned)psp->state->sprite >= (unsigned)numsprites)
  669. I_Error ("R_ProjectSprite: invalid sprite number %i ",
  670.  psp->state->sprite);
  671. #endif
  672.     sprdef = &sprites[psp->state->sprite];
  673. #ifdef RANGECHECK
  674.     if ( (psp->state->frame & FF_FRAMEMASK)  >= sprdef->numframes)
  675. I_Error ("R_ProjectSprite: invalid sprite frame %i : %i ",
  676.  psp->state->sprite, psp->state->frame);
  677. #endif
  678.     sprframe = &sprdef->spriteframes[ psp->state->frame & FF_FRAMEMASK ];
  680.     lump = sprframe->lump[0];
  681.     flip = (boolean)sprframe->flip[0];
  682.     
  683.     // calculate edges of the shape
  684.     tx = psp->sx-160*FRACUNIT;
  686.     tx -= spriteoffset[lump];
  687.     x1 = (centerxfrac + FixedMul (tx,pspritescale) ) >>FRACBITS;
  689.     // off the right side
  690.     if (x1 > viewwidth)
  691. return;
  693.     tx +=  spritewidth[lump];
  694.     x2 = ((centerxfrac + FixedMul (tx, pspritescale) ) >>FRACBITS) - 1;
  696.     // off the left side
  697.     if (x2 < 0)
  698. return;
  699.     
  700.     // store information in a vissprite
  701.     vis = &avis;
  702.     vis->mobjflags = 0;
  703.     vis->texturemid = (BASEYCENTER<<FRACBITS)+FRACUNIT/2-(psp->sy-spritetopoffset[lump]);
  704.     vis->x1 = x1 < 0 ? 0 : x1;
  705.     vis->x2 = x2 >= viewwidth ? viewwidth-1 : x2;
  706.     vis->scale = pspritescale<<detailshift;
  708.     if (flip)
  709.     {
  710. vis->xiscale = -pspriteiscale;
  711. vis->startfrac = spritewidth[lump]-1;
  712.     }
  713.     else
  714.     {
  715. vis->xiscale = pspriteiscale;
  716. vis->startfrac = 0;
  717.     }
  718.     
  719.     if (vis->x1 > x1)
  720. vis->startfrac += vis->xiscale*(vis->x1-x1);
  722.     vis->patch = lump;
  724.     if (viewplayer->powers[pw_invisibility] > 4*32
  725. || viewplayer->powers[pw_invisibility] & 8)
  726.     {
  727. // shadow draw
  728. vis->colormap = NULL;
  729.     }
  730.     else if (fixedcolormap)
  731.     {
  732. // fixed color
  733. vis->colormap = fixedcolormap;
  734.     }
  735.     else if (psp->state->frame & FF_FULLBRIGHT)
  736.     {
  737. // full bright
  738. vis->colormap = colormaps;
  739.     }
  740.     else
  741.     {
  742. // local light
  743. vis->colormap = spritelights[MAXLIGHTSCALE-1];
  744.     }
  746. //    sprintf(MsgText, "R_DrawVisSprite %d - %d...n", vis->x1, vis->x2);
  747. //    WriteDebug(MsgText);
  748.     R_DrawVisSprite (vis, vis->x1, vis->x2);
  749. }
  753. //
  754. // R_DrawPlayerSprites
  755. //
  756. void R_DrawPlayerSprites (void)
  757. {
  758.     int i;
  759.     int lightnum;
  760.     pspdef_t* psp;
  761.     
  762.     // get light level
  763.     lightnum =
  764. (viewplayer->mo->subsector->sector->lightlevel >> LIGHTSEGSHIFT) 
  765. +extralight;
  767.     if (lightnum < 0)
  768. spritelights = scalelight[0];
  769.     else if (lightnum >= LIGHTLEVELS)
  770. spritelights = scalelight[LIGHTLEVELS-1];
  771.     else
  772. spritelights = scalelight[lightnum];
  773.     
  774.     // clip to screen bounds
  775.     mfloorclip = screenheightarray;
  776.     mceilingclip = negonearray;
  777.     
  778.     // add all active psprites
  779.     for (i=0, psp=viewplayer->psprites;
  780.  i<NUMPSPRITES;
  781.  i++,psp++)
  782.     {
  783. if (psp->state)
  784.        {
  785.     R_DrawPSprite (psp);
  786.        }
  787.     }
  788. }
  793. //
  794. // R_SortVisSprites
  795. //
  796. vissprite_t vsprsortedhead;
  799. void R_SortVisSprites (void)
  800. {
  801.     int i;
  802.     int count;
  803.     vissprite_t* ds;
  804.     vissprite_t* best;
  805.     vissprite_t unsorted;
  806.     fixed_t bestscale;
  808.     count = vissprite_p - vissprites;
  810.     unsorted.next = unsorted.prev = &unsorted;
  812.     if (!count)
  813. return;
  815.     for (ds=vissprites ; ds<vissprite_p ; ds++)
  816.     {
  817. ds->next = ds+1;
  818. ds->prev = ds-1;
  819.     }
  820.     
  821.     vissprites[0].prev = &unsorted;
  822.     unsorted.next = &vissprites[0];
  823.     (vissprite_p-1)->next = &unsorted;
  824.     unsorted.prev = vissprite_p-1;
  825.     
  826.     // pull the vissprites out by scale
  827.     //best = 0; // shut up the compiler warning
  828.     vsprsortedhead.next = vsprsortedhead.prev = &vsprsortedhead;
  829.     for (i=0 ; i<count ; i++)
  830.     {
  831. bestscale = MAXINT;
  832. for (ds=unsorted.next ; ds!= &unsorted ; ds=ds->next)
  833. {
  834.     if (ds->scale < bestscale)
  835.     {
  836. bestscale = ds->scale;
  837. best = ds;
  838.     }
  839. }
  840. best->next->prev = best->prev;
  841. best->prev->next = best->next;
  842. best->next = &vsprsortedhead;
  843. best->prev = vsprsortedhead.prev;
  844. vsprsortedhead.prev->next = best;
  845. vsprsortedhead.prev = best;
  846.     }
  847. }
  849. //
  850. // R_DrawSprite
  851. //
  852. void R_DrawSprite (vissprite_t* spr)
  853. {
  854.     drawseg_t* ds;
  855.     short clipbot[1280];
  856.     short cliptop[1280];
  857.     //short clipbot[SCREENWIDTH];
  858.     //short cliptop[SCREENWIDTH];
  859.     int x;
  860.     int r1;
  861.     int r2;
  862.     fixed_t scale;
  863.     fixed_t lowscale;
  864.     int silhouette;
  866.     for (x = spr->x1 ; x<=spr->x2 ; x++)
  867. clipbot[x] = cliptop[x] = -2;
  868.     
  869.     // Scan drawsegs from end to start for obscuring segs.
  870.     // The first drawseg that has a greater scale
  871.     //  is the clip seg.
  872.     for (ds=ds_p-1 ; ds >= drawsegs ; ds--)
  873.     {
  874. // determine if the drawseg obscures the sprite
  875. if (ds->x1 > spr->x2
  876.     || ds->x2 < spr->x1
  877.     || (!ds->silhouette
  878. && !ds->maskedtexturecol) )
  879. {
  880.     // does not cover sprite
  881.     continue;
  882. }
  884. r1 = ds->x1 < spr->x1 ? spr->x1 : ds->x1;
  885. r2 = ds->x2 > spr->x2 ? spr->x2 : ds->x2;
  887. if (ds->scale1 > ds->scale2)
  888. {
  889.     lowscale = ds->scale2;
  890.     scale = ds->scale1;
  891. }
  892. else
  893. {
  894.     lowscale = ds->scale1;
  895.     scale = ds->scale2;
  896. }
  898. if (scale < spr->scale
  899.     || ( lowscale < spr->scale
  900.  && !R_PointOnSegSide (spr->gx, spr->gy, ds->curline) ) )
  901. {
  902.     // masked mid texture?
  903.     if (ds->maskedtexturecol)
  904. R_RenderMaskedSegRange (ds, r1, r2);
  905.     // seg is behind sprite
  906.     continue;
  907. }
  910. // clip this piece of the sprite
  911. silhouette = ds->silhouette;
  913. if (spr->gz >= ds->bsilheight)
  914.     silhouette &= ~SIL_BOTTOM;
  916. if (spr->gzt <= ds->tsilheight)
  917.     silhouette &= ~SIL_TOP;
  919. if (silhouette == 1)
  920. {
  921.     // bottom sil
  922.     for (x=r1 ; x<=r2 ; x++)
  923. if (clipbot[x] == -2)
  924.     clipbot[x] = ds->sprbottomclip[x];
  925. }
  926. else if (silhouette == 2)
  927. {
  928.     // top sil
  929.     for (x=r1 ; x<=r2 ; x++)
  930. if (cliptop[x] == -2)
  931.     cliptop[x] = ds->sprtopclip[x];
  932. }
  933. else if (silhouette == 3)
  934. {
  935.     // both
  936.     for (x=r1 ; x<=r2 ; x++)
  937.     {
  938. if (clipbot[x] == -2)
  939.     clipbot[x] = ds->sprbottomclip[x];
  940. if (cliptop[x] == -2)
  941.     cliptop[x] = ds->sprtopclip[x];
  942.     }
  943. }
  945.     }
  946.     
  947.     // all clipping has been performed, so draw the sprite
  949.     // check for unclipped columns
  950.     for (x = spr->x1 ; x<=spr->x2 ; x++)
  951.     {
  952. if (clipbot[x] == -2)
  953.     clipbot[x] = viewheight;
  955. if (cliptop[x] == -2)
  956.     cliptop[x] = -1;
  957.     }
  959.     mfloorclip = clipbot;
  960.     mceilingclip = cliptop;
  961.     R_DrawVisSprite (spr, spr->x1, spr->x2);
  962. }
  967. //
  968. // R_DrawMasked
  969. //
  970. void R_DrawMasked (void)
  971. {
  972.     vissprite_t* spr;
  973.     drawseg_t* ds;
  975.     R_SortVisSprites ();
  977.     if (vissprite_p > vissprites)
  978.     {
  979. // draw all vissprites back to front
  980. for (spr = vsprsortedhead.next ;
  981.      spr != &vsprsortedhead ;
  982.      spr=spr->next)
  983. {
  984.     
  985.     R_DrawSprite (spr);
  986. }
  987.     }
  988.     
  989.     // render any remaining masked mid textures
  990.     for (ds=ds_p-1 ; ds >= drawsegs ; ds--)
  991. if (ds->maskedtexturecol)
  992.     R_RenderMaskedSegRange (ds, ds->x1, ds->x2);
  993.     
  994.     // draw the psprites on top of everything
  995.     //  but does not draw on side views
  996.     if (!viewangleoffset)
  997.        {
  998. R_DrawPlayerSprites ();
  999.        }
  1000. }