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

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

射击游戏

开发平台：

Visual C++

r_segs.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. // All the clipping: columns, horizontal spans, sky columns.
  21. //
  22. //-----------------------------------------------------------------------------
  25. static const char
  26. rcsid[] = "$Id: r_segs.c,v 1.3 1997/01/29 20:10:19 b1 Exp $";
  32. #include <stdlib.h>
  34. #include "i_system.h"
  36. #include "doomdef.h"
  37. #include "doomstat.h"
  39. #include "r_local.h"
  40. #include "r_sky.h"
  42. void WriteDebug( char *);
  44. // OPTIMIZE: closed two sided lines as single sided
  46. // True if any of the segs textures might be visible.
  47. boolean segtextured;
  49. // False if the back side is the same plane.
  50. boolean markfloor;
  51. boolean markceiling;
  53. boolean maskedtexture;
  54. int toptexture;
  55. int bottomtexture;
  56. int midtexture;
  59. angle_t rw_normalangle;
  60. // angle to line origin
  61. int rw_angle1;
  63. //
  64. // regular wall
  65. //
  66. int rw_x;
  67. int rw_stopx;
  68. angle_t rw_centerangle;
  69. fixed_t rw_offset;
  70. fixed_t rw_distance;
  71. fixed_t rw_scale;
  72. fixed_t rw_scalestep;
  73. fixed_t rw_midtexturemid;
  74. fixed_t rw_toptexturemid;
  75. fixed_t rw_bottomtexturemid;
  77. int worldtop;
  78. int worldbottom;
  79. int worldhigh;
  80. int worldlow;
  82. fixed_t pixhigh;
  83. fixed_t pixlow;
  84. fixed_t pixhighstep;
  85. fixed_t pixlowstep;
  87. fixed_t topfrac;
  88. fixed_t topstep;
  90. fixed_t bottomfrac;
  91. fixed_t bottomstep;
  94. lighttable_t** walllights;
  96. short* maskedtexturecol;
  100. //
  101. // R_RenderMaskedSegRange
  102. //
  103. void
  104. R_RenderMaskedSegRange
  105. ( drawseg_t* ds,
  106.   int x1,
  107.   int x2 )
  108. {
  109.     unsigned index;
  110.     column_t* col;
  111.     int lightnum;
  112.     int texnum;
  113.     
  114.     // Calculate light table.
  115.     // Use different light tables
  116.     //   for horizontal / vertical / diagonal. Diagonal?
  117.     // OPTIMIZE: get rid of LIGHTSEGSHIFT globally
  118.     curline = ds->curline;
  119.     frontsector = curline->frontsector;
  120.     backsector = curline->backsector;
  121.     texnum = texturetranslation[curline->sidedef->midtexture];
  123.     lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT)+extralight;
  125.     if (curline->v1->y == curline->v2->y)
  126. lightnum--;
  127.     else if (curline->v1->x == curline->v2->x)
  128. lightnum++;
  130.     if (lightnum < 0)
  131. walllights = scalelight[0];
  132.     else if (lightnum >= LIGHTLEVELS)
  133. walllights = scalelight[LIGHTLEVELS-1];
  134.     else
  135. walllights = scalelight[lightnum];
  137.     maskedtexturecol = ds->maskedtexturecol;
  139.     rw_scalestep = ds->scalestep;
  140.     spryscale = ds->scale1 + (x1 - ds->x1)*rw_scalestep;
  141.     mfloorclip = ds->sprbottomclip;
  142.     mceilingclip = ds->sprtopclip;
  143.     
  144.     // find positioning
  145.     if (curline->linedef->flags & ML_DONTPEGBOTTOM)
  146.     {
  147. dc_texturemid = frontsector->floorheight > backsector->floorheight
  148.     ? frontsector->floorheight : backsector->floorheight;
  149. dc_texturemid = dc_texturemid + textureheight[texnum] - viewz;
  150.     }
  151.     else
  152.     {
  153. dc_texturemid =frontsector->ceilingheight<backsector->ceilingheight
  154.     ? frontsector->ceilingheight : backsector->ceilingheight;
  155. dc_texturemid = dc_texturemid - viewz;
  156.     }
  157.     dc_texturemid += curline->sidedef->rowoffset;
  159.     if (fixedcolormap)
  160. dc_colormap = fixedcolormap;
  161.     
  162.     // draw the columns
  163.     for (dc_x = x1 ; dc_x <= x2 ; dc_x++)
  164.     {
  165. // calculate lighting
  166. if (maskedtexturecol[dc_x] != MAXSHORT)
  167. {
  168.     if (!fixedcolormap)
  169.     {
  170. index = spryscale>>LIGHTSCALESHIFT;
  172. if (index >=  MAXLIGHTSCALE )
  173.     index = MAXLIGHTSCALE-1;
  175. dc_colormap = walllights[index];
  176.     }
  178.     sprtopscreen = centeryfrac - FixedMul(dc_texturemid, spryscale);
  179.     dc_iscale = 0xffffffffu / (unsigned)spryscale;
  180.     
  181.     // draw the texture
  182.     col = (column_t *)( 
  183. (byte *)R_GetColumn(texnum,maskedtexturecol[dc_x]) -3);
  185.     R_DrawMaskedColumn (col);
  186.     maskedtexturecol[dc_x] = MAXSHORT;
  187. }
  188. spryscale += rw_scalestep;
  189.     }
  191. }
  196. //
  197. // R_RenderSegLoop
  198. // Draws zero, one, or two textures (and possibly a masked
  199. //  texture) for walls.
  200. // Can draw or mark the starting pixel of floor and ceiling
  201. //  textures.
  202. // CALLED: CORE LOOPING ROUTINE.
  203. //
  204. #define HEIGHTBITS 12
  205. #define HEIGHTUNIT (1<<HEIGHTBITS)
  207. void R_RenderSegLoop (void)
  208. {
  209.     angle_t angle;
  210.     unsigned index;
  211.     int yl;
  212.     int yh;
  213.     int mid;
  214.     fixed_t texturecolumn;
  215.     int top;
  216.     int bottom;
  218.     //texturecolumn = 0; // shut up compiler warning
  220.     for ( ; rw_x < rw_stopx ; rw_x++)
  221.     {
  222. // mark floor / ceiling areas
  223. yl = (topfrac+HEIGHTUNIT-1)>>HEIGHTBITS;
  225. // no space above wall?
  226. if (yl < ceilingclip[rw_x]+1)
  227.     yl = ceilingclip[rw_x]+1;
  229. if (markceiling)
  230. {
  231.     top = ceilingclip[rw_x]+1;
  232.     bottom = yl-1;
  234.     if (bottom >= floorclip[rw_x])
  235. bottom = floorclip[rw_x]-1;
  237.     if (top <= bottom)
  238.     {
  239. ceilingplane->top[rw_x] = top;
  240. ceilingplane->bottom[rw_x] = bottom;
  241.     }
  242. }
  244. yh = bottomfrac>>HEIGHTBITS;
  246. if (yh >= floorclip[rw_x])
  247.     yh = floorclip[rw_x]-1;
  249. if (markfloor)
  250. {
  251.     top = yh+1;
  252.     bottom = floorclip[rw_x]-1;
  253.     if (top <= ceilingclip[rw_x])
  254. top = ceilingclip[rw_x]+1;
  255.     if (top <= bottom)
  256.     {
  257. floorplane->top[rw_x] = top;
  258. floorplane->bottom[rw_x] = bottom;
  259.     }
  260. }
  262. // texturecolumn and lighting are independent of wall tiers
  263. if (segtextured)
  264. {
  265.     // calculate texture offset
  266.     angle = (rw_centerangle + xtoviewangle[rw_x])>>ANGLETOFINESHIFT;
  267.     texturecolumn = rw_offset-FixedMul(finetangent[angle],rw_distance);
  268.     texturecolumn >>= FRACBITS;
  269.     // calculate lighting
  270.     index = rw_scale>>LIGHTSCALESHIFT;
  272.     if (index >=  MAXLIGHTSCALE )
  273. index = MAXLIGHTSCALE-1;
  275.     dc_colormap = walllights[index];
  276.     dc_x = rw_x;
  277.     dc_iscale = 0xffffffffu / (unsigned)rw_scale;
  278. }
  280. // draw the wall tiers
  281. if (midtexture)
  282. {
  283.     // single sided line
  284.     dc_yl = yl;
  285.     dc_yh = yh;
  286.     dc_texturemid = rw_midtexturemid;
  287.     dc_source = R_GetColumn(midtexture,texturecolumn);
  288.     colfunc ();
  289.     ceilingclip[rw_x] = viewheight;
  290.     floorclip[rw_x] = -1;
  291. }
  292. else
  293. {
  294.     // two sided line
  295.     if (toptexture)
  296.     {
  297. // top wall
  298. mid = pixhigh>>HEIGHTBITS;
  299. pixhigh += pixhighstep;
  301. if (mid >= floorclip[rw_x])
  302.     mid = floorclip[rw_x]-1;
  304. if (mid >= yl)
  305. {
  306.     dc_yl = yl;
  307.     dc_yh = mid;
  308.     dc_texturemid = rw_toptexturemid;
  309.     dc_source = R_GetColumn(toptexture,texturecolumn);
  310.     colfunc ();
  311.     ceilingclip[rw_x] = mid;
  312. }
  313. else
  314.     ceilingclip[rw_x] = yl-1;
  315.     }
  316.     else
  317.     {
  318. // no top wall
  319. if (markceiling)
  320.     ceilingclip[rw_x] = yl-1;
  321.     }
  323.     if (bottomtexture)
  324.     {
  325. // bottom wall
  326. mid = (pixlow+HEIGHTUNIT-1)>>HEIGHTBITS;
  327. pixlow += pixlowstep;
  329. // no space above wall?
  330. if (mid <= ceilingclip[rw_x])
  331.     mid = ceilingclip[rw_x]+1;
  333. if (mid <= yh)
  334. {
  335.     dc_yl = mid;
  336.     dc_yh = yh;
  337.     dc_texturemid = rw_bottomtexturemid;
  338.     dc_source = R_GetColumn(bottomtexture,
  339.     texturecolumn);
  340.     colfunc ();
  341.     floorclip[rw_x] = mid;
  342. }
  343. else
  344.     floorclip[rw_x] = yh+1;
  345.     }
  346.     else
  347.     {
  348. // no bottom wall
  349. if (markfloor)
  350.     floorclip[rw_x] = yh+1;
  351.     }
  353.     if (maskedtexture)
  354.     {
  355. // save texturecol
  356. //  for backdrawing of masked mid texture
  357. maskedtexturecol[rw_x] = texturecolumn;
  358.     }
  359. }
  361. rw_scale += rw_scalestep;
  362. topfrac += topstep;
  363. bottomfrac += bottomstep;
  364.     }
  365. }
  370. //
  371. // R_StoreWallRange
  372. // A wall segment will be drawn
  373. //  between start and stop pixels (inclusive).
  374. //
  375. void R_StoreWallRange( int start, int stop )
  376.    {
  377.     fixed_t hyp;
  378.     fixed_t sineval;
  379.     angle_t distangle, offsetangle;
  380.     fixed_t vtop;
  381.     int lightnum;
  383.     // don't overflow and crash
  384.     if (ds_p == &drawsegs[MAXDRAWSEGS])
  385.         return;
  387. #ifdef RANGECHECK
  389.     if (start > stop)
  390.        {
  391.         int hold;
  393.         hold = start;
  394.         start = stop;
  395.         stop = hold;
  396.         //WriteDebug("R_StoreWallRange ASS BACKWARDS...n");
  397.        }
  399.     if (start >= viewwidth)
  400.        {
  401.         WriteDebug("R_StoreWallRange start >= viewwidth...n");
  402.         return;
  403.        }
  404.         //I_Error ("Bad R_StoreWallRange: %i to %i : %i ", start , stop, viewwidth);
  405. #endif
  407.     sidedef = curline->sidedef;
  408.     linedef = curline->linedef;
  410.     // mark the segment as visible for auto map
  411.     linedef->flags |= ML_MAPPED;
  412.     
  413.     // calculate rw_distance for scale calculation
  414.     rw_normalangle = curline->angle + ANG90;
  415.     offsetangle = abs(rw_normalangle-rw_angle1);
  416.     
  417.     if (offsetangle > ANG90)
  418.         offsetangle = ANG90;
  420.     distangle = ANG90 - offsetangle;
  421.     hyp = R_PointToDist (curline->v1->x, curline->v1->y);
  422.     sineval = finesine[distangle>>ANGLETOFINESHIFT];
  423.     rw_distance = FixedMul (hyp, sineval);
  425.     ds_p->x1 = rw_x = start;
  426.     ds_p->x2 = stop;
  427.     ds_p->curline = curline;
  428.     rw_stopx = stop+1;
  429.     
  430.     // calculate scale at both ends and step
  431.     ds_p->scale1 = rw_scale = 
  432. R_ScaleFromGlobalAngle (viewangle + xtoviewangle[start]);
  433.     
  434.     if (stop > start )
  435.        {
  436.         ds_p->scale2 = R_ScaleFromGlobalAngle (viewangle + xtoviewangle[stop]);
  437.         ds_p->scalestep = rw_scalestep = (ds_p->scale2 - rw_scale) / (stop-start);
  438.        }
  439.     else
  440.        {
  441. // UNUSED: try to fix the stretched line bug
  442. #if 0
  443. if (rw_distance < FRACUNIT/2)
  444. {
  445.     fixed_t trx,try;
  446.     fixed_t gxt,gyt;
  448.     trx = curline->v1->x - viewx;
  449.     try = curline->v1->y - viewy;
  451.     gxt = FixedMul(trx,viewcos); 
  452.     gyt = -FixedMul(try,viewsin); 
  453.     ds_p->scale1 = FixedDiv(projection, gxt-gyt)<<detailshift;
  454. }
  455. #endif
  456.         ds_p->scale2 = ds_p->scale1;
  457.        }
  458.     
  459.     // calculate texture boundaries
  460.     //  and decide if floor / ceiling marks are needed
  461.     worldtop = frontsector->ceilingheight - viewz;
  462.     worldbottom = frontsector->floorheight - viewz;
  464.     midtexture = toptexture = bottomtexture = maskedtexture = 0;
  465.     ds_p->maskedtexturecol = NULL;
  467.     if (!backsector)
  468.        {
  469.         // single sided line
  470.         midtexture = texturetranslation[sidedef->midtexture];
  471.         // a single sided line is terminal, so it must mark ends
  472.         markfloor = markceiling = true;
  473.         if (linedef->flags & ML_DONTPEGBOTTOM)
  474.            {
  475.             vtop = frontsector->floorheight +
  476.             textureheight[sidedef->midtexture];
  477.             // bottom of texture at bottom
  478.             rw_midtexturemid = vtop - viewz;
  479.            }
  480.         else
  481.            {
  482.             // top of texture at top
  483.             rw_midtexturemid = worldtop;
  484.            }
  485.         rw_midtexturemid += sidedef->rowoffset;
  487.         ds_p->silhouette = SIL_BOTH;
  488.         ds_p->sprtopclip = screenheightarray;
  489.         ds_p->sprbottomclip = negonearray;
  490.         ds_p->bsilheight = MAXINT;
  491.         ds_p->tsilheight = MININT;
  492.        }
  493.     else
  494.        {
  495.         // two sided line
  496.         ds_p->sprtopclip = ds_p->sprbottomclip = NULL;
  497.         ds_p->silhouette = 0;
  499.         if (frontsector->floorheight > backsector->floorheight)
  500.            {
  501.             ds_p->silhouette = SIL_BOTTOM;
  502.             ds_p->bsilheight = frontsector->floorheight;
  503.            }
  504.         else
  505.         if (backsector->floorheight > viewz)
  506.            {
  507.             ds_p->silhouette = SIL_BOTTOM;
  508.             ds_p->bsilheight = MAXINT;
  509.             // ds_p->sprbottomclip = negonearray;
  510.            }
  512.         if (frontsector->ceilingheight < backsector->ceilingheight)
  513.            {
  514.             ds_p->silhouette |= SIL_TOP;
  515.             ds_p->tsilheight = frontsector->ceilingheight;
  516.            }
  517.         else
  518.         if (backsector->ceilingheight < viewz)
  519.            {
  520.             ds_p->silhouette |= SIL_TOP;
  521.             ds_p->tsilheight = MININT;
  522.             // ds_p->sprtopclip = screenheightarray;
  523.            }
  525.         if (backsector->ceilingheight <= frontsector->floorheight)
  526.            {
  527.             ds_p->sprbottomclip = negonearray;
  528.             ds_p->bsilheight = MAXINT;
  529.             ds_p->silhouette |= SIL_BOTTOM;
  530.            }
  532.         if (backsector->floorheight >= frontsector->ceilingheight)
  533.            {
  534.             ds_p->sprtopclip = screenheightarray;
  535.             ds_p->tsilheight = MININT;
  536.             ds_p->silhouette |= SIL_TOP;
  537.            }
  539.         worldhigh = backsector->ceilingheight - viewz;
  540.         worldlow = backsector->floorheight - viewz;
  542.         // hack to allow height changes in outdoor areas
  543.         if (frontsector->ceilingpic == skyflatnum && backsector->ceilingpic == skyflatnum)
  544.            {
  545.             worldtop = worldhigh;
  546.            }
  548.         if (worldlow != worldbottom || backsector->floorpic != frontsector->floorpic || backsector->lightlevel != frontsector->lightlevel)
  549.            {
  550.             markfloor = true;
  551.            }
  552.         else
  553.            {
  554.             // same plane on both sides
  555.             markfloor = false;
  556.            }
  559.         if (worldhigh != worldtop || backsector->ceilingpic != frontsector->ceilingpic || backsector->lightlevel != frontsector->lightlevel)
  560.            {
  561.             markceiling = true;
  562.            }
  563.         else
  564.            {
  565.             // same plane on both sides
  566.             markceiling = false;
  567.            }
  569.         if (backsector->ceilingheight <= frontsector->floorheight || backsector->floorheight >= frontsector->ceilingheight)
  570.            {
  571.             // closed door
  572.             markceiling = markfloor = true;
  573.            }
  575.         if (worldhigh < worldtop)
  576.            {
  577.             // top texture
  578.             toptexture = texturetranslation[sidedef->toptexture];
  579.             if (linedef->flags & ML_DONTPEGTOP)
  580.                {
  581.                 // top of texture at top
  582.                 rw_toptexturemid = worldtop;
  583.                }
  584.             else
  585.                {
  586.                 vtop = backsector->ceilingheight + textureheight[sidedef->toptexture];
  587.                 // bottom of texture
  588.                 rw_toptexturemid = vtop - viewz;
  589.                }
  590.            }
  591.         if (worldlow > worldbottom)
  592.            {
  593.             // bottom texture
  594.             bottomtexture = texturetranslation[sidedef->bottomtexture];
  595.             if (linedef->flags & ML_DONTPEGBOTTOM )
  596.                {
  597.                 // bottom of texture at bottom
  598.                 // top of texture at top
  599.                 rw_bottomtexturemid = worldtop;
  600.                }
  601.             else // top of texture at top
  602.                 rw_bottomtexturemid = worldlow;
  603.            }
  604.         rw_toptexturemid += sidedef->rowoffset;
  605.         rw_bottomtexturemid += sidedef->rowoffset;
  607.         // allocate space for masked texture tables
  608.         if (sidedef->midtexture)
  609.            {
  610.             // masked midtexture
  611.             maskedtexture = true;
  612.             ds_p->maskedtexturecol = maskedtexturecol = lastopening - rw_x;
  613.             lastopening += rw_stopx - rw_x;
  614.            }
  615.        }
  616.     
  617.     // calculate rw_offset (only needed for textured lines)
  618.     segtextured = midtexture | toptexture | bottomtexture | maskedtexture;
  620.     if (segtextured)
  621.        {
  622.         offsetangle = rw_normalangle-rw_angle1;
  624.         if (offsetangle > ANG180)
  625.             offsetangle = (offsetangle * -1);
  627.         if (offsetangle > ANG90)
  628.             offsetangle = ANG90;
  630.         sineval = finesine[offsetangle >>ANGLETOFINESHIFT];
  631.         rw_offset = FixedMul (hyp, sineval);
  633.         if (rw_normalangle-rw_angle1 < ANG180)
  634.             rw_offset = -rw_offset;
  636.         rw_offset += sidedef->textureoffset + curline->offset;
  637.         rw_centerangle = ANG90 + viewangle - rw_normalangle;
  639.         // calculate light table
  640.         //  use different light tables
  641.         //  for horizontal / vertical / diagonal
  642.         // OPTIMIZE: get rid of LIGHTSEGSHIFT globally
  643.         if (!fixedcolormap)
  644.            {
  645.             lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT)+extralight;
  647.             if (curline->v1->y == curline->v2->y)
  648.                 lightnum--;
  649.             else
  650.             if (curline->v1->x == curline->v2->x)
  651.                 lightnum++;
  653.             if (lightnum < 0)
  654.                 walllights = scalelight[0];
  655.             else
  656.             if (lightnum >= LIGHTLEVELS)
  657.                 walllights = scalelight[LIGHTLEVELS-1];
  658.             else
  659.                 walllights = scalelight[lightnum];
  660.            }
  661.        }
  662.     
  663.     // if a floor / ceiling plane is on the wrong side
  664.     //  of the view plane, it is definitely invisible
  665.     //  and doesn't need to be marked.
  666.     
  667.   
  668.     if (frontsector->floorheight >= viewz)
  669.        {
  670.         // above view plane
  671.         markfloor = false;
  672.        }
  673.     
  674.     if (frontsector->ceilingheight <= viewz && frontsector->ceilingpic != skyflatnum)
  675.        {
  676.         // below view plane
  677.         markceiling = false;
  678.        }
  680.     
  681.     // calculate incremental stepping values for texture edges
  682.     worldtop >>= 4;
  683.     worldbottom >>= 4;
  685.     topstep = -FixedMul (rw_scalestep, worldtop);
  686.     topfrac = (centeryfrac>>4) - FixedMul (worldtop, rw_scale);
  688.     bottomstep = -FixedMul (rw_scalestep,worldbottom);
  689.     bottomfrac = (centeryfrac>>4) - FixedMul (worldbottom, rw_scale);
  691.     if (backsector)
  692.        {
  693.         worldhigh >>= 4;
  694.         worldlow >>= 4;
  696.         if (worldhigh < worldtop)
  697.            {
  698.             pixhigh = (centeryfrac>>4) - FixedMul (worldhigh, rw_scale);
  699.             pixhighstep = -FixedMul (rw_scalestep,worldhigh);
  700.            }
  702.         if (worldlow > worldbottom)
  703.            {
  704.             pixlow = (centeryfrac>>4) - FixedMul (worldlow, rw_scale);
  705.             pixlowstep = -FixedMul (rw_scalestep,worldlow);
  706.            }
  707.        }
  708.     
  709.     // render it
  710.     if (markceiling)
  711. ceilingplane = R_CheckPlane (ceilingplane, rw_x, rw_stopx-1);
  712.     
  713.     if (markfloor)
  714. floorplane = R_CheckPlane (floorplane, rw_x, rw_stopx-1);
  716.     R_RenderSegLoop ();
  717.     
  718.     // save sprite clipping info
  719.     if ( ((ds_p->silhouette & SIL_TOP) || maskedtexture) && !ds_p->sprtopclip)
  720.        {
  721.         memcpy (lastopening, ceilingclip+start, 2*(rw_stopx-start));
  722.         ds_p->sprtopclip = lastopening - start;
  723.         lastopening += rw_stopx - start;
  724.        }
  725.     
  726.     if ( ((ds_p->silhouette & SIL_BOTTOM) || maskedtexture) && !ds_p->sprbottomclip)
  727.        {
  728.         memcpy (lastopening, floorclip+start, 2*(rw_stopx-start));
  729.         ds_p->sprbottomclip = lastopening - start;
  730.         lastopening += rw_stopx - start;
  731.        }
  733.     if (maskedtexture && !(ds_p->silhouette&SIL_TOP))
  734.        {
  735.         ds_p->silhouette |= SIL_TOP;
  736.         ds_p->tsilheight = MININT;
  737.        }
  738.     if (maskedtexture && !(ds_p->silhouette&SIL_BOTTOM))
  739.        {
  740.         ds_p->silhouette |= SIL_BOTTOM;
  741.         ds_p->bsilheight = MAXINT;
  742.        }
  743.     ds_p++;
  744.    }