Patch #2969 - Doom! Currently only working on the H300.

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@9312 a1c6a512-1295-4272-9138-f99709370657

1 files changed, 843 insertions, 0 deletions

diff --git a/apps/plugins/doom/r_segs.c b/apps/plugins/doom/r_segs.c
new file mode 100644
index 0000000000..4771132c77
--- /dev/null
+++ b/apps/plugins/doom/r_segs.c
@@ -0,0 +1,843 @@
+/* Emacs style mode select   -*- C++ -*-
+ *-----------------------------------------------------------------------------
+ *
+ *
+ *  PrBoom a Doom port merged with LxDoom and LSDLDoom
+ *  based on BOOM, a modified and improved DOOM engine
+ *  Copyright (C) 1999 by
+ *  id Software, Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
+ *  Copyright (C) 1999-2000 by
+ *  Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version 2
+ *  of the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ *  02111-1307, USA.
+ *
+ * DESCRIPTION:
+ *      All the clipping: columns, horizontal spans, sky columns.
+ *
+ *-----------------------------------------------------------------------------*/
+//
+// 4/25/98, 5/2/98 killough: reformatted, beautified
+
+#include "doomstat.h"
+#include "r_main.h"
+#include "r_bsp.h"
+#include "r_plane.h"
+#include "r_things.h"
+#include "r_draw.h"
+#include "w_wad.h"
+//#include "lprintf.h"
+#include "rockmacros.h"
+
+// OPTIMIZE: closed two sided lines as single sided
+
+// killough 1/6/98: replaced globals with statics where appropriate
+
+// True if any of the segs textures might be visible.
+boolean  segtextured;
+boolean  markfloor;      // False if the back side is the same plane.
+boolean  markceiling;
+static boolean  maskedtexture;
+static int      toptexture;
+static int      bottomtexture;
+static int      midtexture;
+
+static fixed_t  toptexheight, midtexheight, bottomtexheight; // cph
+
+angle_t  rw_normalangle;// angle to line origin
+int  rw_angle1;
+fixed_t  rw_distance;
+lighttable_t** walllights;
+
+//
+// regular wall
+//
+int      rw_x;
+int      rw_stopx;
+static angle_t  rw_centerangle;
+static fixed_t  rw_offset;
+static fixed_t  rw_scale;
+static fixed_t  rw_scalestep;
+static fixed_t  rw_midtexturemid;
+static fixed_t  rw_toptexturemid;
+static fixed_t  rw_bottomtexturemid;
+static int      worldtop;
+static int      worldbottom;
+static int      worldhigh;
+static int      worldlow;
+static fixed_t  pixhigh;
+static fixed_t  pixlow;
+static fixed_t  pixhighstep;
+static fixed_t  pixlowstep;
+static fixed_t  topfrac;
+static fixed_t  topstep;
+static fixed_t  bottomfrac;
+static fixed_t  bottomstep;
+static short    *maskedtexturecol;
+
+//
+// R_ScaleFromGlobalAngle
+// Returns the texture mapping scale
+//  for the current line (horizontal span)
+//  at the given angle.
+// rw_distance must be calculated first.
+//
+// killough 5/2/98: reformatted, cleaned up
+static fixed_t R_ScaleFromGlobalAngle (angle_t visangle)
+{
+   int   anglea = ANG90 + (visangle-viewangle);
+   int   angleb = ANG90 + (visangle-rw_normalangle);
+   int   sinea = finesine[anglea>>ANGLETOFINESHIFT];
+   int   sineb = finesine[angleb>>ANGLETOFINESHIFT];
+   fixed_t  num = FixedMul(projection,sineb);
+   int   den = FixedMul(rw_distance,sinea);
+
+   return den > num>>16 ? (num=FixedDiv (num, den)) > 64*FRACUNIT ?
+      64*FRACUNIT : num < 256 ? 256 : num : 64*FRACUNIT ;
+}
+//
+// R_RenderMaskedSegRange
+//
+
+int fake_contrast IBSS_ATTR;
+
+void R_RenderMaskedSegRange(drawseg_t *ds, int x1, int x2)
+{
+   column_t *col;
+   int      lightnum;
+   int      texnum;
+   sector_t tempsec;      // killough 4/13/98
+
+   // Calculate light table.
+   // Use different light tables
+   //   for horizontal / vertical / diagonal. Diagonal?
+
+   curline = ds->curline;  // OPTIMIZE: get rid of LIGHTSEGSHIFT globally
+
+   // killough 4/11/98: draw translucent 2s normal textures
+
+   colfunc = R_DrawColumn;
+   if (curline->linedef->tranlump >= 0 && general_translucency)
+   {
+      colfunc = R_DrawTLColumn;
+      tranmap = main_tranmap;
+      if (curline->linedef->tranlump > 0)
+         tranmap = W_CacheLumpNum(curline->linedef->tranlump-1);
+   }
+
+   // killough 4/11/98: end translucent 2s normal code
+
+   frontsector = curline->frontsector;
+   backsector = curline->backsector;
+
+   texnum = texturetranslation[curline->sidedef->midtexture];
+
+   // killough 4/13/98: get correct lightlevel for 2s normal textures
+   lightnum = (R_FakeFlat(frontsector, &tempsec, NULL, NULL, false)
+                  ->lightlevel >> LIGHTSEGSHIFT)+extralight;
+
+   /* cph - ...what is this for? adding contrast to rooms?
+    * It looks crap in outdoor areas */
+   if (fake_contrast) {
+      if (curline->v1->y == curline->v2->y)
+         lightnum--;
+      else
+         if (curline->v1->x == curline->v2->x)
+            lightnum++;
+   }
+
+   walllights = lightnum >= LIGHTLEVELS ? scalelight[LIGHTLEVELS-1] :
+                lightnum <  0           ? scalelight[0] : scalelight[lightnum];
+
+   maskedtexturecol = ds->maskedtexturecol;
+
+   rw_scalestep = ds->scalestep;
+   spryscale = ds->scale1 + (x1 - ds->x1)*rw_scalestep;
+   mfloorclip = ds->sprbottomclip;
+   mceilingclip = ds->sprtopclip;
+
+   // find positioning
+   if (curline->linedef->flags & ML_DONTPEGBOTTOM)
+   {
+      dc_texturemid = frontsector->floorheight > backsector->floorheight
+                      ? frontsector->floorheight : backsector->floorheight;
+      dc_texturemid = dc_texturemid + textureheight[texnum] - viewz;
+   }
+   else
+   {
+      dc_texturemid =frontsector->ceilingheight<backsector->ceilingheight
+                     ? frontsector->ceilingheight : backsector->ceilingheight;
+      dc_texturemid = dc_texturemid - viewz;
+   }
+
+   dc_texturemid += curline->sidedef->rowoffset;
+
+   if (fixedcolormap)
+      dc_colormap = fixedcolormap;
+
+   // draw the columns
+   for (dc_x = x1 ; dc_x <= x2 ; dc_x++, spryscale += rw_scalestep)
+      if (maskedtexturecol[dc_x] != SHRT_MAX)
+      {
+         if (!fixedcolormap)      // calculate lighting
+         {
+            unsigned index = spryscale>>LIGHTSCALESHIFT;
+
+            if (index >=  MAXLIGHTSCALE )
+               index = MAXLIGHTSCALE-1;
+
+            dc_colormap = walllights[index];
+         }
+
+         // killough 3/2/98:
+         //
+         // This calculation used to overflow and cause crashes in Doom:
+         //
+         // sprtopscreen = centeryfrac - FixedMul(dc_texturemid, spryscale);
+         //
+         // This code fixes it, by using double-precision intermediate
+         // arithmetic and by skipping the drawing of 2s normals whose
+         // mapping to screen coordinates is totally out of range:
+
+         {
+            int_64_t t = ((int_64_t) centeryfrac << FRACBITS) -
+                         (int_64_t) dc_texturemid * spryscale;
+            if (t + (int_64_t) textureheight[texnum] * spryscale < 0 ||
+                  t > (int_64_t) SCREENHEIGHT << FRACBITS*2)
+               continue;        // skip if the texture is out of screen's range
+            sprtopscreen = (long)(t >> FRACBITS);
+         }
+
+         dc_iscale = 0xffffffffu / (unsigned) spryscale;
+
+         // killough 1/25/98: here's where Medusa came in, because
+         // it implicitly assumed that the column was all one patch.
+         // Originally, Doom did not construct complete columns for
+         // multipatched textures, so there were no header or trailer
+         // bytes in the column referred to below, which explains
+         // the Medusa effect. The fix is to construct true columns
+         // when forming multipatched textures (see r_data.c).
+
+         // draw the texture
+         col = (column_t *)((byte *)
+                            R_GetColumn(texnum,maskedtexturecol[dc_x]) - 3);
+         R_DrawMaskedColumn (col);
+         maskedtexturecol[dc_x] = SHRT_MAX;
+      }
+
+   // Except for main_tranmap, mark others purgable at this point
+   if (curline->linedef->tranlump > 0 && general_translucency)
+      W_UnlockLumpNum(curline->linedef->tranlump-1); // cph - unlock it
+}
+
+//
+// R_RenderSegLoop
+// Draws zero, one, or two textures (and possibly a masked texture) for walls.
+// Can draw or mark the starting pixel of floor and ceiling textures.
+// CALLED: CORE LOOPING ROUTINE.
+//
+
+extern byte solidcol[SCREENWIDTH];
+#define HEIGHTBITS 12
+#define HEIGHTUNIT (1<<HEIGHTBITS)
+static int didsolidcol; /* True if at least one column was marked solid */
+
+static void R_RenderSegLoop (void)
+{
+   fixed_t  texturecolumn = 0;   // shut up compiler warning
+   for ( ; rw_x < rw_stopx ; rw_x++)
+   {
+
+      // mark floor / ceiling areas
+
+      int yh = bottomfrac>>HEIGHTBITS;
+      int yl = (topfrac+HEIGHTUNIT-1)>>HEIGHTBITS;
+
+      // no space above wall?
+      int bottom,top = ceilingclip[rw_x]+1;
+
+      if (yl < top)
+         yl = top;
+
+      if (markceiling)
+      {
+         bottom = yl-1;
+
+         if (bottom >= floorclip[rw_x])
+            bottom = floorclip[rw_x]-1;
+
+         if (top <= bottom)
+         {
+            ceilingplane->top[rw_x] = top;
+            ceilingplane->bottom[rw_x] = bottom;
+         }
+      }
+
+      //      yh = bottomfrac>>HEIGHTBITS;
+
+      bottom = floorclip[rw_x]-1;
+      if (yh > bottom)
+         yh = bottom;
+
+      if (markfloor)
+      {
+
+         top  = yh < ceilingclip[rw_x] ? ceilingclip[rw_x] : yh;
+
+         if (++top <= bottom)
+         {
+            floorplane->top[rw_x] = top;
+            floorplane->bottom[rw_x] = bottom;
+         }
+      }
+
+      // texturecolumn and lighting are independent of wall tiers
+      if (segtextured)
+      {
+         unsigned index;
+
+         // calculate texture offset
+         angle_t angle =(rw_centerangle+xtoviewangle[rw_x])>>ANGLETOFINESHIFT;
+
+         texturecolumn = rw_offset-FixedMul(finetangent[angle],rw_distance);
+         texturecolumn >>= FRACBITS;
+         // calculate lighting
+         index = rw_scale>>LIGHTSCALESHIFT;
+
+         if (index >=  MAXLIGHTSCALE )
+            index = MAXLIGHTSCALE-1;
+
+         dc_colormap = walllights[index];
+         dc_x = rw_x;
+         dc_iscale = 0xffffffffu / (unsigned)rw_scale;
+      }
+
+      // draw the wall tiers
+      if (midtexture)
+      {
+
+         dc_yl = yl;     // single sided line
+         dc_yh = yh;
+         dc_texturemid = rw_midtexturemid;
+         dc_source = R_GetColumn(midtexture, texturecolumn);
+         dc_texheight = midtexheight;
+         colfunc ();
+         ceilingclip[rw_x] = viewheight;
+         floorclip[rw_x] = -1;
+      }
+      else
+      {
+
+         // two sided line
+         if (toptexture)
+         {
+            // top wall
+            int mid = pixhigh>>HEIGHTBITS;
+            pixhigh += pixhighstep;
+
+            if (mid >= floorclip[rw_x])
+               mid = floorclip[rw_x]-1;
+
+            if (mid >= yl)
+            {
+               dc_yl = yl;
+               dc_yh = mid;
+               dc_texturemid = rw_toptexturemid;
+               dc_source = R_GetColumn(toptexture,texturecolumn);
+               dc_texheight = toptexheight;
+               colfunc ();
+               ceilingclip[rw_x] = mid;
+            }
+            else
+               ceilingclip[rw_x] = yl-1;
+         }
+         else  // no top wall
+         {
+
+            if (markceiling)
+               ceilingclip[rw_x] = yl-1;
+         }
+
+         if (bottomtexture)          // bottom wall
+         {
+            int mid = (pixlow+HEIGHTUNIT-1)>>HEIGHTBITS;
+            pixlow += pixlowstep;
+
+            // no space above wall?
+            if (mid <= ceilingclip[rw_x])
+               mid = ceilingclip[rw_x]+1;
+
+            if (mid <= yh)
+            {
+               dc_yl = mid;
+               dc_yh = yh;
+               dc_texturemid = rw_bottomtexturemid;
+               dc_source = R_GetColumn(bottomtexture,
+                                       texturecolumn);
+               dc_texheight = bottomtexheight;
+               colfunc ();
+               floorclip[rw_x] = mid;
+            }
+            else
+               floorclip[rw_x] = yh+1;
+         }
+         else        // no bottom wall
+         {
+            if (markfloor)
+               floorclip[rw_x] = yh+1;
+         }
+
+         // cph - if we completely blocked further sight through this column,
+         // add this info to the solid columns array for r_bsp.c
+         if ((markceiling || markfloor) &&
+               (floorclip[rw_x] <= ceilingclip[rw_x] + 1)) {
+            solidcol[rw_x] = 1; didsolidcol = 1;
+         }
+
+         // save texturecol for backdrawing of masked mid texture
+         if (maskedtexture)
+            maskedtexturecol[rw_x] = texturecolumn;
+      }
+
+      rw_scale += rw_scalestep;
+      topfrac += topstep;
+      bottomfrac += bottomstep;
+   }
+}
+
+// killough 5/2/98: move from r_main.c, made static, simplified
+
+static fixed_t R_PointToDist(fixed_t x, fixed_t y)
+{
+   fixed_t dx = D_abs(x - viewx);
+   fixed_t dy = D_abs(y - viewy);
+
+   if (dy > dx)
+   {
+      fixed_t t = dx;
+      dx = dy;
+      dy = t;
+   }
+
+   return FixedDiv(dx, finesine[(tantoangle[FixedDiv(dy,dx) >> DBITS]
+                                 + ANG90) >> ANGLETOFINESHIFT]);
+}
+
+//
+// R_StoreWallRange
+// A wall segment will be drawn
+//  between start and stop pixels (inclusive).
+//
+void R_StoreWallRange(const int start, const int stop)
+{
+   fixed_t hyp;
+   fixed_t sineval;
+   angle_t distangle, offsetangle;
+
+   if (ds_p == drawsegs+maxdrawsegs)   // killough 1/98 -- fix 2s line HOM
+   {
+      unsigned pos = ds_p - drawsegs; // jff 8/9/98 fix from ZDOOM1.14a
+      unsigned newmax = maxdrawsegs ? maxdrawsegs*2 : 128; // killough
+      drawsegs = realloc(drawsegs,newmax*sizeof(*drawsegs));
+      ds_p = drawsegs + pos;          // jff 8/9/98 fix from ZDOOM1.14a
+      maxdrawsegs = newmax;
+   }
+
+   if(curline->miniseg == false) // figgi -- skip minisegs
+      curline->linedef->flags |= ML_MAPPED;
+
+
+#ifdef RANGECHECK
+   if (start >=viewwidth || start > stop)
+      I_Error ("Bad R_RenderWallRange: %i to %i", start , stop);
+#endif
+
+   sidedef = curline->sidedef;
+   linedef = curline->linedef;
+
+   // mark the segment as visible for auto map
+   linedef->flags |= ML_MAPPED;
+
+   // calculate rw_distance for scale calculation
+   rw_normalangle = curline->angle + ANG90;
+
+   offsetangle = D_abs(rw_normalangle-rw_angle1);
+
+   if (offsetangle > ANG90)
+      offsetangle = ANG90;
+
+   distangle = ANG90 - offsetangle;
+   hyp = (viewx==curline->v1->x && viewy==curline->v1->y)?
+         0 : R_PointToDist (curline->v1->x, curline->v1->y);
+   sineval = finesine[distangle>>ANGLETOFINESHIFT];
+   rw_distance = FixedMul(hyp, sineval);
+
+   ds_p->x1 = rw_x = start;
+   ds_p->x2 = stop;
+   ds_p->curline = curline;
+   rw_stopx = stop+1;
+
+   {     // killough 1/6/98, 2/1/98: remove limit on openings
+      extern short *openings;
+      extern size_t maxopenings;
+      size_t pos = lastopening - openings;
+      size_t need = (rw_stopx - start)*4 + pos;
+      if (need > maxopenings)
+      {
+         drawseg_t *ds;                //jff 8/9/98 needed for fix from ZDoom
+         short *oldopenings = openings;
+         short *oldlast = lastopening;
+
+         do
+            maxopenings = maxopenings ? maxopenings*2 : 16384;
+         while (need > maxopenings);
+         openings = realloc(openings, maxopenings * sizeof(*openings));
+         lastopening = openings + pos;
+
+         // jff 8/9/98 borrowed fix for openings from ZDOOM1.14
+         // [RH] We also need to adjust the openings pointers that
+         //    were already stored in drawsegs.
+         for (ds = drawsegs; ds < ds_p; ds++)
+         {
+#define ADJUST(p) if (ds->p + ds->x1 >= oldopenings && ds->p + ds->x1 <= oldlast)\
+            ds->p = ds->p - oldopenings + openings;
+            ADJUST (maskedtexturecol);
+            ADJUST (sprtopclip);
+            ADJUST (sprbottomclip);
+         }
+#undef ADJUST
+      }
+   }  // killough: end of code to remove limits on openings
+
+   // calculate scale at both ends and step
+
+   ds_p->scale1 = rw_scale =
+                     R_ScaleFromGlobalAngle (viewangle + xtoviewangle[start]);
+
+   if (stop > start)
+   {
+      ds_p->scale2 = R_ScaleFromGlobalAngle (viewangle + xtoviewangle[stop]);
+      ds_p->scalestep = rw_scalestep = (ds_p->scale2-rw_scale) / (stop-start);
+   }
+   else
+      ds_p->scale2 = ds_p->scale1;
+
+   // calculate texture boundaries
+   //  and decide if floor / ceiling marks are needed
+
+   worldtop = frontsector->ceilingheight - viewz;
+   worldbottom = frontsector->floorheight - viewz;
+
+   midtexture = toptexture = bottomtexture = maskedtexture = 0;
+   ds_p->maskedtexturecol = NULL;
+
+   if (!backsector)
+   {
+      // single sided line
+      midtexture = texturetranslation[sidedef->midtexture];
+      midtexheight = (linedef->r_flags & RF_MID_TILE) ? 0 : textureheight[midtexture] >> FRACBITS;
+
+      // a single sided line is terminal, so it must mark ends
+      markfloor = markceiling = true;
+
+      if (linedef->flags & ML_DONTPEGBOTTOM)
+      {         // bottom of texture at bottom
+         fixed_t vtop = frontsector->floorheight +
+                        textureheight[sidedef->midtexture];
+         rw_midtexturemid = vtop - viewz;
+      }
+      else        // top of texture at top
+         rw_midtexturemid = worldtop;
+
+      rw_midtexturemid += FixedMod(sidedef->rowoffset, textureheight[midtexture]);
+
+      ds_p->silhouette = SIL_BOTH;
+      ds_p->sprtopclip = screenheightarray;
+      ds_p->sprbottomclip = negonearray;
+      ds_p->bsilheight = INT_MAX;
+      ds_p->tsilheight = INT_MIN;
+   }
+   else      // two sided line
+   {
+      ds_p->sprtopclip = ds_p->sprbottomclip = NULL;
+      ds_p->silhouette = 0;
+
+      if (linedef->r_flags & RF_CLOSED) { /* cph - closed 2S line e.g. door */
+         // cph - killough's (outdated) comment follows - this deals with both
+         // "automap fixes", his and mine
+         // killough 1/17/98: this test is required if the fix
+         // for the automap bug (r_bsp.c) is used, or else some
+         // sprites will be displayed behind closed doors. That
+         // fix prevents lines behind closed doors with dropoffs
+         // from being displayed on the automap.
+
+         ds_p->silhouette = SIL_BOTH;
+         ds_p->sprbottomclip = negonearray;
+         ds_p->bsilheight = INT_MAX;
+         ds_p->sprtopclip = screenheightarray;
+         ds_p->tsilheight = INT_MIN;
+
+      } else { /* not solid - old code */
+
+         if (frontsector->floorheight > backsector->floorheight)
+         {
+            ds_p->silhouette = SIL_BOTTOM;
+            ds_p->bsilheight = frontsector->floorheight;
+         }
+         else
+            if (backsector->floorheight > viewz)
+            {
+               ds_p->silhouette = SIL_BOTTOM;
+               ds_p->bsilheight = INT_MAX;
+            }
+
+         if (frontsector->ceilingheight < backsector->ceilingheight)
+         {
+            ds_p->silhouette |= SIL_TOP;
+            ds_p->tsilheight = frontsector->ceilingheight;
+         }
+         else
+            if (backsector->ceilingheight < viewz)
+            {
+               ds_p->silhouette |= SIL_TOP;
+               ds_p->tsilheight = INT_MIN;
+            }
+      }
+
+      worldhigh = backsector->ceilingheight - viewz;
+      worldlow = backsector->floorheight - viewz;
+
+      // hack to allow height changes in outdoor areas
+      if (frontsector->ceilingpic == skyflatnum
+            && backsector->ceilingpic == skyflatnum)
+         worldtop = worldhigh;
+
+      markfloor = worldlow != worldbottom
+                  || backsector->floorpic != frontsector->floorpic
+                  || backsector->lightlevel != frontsector->lightlevel
+
+                  // killough 3/7/98: Add checks for (x,y) offsets
+                  || backsector->floor_xoffs != frontsector->floor_xoffs
+                  || backsector->floor_yoffs != frontsector->floor_yoffs
+
+                  // killough 4/15/98: prevent 2s normals
+                  // from bleeding through deep water
+                  || frontsector->heightsec != -1
+
+                  // killough 4/17/98: draw floors if different light levels
+                  || backsector->floorlightsec != frontsector->floorlightsec
+                  ;
+
+      markceiling = worldhigh != worldtop
+                    || backsector->ceilingpic != frontsector->ceilingpic
+                    || backsector->lightlevel != frontsector->lightlevel
+
+                    // killough 3/7/98: Add checks for (x,y) offsets
+                    || backsector->ceiling_xoffs != frontsector->ceiling_xoffs
+                    || backsector->ceiling_yoffs != frontsector->ceiling_yoffs
+
+                    // killough 4/15/98: prevent 2s normals
+                    // from bleeding through fake ceilings
+                    || (frontsector->heightsec != -1 &&
+                        frontsector->ceilingpic!=skyflatnum)
+
+                    // killough 4/17/98: draw ceilings if different light levels
+                    || backsector->ceilinglightsec != frontsector->ceilinglightsec
+                    ;
+
+      if (backsector->ceilingheight <= frontsector->floorheight
+            || backsector->floorheight >= frontsector->ceilingheight)
+         markceiling = markfloor = true;   // closed door
+
+      if (worldhigh < worldtop)   // top texture
+      {
+         toptexture = texturetranslation[sidedef->toptexture];
+         toptexheight = (linedef->r_flags & RF_TOP_TILE) ? 0 : textureheight[toptexture] >> FRACBITS;
+         rw_toptexturemid = linedef->flags & ML_DONTPEGTOP ? worldtop :
+                            backsector->ceilingheight+textureheight[sidedef->toptexture]-viewz;
+         rw_toptexturemid += FixedMod(sidedef->rowoffset, textureheight[toptexture]);
+      }
+
+      if (worldlow > worldbottom) // bottom texture
+      {
+         bottomtexture = texturetranslation[sidedef->bottomtexture];
+         bottomtexheight = (linedef->r_flags & RF_BOT_TILE) ? 0 : textureheight[bottomtexture] >> FRACBITS;
+         rw_bottomtexturemid = linedef->flags & ML_DONTPEGBOTTOM ? worldtop :
+                               worldlow;
+         rw_bottomtexturemid += FixedMod(sidedef->rowoffset, textureheight[bottomtexture]);
+      }
+
+      // allocate space for masked texture tables
+      if (sidedef->midtexture)    // masked midtexture
+      {
+         maskedtexture = true;
+         ds_p->maskedtexturecol = maskedtexturecol = lastopening - rw_x;
+         lastopening += rw_stopx - rw_x;
+      }
+   }
+
+   // calculate rw_offset (only needed for textured lines)
+   segtextured = midtexture | toptexture | bottomtexture | maskedtexture;
+
+   if (segtextured)
+   {
+      offsetangle = rw_normalangle-rw_angle1;
+
+      if (offsetangle > ANG180)
+         offsetangle = 0-offsetangle;
+
+      if (offsetangle > ANG90)
+         offsetangle = ANG90;
+
+      sineval = finesine[offsetangle >>ANGLETOFINESHIFT];
+      rw_offset = FixedMul (hyp, sineval);
+
+      if (rw_normalangle-rw_angle1 < ANG180)
+         rw_offset = -rw_offset;
+
+      rw_offset += sidedef->textureoffset + curline->offset;
+
+      rw_centerangle = ANG90 + viewangle - rw_normalangle;
+
+      // calculate light table
+      //  use different light tables
+      //  for horizontal / vertical / diagonal
+      // OPTIMIZE: get rid of LIGHTSEGSHIFT globally
+      if (!fixedcolormap)
+      {
+         int lightnum = (frontsector->lightlevel >> LIGHTSEGSHIFT)+extralight;
+
+         /* cph - ...what is this for? adding contrast to rooms?
+          * It looks crap in outdoor areas */
+         if (fake_contrast) {
+            if (curline->v1->y == curline->v2->y)
+               lightnum--;
+            else if (curline->v1->x == curline->v2->x)
+               lightnum++;
+         }
+
+         if (lightnum < 0)
+            walllights = scalelight[0];
+         else if (lightnum >= LIGHTLEVELS)
+            walllights = scalelight[LIGHTLEVELS-1];
+         else
+            walllights = scalelight[lightnum];
+      }
+   }
+
+   // if a floor / ceiling plane is on the wrong side of the view
+   // plane, it is definitely invisible and doesn't need to be marked.
+
+   // killough 3/7/98: add deep water check
+   if (frontsector->heightsec == -1)
+   {
+      if (frontsector->floorheight >= viewz)       // above view plane
+         markfloor = false;
+      if (frontsector->ceilingheight <= viewz &&
+            frontsector->ceilingpic != skyflatnum)   // below view plane
+         markceiling = false;
+   }
+
+   // calculate incremental stepping values for texture edges
+   worldtop >>= 4;
+   worldbottom >>= 4;
+
+   topstep = -FixedMul (rw_scalestep, worldtop);
+   topfrac = (centeryfrac>>4) - FixedMul (worldtop, rw_scale);
+
+   bottomstep = -FixedMul (rw_scalestep,worldbottom);
+   bottomfrac = (centeryfrac>>4) - FixedMul (worldbottom, rw_scale);
+
+   if (backsector)
+   {
+      worldhigh >>= 4;
+      worldlow >>= 4;
+
+      if (worldhigh < worldtop)
+      {
+         pixhigh = (centeryfrac>>4) - FixedMul (worldhigh, rw_scale);
+         pixhighstep = -FixedMul (rw_scalestep,worldhigh);
+      }
+      if (worldlow > worldbottom)
+      {
+         pixlow = (centeryfrac>>4) - FixedMul (worldlow, rw_scale);
+         pixlowstep = -FixedMul (rw_scalestep,worldlow);
+      }
+   }
+
+   // render it
+   if (markceiling) {
+      if (ceilingplane)   // killough 4/11/98: add NULL ptr checks
+         ceilingplane = R_CheckPlane (ceilingplane, rw_x, rw_stopx-1);
+      else
+         markceiling = 0;
+   }
+
+   if (markfloor) {
+      if (floorplane)     // killough 4/11/98: add NULL ptr checks
+         /* cph 2003/04/18  - ceilingplane and floorplane might be the same
+          * visplane (e.g. if both skies); R_CheckPlane doesn't know about
+          * modifications to the plane that might happen in parallel with the check
+          * being made, so we have to override it and split them anyway if that is
+          * a possibility, otherwise the floor marking would overwrite the ceiling
+          * marking, resulting in HOM. */
+         if (markceiling && ceilingplane == floorplane)
+            floorplane = R_DupPlane (floorplane, rw_x, rw_stopx-1);
+         else
+            floorplane = R_CheckPlane (floorplane, rw_x, rw_stopx-1);
+      else
+         markfloor = 0;
+   }
+
+   didsolidcol = 0;
+   R_RenderSegLoop();
+
+   /* cph - if a column was made solid by this wall, we _must_ save full clipping info */
+   if (backsector && didsolidcol) {
+      if (!(ds_p->silhouette & SIL_BOTTOM)) {
+         ds_p->silhouette |= SIL_BOTTOM;
+         ds_p->bsilheight = backsector->floorheight;
+      }
+      if (!(ds_p->silhouette & SIL_TOP)) {
+         ds_p->silhouette |= SIL_TOP;
+         ds_p->tsilheight = backsector->ceilingheight;
+      }
+   }
+
+   // save sprite clipping info
+   if ((ds_p->silhouette & SIL_TOP || maskedtexture) && !ds_p->sprtopclip)
+   {
+      memcpy (lastopening, ceilingclip+start, 2*(rw_stopx-start));
+      ds_p->sprtopclip = lastopening - start;
+      lastopening += rw_stopx - start;
+   }
+   if ((ds_p->silhouette & SIL_BOTTOM || maskedtexture) && !ds_p->sprbottomclip)
+   {
+      memcpy (lastopening, floorclip+start, 2*(rw_stopx-start));
+      ds_p->sprbottomclip = lastopening - start;
+      lastopening += rw_stopx - start;
+   }
+   if (maskedtexture && !(ds_p->silhouette & SIL_TOP))
+   {
+      ds_p->silhouette |= SIL_TOP;
+      ds_p->tsilheight = INT_MIN;
+   }
+   if (maskedtexture && !(ds_p->silhouette & SIL_BOTTOM))
+   {
+      ds_p->silhouette |= SIL_BOTTOM;
+      ds_p->bsilheight = INT_MAX;
+   }
+   ds_p++;
+}