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