src/r_segs.c

   1 // Emacs style mode select   -*- C++ -*-
   2 //-----------------------------------------------------------------------------
   3 //
   4 // Copyright(C) 1993-1996 Id Software, Inc.
   5 // Copyright(C) 2005 Simon Howard
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License
   9 // as published by the Free Software Foundation; either version 2
  10 // of the License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20 // 02111-1307, USA.
  21 //
  22 // DESCRIPTION:
  23 //      All the clipping: columns, horizontal spans, sky columns.
  24 //
  25 //-----------------------------------------------------------------------------
  26
  27
  28
  29
  30
  31
  32
  33 #include <stdlib.h>
  34
  35 #include "i_system.h"
  36
  37 #include "doomdef.h"
  38 #include "doomstat.h"
  39
  40 #include "r_local.h"
  41 #include "r_sky.h"
  42
  43
  44 // OPTIMIZE: closed two sided lines as single sided
  45
  46 // True if any of the segs textures might be visible.
  47 boolean         segtextured;
  48
  49 // False if the back side is the same plane.
  50 boolean         markfloor;
  51 boolean         markceiling;
  52
  53 boolean         maskedtexture;
  54 int             toptexture;
  55 int             bottomtexture;
  56 int             midtexture;
  57
  58
  59 angle_t         rw_normalangle;
  60 // angle to line origin
  61 int             rw_angle1;
  62
  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;
  76
  77 int             worldtop;
  78 int             worldbottom;
  79 int             worldhigh;
  80 int             worldlow;
  81
  82 fixed_t         pixhigh;
  83 fixed_t         pixlow;
  84 fixed_t         pixhighstep;
  85 fixed_t         pixlowstep;
  86
  87 fixed_t         topfrac;
  88 fixed_t         topstep;
  89
  90 fixed_t         bottomfrac;
  91 fixed_t         bottomstep;
  92
  93
  94 lighttable_t**  walllights;
  95
  96 short*          maskedtexturecol;
  97
  98
  99
 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];
 122
 123     lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT)+extralight;
 124
 125     if (curline->v1->y == curline->v2->y)
 126         lightnum--;
 127     else if (curline->v1->x == curline->v2->x)
 128         lightnum++;
 129
 130     if (lightnum < 0)
 131         walllights = scalelight[0];
 132     else if (lightnum >= LIGHTLEVELS)
 133         walllights = scalelight[LIGHTLEVELS-1];
 134     else
 135         walllights = scalelight[lightnum];
 136
 137     maskedtexturecol = ds->maskedtexturecol;
 138
 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;
 158
 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] != SHRT_MAX)
 167         {
 168             if (!fixedcolormap)
 169             {
 170                 index = spryscale>>LIGHTSCALESHIFT;
 171
 172                 if (index >=  MAXLIGHTSCALE )
 173                     index = MAXLIGHTSCALE-1;
 174
 175                 dc_colormap = walllights[index];
 176             }
 177
 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);
 184
 185             R_DrawMaskedColumn (col);
 186             maskedtexturecol[dc_x] = SHRT_MAX;
 187         }
 188         spryscale += rw_scalestep;
 189     }
 190
 191 }
 192
 193
 194
 195
 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)
 206
 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;
 217
 218     for ( ; rw_x < rw_stopx ; rw_x++)
 219     {
 220         // mark floor / ceiling areas
 221         yl = (topfrac+HEIGHTUNIT-1)>>HEIGHTBITS;
 222
 223         // no space above wall?
 224         if (yl < ceilingclip[rw_x]+1)
 225             yl = ceilingclip[rw_x]+1;
 226
 227         if (markceiling)
 228         {
 229             top = ceilingclip[rw_x]+1;
 230             bottom = yl-1;
 231
 232             if (bottom >= floorclip[rw_x])
 233                 bottom = floorclip[rw_x]-1;
 234
 235             if (top <= bottom)
 236             {
 237                 ceilingplane->top[rw_x] = top;
 238                 ceilingplane->bottom[rw_x] = bottom;
 239             }
 240         }
 241
 242         yh = bottomfrac>>HEIGHTBITS;
 243
 244         if (yh >= floorclip[rw_x])
 245             yh = floorclip[rw_x]-1;
 246
 247         if (markfloor)
 248         {
 249             top = yh+1;
 250             bottom = floorclip[rw_x]-1;
 251             if (top <= ceilingclip[rw_x])
 252                 top = ceilingclip[rw_x]+1;
 253             if (top <= bottom)
 254             {
 255                 floorplane->top[rw_x] = top;
 256                 floorplane->bottom[rw_x] = bottom;
 257             }
 258         }
 259
 260         // texturecolumn and lighting are independent of wall tiers
 261         if (segtextured)
 262         {
 263             // calculate texture offset
 264             angle = (rw_centerangle + xtoviewangle[rw_x])>>ANGLETOFINESHIFT;
 265             texturecolumn = rw_offset-FixedMul(finetangent[angle],rw_distance);
 266             texturecolumn >>= FRACBITS;
 267             // calculate lighting
 268             index = rw_scale>>LIGHTSCALESHIFT;
 269
 270             if (index >=  MAXLIGHTSCALE )
 271                 index = MAXLIGHTSCALE-1;
 272
 273             dc_colormap = walllights[index];
 274             dc_x = rw_x;
 275             dc_iscale = 0xffffffffu / (unsigned)rw_scale;
 276         }
 277         else
 278         {
 279             // purely to shut up the compiler
 280
 281             texturecolumn = 0;
 282         }
 283
 284         // draw the wall tiers
 285         if (midtexture)
 286         {
 287             // single sided line
 288             dc_yl = yl;
 289             dc_yh = yh;
 290             dc_texturemid = rw_midtexturemid;
 291             dc_source = R_GetColumn(midtexture,texturecolumn);
 292             colfunc ();
 293             ceilingclip[rw_x] = viewheight;
 294             floorclip[rw_x] = -1;
 295         }
 296         else
 297         {
 298             // two sided line
 299             if (toptexture)
 300             {
 301                 // top wall
 302                 mid = pixhigh>>HEIGHTBITS;
 303                 pixhigh += pixhighstep;
 304
 305                 if (mid >= floorclip[rw_x])
 306                     mid = floorclip[rw_x]-1;
 307
 308                 if (mid >= yl)
 309                 {
 310                     dc_yl = yl;
 311                     dc_yh = mid;
 312                     dc_texturemid = rw_toptexturemid;
 313                     dc_source = R_GetColumn(toptexture,texturecolumn);
 314                     colfunc ();
 315                     ceilingclip[rw_x] = mid;
 316                 }
 317                 else
 318                     ceilingclip[rw_x] = yl-1;
 319             }
 320             else
 321             {
 322                 // no top wall
 323                 if (markceiling)
 324                     ceilingclip[rw_x] = yl-1;
 325             }
 326
 327             if (bottomtexture)
 328             {
 329                 // bottom wall
 330                 mid = (pixlow+HEIGHTUNIT-1)>>HEIGHTBITS;
 331                 pixlow += pixlowstep;
 332
 333                 // no space above wall?
 334                 if (mid <= ceilingclip[rw_x])
 335                     mid = ceilingclip[rw_x]+1;
 336
 337                 if (mid <= yh)
 338                 {
 339                     dc_yl = mid;
 340                     dc_yh = yh;
 341                     dc_texturemid = rw_bottomtexturemid;
 342                     dc_source = R_GetColumn(bottomtexture,
 343                                             texturecolumn);
 344                     colfunc ();
 345                     floorclip[rw_x] = mid;
 346                 }
 347                 else
 348                     floorclip[rw_x] = yh+1;
 349             }
 350             else
 351             {
 352                 // no bottom wall
 353                 if (markfloor)
 354                     floorclip[rw_x] = yh+1;
 355             }
 356
 357             if (maskedtexture)
 358             {
 359                 // save texturecol
 360                 //  for backdrawing of masked mid texture
 361                 maskedtexturecol[rw_x] = texturecolumn;
 362             }
 363         }
 364
 365         rw_scale += rw_scalestep;
 366         topfrac += topstep;
 367         bottomfrac += bottomstep;
 368     }
 369 }
 370
 371
 372
 373
 374 //
 375 // R_StoreWallRange
 376 // A wall segment will be drawn
 377 //  between start and stop pixels (inclusive).
 378 //
 379 void
 380 R_StoreWallRange
 381 ( int   start,
 382   int   stop )
 383 {
 384     fixed_t             hyp;
 385     fixed_t             sineval;
 386     angle_t             distangle, offsetangle;
 387     fixed_t             vtop;
 388     int                 lightnum;
 389
 390     // don't overflow and crash
 391     if (ds_p == &drawsegs[MAXDRAWSEGS])
 392         return;
 393
 394 #ifdef RANGECHECK
 395     if (start >=viewwidth || start > stop)
 396         I_Error ("Bad R_RenderWallRange: %i to %i", start , stop);
 397 #endif
 398
 399     sidedef = curline->sidedef;
 400     linedef = curline->linedef;
 401
 402     // mark the segment as visible for auto map
 403     linedef->flags |= ML_MAPPED;
 404
 405     // calculate rw_distance for scale calculation
 406     rw_normalangle = curline->angle + ANG90;
 407     offsetangle = abs(rw_normalangle-rw_angle1);
 408
 409     if (offsetangle > ANG90)
 410         offsetangle = ANG90;
 411
 412     distangle = ANG90 - offsetangle;
 413     hyp = R_PointToDist (curline->v1->x, curline->v1->y);
 414     sineval = finesine[distangle>>ANGLETOFINESHIFT];
 415     rw_distance = FixedMul (hyp, sineval);
 416
 417
 418     ds_p->x1 = rw_x = start;
 419     ds_p->x2 = stop;
 420     ds_p->curline = curline;
 421     rw_stopx = stop+1;
 422
 423     // calculate scale at both ends and step
 424     ds_p->scale1 = rw_scale =
 425         R_ScaleFromGlobalAngle (viewangle + xtoviewangle[start]);
 426
 427     if (stop > start )
 428     {
 429         ds_p->scale2 = R_ScaleFromGlobalAngle (viewangle + xtoviewangle[stop]);
 430         ds_p->scalestep = rw_scalestep =
 431             (ds_p->scale2 - rw_scale) / (stop-start);
 432     }
 433     else
 434     {
 435         // UNUSED: try to fix the stretched line bug
 436 #if 0
 437         if (rw_distance < FRACUNIT/2)
 438         {
 439             fixed_t             trx,try;
 440             fixed_t             gxt,gyt;
 441
 442             trx = curline->v1->x - viewx;
 443             try = curline->v1->y - viewy;
 444
 445             gxt = FixedMul(trx,viewcos);
 446             gyt = -FixedMul(try,viewsin);
 447             ds_p->scale1 = FixedDiv(projection, gxt-gyt)<<detailshift;
 448         }
 449 #endif
 450         ds_p->scale2 = ds_p->scale1;
 451     }
 452
 453     // calculate texture boundaries
 454     //  and decide if floor / ceiling marks are needed
 455     worldtop = frontsector->ceilingheight - viewz;
 456     worldbottom = frontsector->floorheight - viewz;
 457
 458     midtexture = toptexture = bottomtexture = maskedtexture = 0;
 459     ds_p->maskedtexturecol = NULL;
 460
 461     if (!backsector)
 462     {
 463         // single sided line
 464         midtexture = texturetranslation[sidedef->midtexture];
 465         // a single sided line is terminal, so it must mark ends
 466         markfloor = markceiling = true;
 467         if (linedef->flags & ML_DONTPEGBOTTOM)
 468         {
 469             vtop = frontsector->floorheight +
 470                 textureheight[sidedef->midtexture];
 471             // bottom of texture at bottom
 472             rw_midtexturemid = vtop - viewz;
 473         }
 474         else
 475         {
 476             // top of texture at top
 477             rw_midtexturemid = worldtop;
 478         }
 479         rw_midtexturemid += sidedef->rowoffset;
 480
 481         ds_p->silhouette = SIL_BOTH;
 482         ds_p->sprtopclip = screenheightarray;
 483         ds_p->sprbottomclip = negonearray;
 484         ds_p->bsilheight = INT_MAX;
 485         ds_p->tsilheight = INT_MIN;
 486     }
 487     else
 488     {
 489         // two sided line
 490         ds_p->sprtopclip = ds_p->sprbottomclip = NULL;
 491         ds_p->silhouette = 0;
 492
 493         if (frontsector->floorheight > backsector->floorheight)
 494         {
 495             ds_p->silhouette = SIL_BOTTOM;
 496             ds_p->bsilheight = frontsector->floorheight;
 497         }
 498         else if (backsector->floorheight > viewz)
 499         {
 500             ds_p->silhouette = SIL_BOTTOM;
 501             ds_p->bsilheight = INT_MAX;
 502             // ds_p->sprbottomclip = negonearray;
 503         }
 504
 505         if (frontsector->ceilingheight < backsector->ceilingheight)
 506         {
 507             ds_p->silhouette |= SIL_TOP;
 508             ds_p->tsilheight = frontsector->ceilingheight;
 509         }
 510         else if (backsector->ceilingheight < viewz)
 511         {
 512             ds_p->silhouette |= SIL_TOP;
 513             ds_p->tsilheight = INT_MIN;
 514             // ds_p->sprtopclip = screenheightarray;
 515         }
 516
 517         if (backsector->ceilingheight <= frontsector->floorheight)
 518         {
 519             ds_p->sprbottomclip = negonearray;
 520             ds_p->bsilheight = INT_MAX;
 521             ds_p->silhouette |= SIL_BOTTOM;
 522         }
 523
 524         if (backsector->floorheight >= frontsector->ceilingheight)
 525         {
 526             ds_p->sprtopclip = screenheightarray;
 527             ds_p->tsilheight = INT_MIN;
 528             ds_p->silhouette |= SIL_TOP;
 529         }
 530
 531         worldhigh = backsector->ceilingheight - viewz;
 532         worldlow = backsector->floorheight - viewz;
 533
 534         // hack to allow height changes in outdoor areas
 535         if (frontsector->ceilingpic == skyflatnum
 536             && backsector->ceilingpic == skyflatnum)
 537         {
 538             worldtop = worldhigh;
 539         }
 540
 541
 542         if (worldlow != worldbottom
 543             || backsector->floorpic != frontsector->floorpic
 544             || backsector->lightlevel != frontsector->lightlevel)
 545         {
 546             markfloor = true;
 547         }
 548         else
 549         {
 550             // same plane on both sides
 551             markfloor = false;
 552         }
 553
 554
 555         if (worldhigh != worldtop
 556             || backsector->ceilingpic != frontsector->ceilingpic
 557             || backsector->lightlevel != frontsector->lightlevel)
 558         {
 559             markceiling = true;
 560         }
 561         else
 562         {
 563             // same plane on both sides
 564             markceiling = false;
 565         }
 566
 567         if (backsector->ceilingheight <= frontsector->floorheight
 568             || backsector->floorheight >= frontsector->ceilingheight)
 569         {
 570             // closed door
 571             markceiling = markfloor = true;
 572         }
 573
 574
 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 =
 587                     backsector->ceilingheight
 588                     + textureheight[sidedef->toptexture];
 589
 590                 // bottom of texture
 591                 rw_toptexturemid = vtop - viewz;
 592             }
 593         }
 594         if (worldlow > worldbottom)
 595         {
 596             // bottom texture
 597             bottomtexture = texturetranslation[sidedef->bottomtexture];
 598
 599             if (linedef->flags & ML_DONTPEGBOTTOM )
 600             {
 601                 // bottom of texture at bottom
 602                 // top of texture at top
 603                 rw_bottomtexturemid = worldtop;
 604             }
 605             else        // top of texture at top
 606                 rw_bottomtexturemid = worldlow;
 607         }
 608         rw_toptexturemid += sidedef->rowoffset;
 609         rw_bottomtexturemid += sidedef->rowoffset;
 610
 611         // allocate space for masked texture tables
 612         if (sidedef->midtexture)
 613         {
 614             // masked midtexture
 615             maskedtexture = true;
 616             ds_p->maskedtexturecol = maskedtexturecol = lastopening - rw_x;
 617             lastopening += rw_stopx - rw_x;
 618         }
 619     }
 620
 621     // calculate rw_offset (only needed for textured lines)
 622     segtextured = midtexture | toptexture | bottomtexture | maskedtexture;
 623
 624     if (segtextured)
 625     {
 626         offsetangle = rw_normalangle-rw_angle1;
 627
 628         if (offsetangle > ANG180)
 629             offsetangle = -offsetangle;
 630
 631         if (offsetangle > ANG90)
 632             offsetangle = ANG90;
 633
 634         sineval = finesine[offsetangle >>ANGLETOFINESHIFT];
 635         rw_offset = FixedMul (hyp, sineval);
 636
 637         if (rw_normalangle-rw_angle1 < ANG180)
 638             rw_offset = -rw_offset;
 639
 640         rw_offset += sidedef->textureoffset + curline->offset;
 641         rw_centerangle = ANG90 + viewangle - rw_normalangle;
 642
 643         // calculate light table
 644         //  use different light tables
 645         //  for horizontal / vertical / diagonal
 646         // OPTIMIZE: get rid of LIGHTSEGSHIFT globally
 647         if (!fixedcolormap)
 648         {
 649             lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT)+extralight;
 650
 651             if (curline->v1->y == curline->v2->y)
 652                 lightnum--;
 653             else if (curline->v1->x == curline->v2->x)
 654                 lightnum++;
 655
 656             if (lightnum < 0)
 657                 walllights = scalelight[0];
 658             else if (lightnum >= LIGHTLEVELS)
 659                 walllights = scalelight[LIGHTLEVELS-1];
 660             else
 661                 walllights = scalelight[lightnum];
 662         }
 663     }
 664
 665     // if a floor / ceiling plane is on the wrong side
 666     //  of the view plane, it is definitely invisible
 667     //  and doesn't need to be marked.
 668
 669
 670     if (frontsector->floorheight >= viewz)
 671     {
 672         // above view plane
 673         markfloor = false;
 674     }
 675
 676     if (frontsector->ceilingheight <= viewz
 677         && frontsector->ceilingpic != skyflatnum)
 678     {
 679         // below view plane
 680         markceiling = false;
 681     }
 682
 683
 684     // calculate incremental stepping values for texture edges
 685     worldtop >>= 4;
 686     worldbottom >>= 4;
 687
 688     topstep = -FixedMul (rw_scalestep, worldtop);
 689     topfrac = (centeryfrac>>4) - FixedMul (worldtop, rw_scale);
 690
 691     bottomstep = -FixedMul (rw_scalestep,worldbottom);
 692     bottomfrac = (centeryfrac>>4) - FixedMul (worldbottom, rw_scale);
 693
 694     if (backsector)
 695     {
 696         worldhigh >>= 4;
 697         worldlow >>= 4;
 698
 699         if (worldhigh < worldtop)
 700         {
 701             pixhigh = (centeryfrac>>4) - FixedMul (worldhigh, rw_scale);
 702             pixhighstep = -FixedMul (rw_scalestep,worldhigh);
 703         }
 704
 705         if (worldlow > worldbottom)
 706         {
 707             pixlow = (centeryfrac>>4) - FixedMul (worldlow, rw_scale);
 708             pixlowstep = -FixedMul (rw_scalestep,worldlow);
 709         }
 710     }
 711
 712     // render it
 713     if (markceiling)
 714         ceilingplane = R_CheckPlane (ceilingplane, rw_x, rw_stopx-1);
 715
 716     if (markfloor)
 717         floorplane = R_CheckPlane (floorplane, rw_x, rw_stopx-1);
 718
 719     R_RenderSegLoop ();
 720
 721
 722     // save sprite clipping info
 723     if ( ((ds_p->silhouette & SIL_TOP) || maskedtexture)
 724          && !ds_p->sprtopclip)
 725     {
 726         memcpy (lastopening, ceilingclip+start, 2*(rw_stopx-start));
 727         ds_p->sprtopclip = lastopening - start;
 728         lastopening += rw_stopx - start;
 729     }
 730
 731     if ( ((ds_p->silhouette & SIL_BOTTOM) || maskedtexture)
 732          && !ds_p->sprbottomclip)
 733     {
 734         memcpy (lastopening, floorclip+start, 2*(rw_stopx-start));
 735         ds_p->sprbottomclip = lastopening - start;
 736         lastopening += rw_stopx - start;
 737     }
 738
 739     if (maskedtexture && !(ds_p->silhouette&SIL_TOP))
 740     {
 741         ds_p->silhouette |= SIL_TOP;
 742         ds_p->tsilheight = INT_MIN;
 743     }
 744     if (maskedtexture && !(ds_p->silhouette&SIL_BOTTOM))
 745     {
 746         ds_p->silhouette |= SIL_BOTTOM;
 747         ds_p->bsilheight = INT_MAX;
 748     }
 749     ds_p++;
 750 }
 751