apps/plugins/doom/r_plane.c

   1 /* Emacs style mode select   -*- C++ -*-
   2  *-----------------------------------------------------------------------------
   3  *
   4  *
   5  *  PrBoom a Doom port merged with LxDoom and LSDLDoom
   6  *  based on BOOM, a modified and improved DOOM engine
   7  *  Copyright (C) 1999 by
   8  *  id Software, Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
   9  *  Copyright (C) 1999-2000 by
  10  *  Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
  11  *
  12  *  This program is free software; you can redistribute it and/or
  13  *  modify it under the terms of the GNU General Public License
  14  *  as published by the Free Software Foundation; either version 2
  15  *  of the License, or (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  25  *  02111-1307, USA.
  26  *
  27  * DESCRIPTION:
  28  *      Here is a core component: drawing the floors and ceilings,
  29  *       while maintaining a per column clipping list only.
  30  *      Moreover, the sky areas have to be determined.
  31  *
  32  * MAXVISPLANES is no longer a limit on the number of visplanes,
  33  * but a limit on the number of hash slots; larger numbers mean
  34  * better performance usually but after a point they are wasted,
  35  * and memory and time overheads creep in.
  36  *
  37  * For more information on visplanes, see:
  38  *
  39  * http://classicgaming.com/doom/editing/
  40  *
  41  * Lee Killough
  42  *
  43  *-----------------------------------------------------------------------------*/
  44
  45 #include "z_zone.h"  /* memory allocation wrappers -- killough */
  46
  47 #include "doomstat.h"
  48 #include "w_wad.h"
  49 #include "r_main.h"
  50 #include "r_draw.h"
  51 #include "r_things.h"
  52 #include "r_sky.h"
  53 #include "r_plane.h"
  54 #include "rockmacros.h"
  55
  56 #define MAXVISPLANES 128    /* must be a power of 2 */
  57
  58 static visplane_t *visplanes[MAXVISPLANES] IBSS_ATTR;   // killough
  59 static visplane_t *freetail;                  // killough
  60 static visplane_t **freehead = &freetail;     // killough
  61 visplane_t *floorplane, *ceilingplane;
  62
  63 // killough -- hash function for visplanes
  64 // Empirically verified to be fairly uniform:
  65
  66 #define visplane_hash(picnum,lightlevel,height) \
  67   ((unsigned)((picnum)*3+(lightlevel)+(height)*7) & (MAXVISPLANES-1))
  68
  69 size_t maxopenings;
  70 short *openings,*lastopening;
  71
  72 // Clip values are the solid pixel bounding the range.
  73 //  floorclip starts out SCREENHEIGHT
  74 //  ceilingclip starts out -1
  75
  76 short floorclip[MAX_SCREENWIDTH], ceilingclip[MAX_SCREENWIDTH];
  77
  78 // spanstart holds the start of a plane span; initialized to 0 at start
  79
  80 static int spanstart[MAX_SCREENHEIGHT];                // killough 2/8/98
  81
  82 //
  83 // texture mapping
  84 //
  85
  86 static lighttable_t **planezlight;
  87 static fixed_t planeheight;
  88
  89 // killough 2/8/98: make variables static
  90
  91 static fixed_t basexscale, baseyscale;
  92 static fixed_t cachedheight[MAX_SCREENHEIGHT];
  93 static fixed_t cacheddistance[MAX_SCREENHEIGHT];
  94 static fixed_t cachedxstep[MAX_SCREENHEIGHT];
  95 static fixed_t cachedystep[MAX_SCREENHEIGHT];
  96 static fixed_t xoffs, yoffs;    // killough 2/28/98: flat offsets
  97
  98 fixed_t yslope[MAX_SCREENHEIGHT], distscale[MAX_SCREENWIDTH];
  99
 100 //
 101 // R_InitPlanes
 102 // Only at game startup.
 103 //
 104 void R_InitPlanes (void)
 105 {
 106 }
 107
 108 //
 109 // R_MapPlane
 110 //
 111 // Uses global vars:
 112 //  planeheight
 113 //  ds_source
 114 //  basexscale
 115 //  baseyscale
 116 //  viewx
 117 //  viewy
 118 //  xoffs
 119 //  yoffs
 120 //
 121 // BASIC PRIMITIVE
 122 //
 123
 124 static void R_MapPlane(int y, int x1, int x2)
 125 {
 126    angle_t angle;
 127    fixed_t distance, length;
 128    unsigned index;
 129
 130 #ifdef RANGECHECK
 131
 132    if (x2 < x1 || x1<0 || x2>=viewwidth || (unsigned)y>(unsigned)viewheight)
 133       I_Error ("R_MapPlane: %i, %i at %i",x1,x2,y);
 134 #endif
 135
 136    if (planeheight != cachedheight[y])
 137    {
 138       cachedheight[y] = planeheight;
 139       distance = cacheddistance[y] = FixedMul (planeheight, yslope[y]);
 140       ds_xstep = cachedxstep[y] = FixedMul (distance,basexscale);
 141       ds_ystep = cachedystep[y] = FixedMul (distance,baseyscale);
 142    }
 143    else
 144    {
 145       distance = cacheddistance[y];
 146       ds_xstep = cachedxstep[y];
 147       ds_ystep = cachedystep[y];
 148    }
 149
 150    length = FixedMul (distance,distscale[x1]);
 151    angle = (viewangle + xtoviewangle[x1])>>ANGLETOFINESHIFT;
 152
 153    // killough 2/28/98: Add offsets
 154    ds_xfrac =  viewx + FixedMul(finecosine[angle], length) + xoffs;
 155    ds_yfrac = -viewy - FixedMul(finesine[angle],   length) + yoffs;
 156
 157    if (!(ds_colormap = fixedcolormap))
 158    {
 159       index = distance >> LIGHTZSHIFT;
 160       if (index >= MAXLIGHTZ )
 161          index = MAXLIGHTZ-1;
 162       ds_colormap = planezlight[index];
 163    }
 164
 165    ds_y = y;
 166    ds_x1 = x1;
 167    ds_x2 = x2;
 168
 169    R_DrawSpan();
 170 }
 171
 172 //
 173 // R_ClearPlanes
 174 // At begining of frame.
 175 //
 176
 177 void R_ClearPlanes(void)
 178 {
 179    int i;
 180    angle_t angle;
 181
 182    // opening / clipping determination
 183    for (i=0 ; i<viewwidth ; i++)
 184       floorclip[i] = viewheight, ceilingclip[i] = -1;
 185
 186    for (i=0;i<MAXVISPLANES;i++)    // new code -- killough
 187       for (*freehead = visplanes[i], visplanes[i] = NULL; *freehead; )
 188          freehead = &(*freehead)->next;
 189
 190    lastopening = openings;
 191
 192    // texture calculation
 193    memset (cachedheight, 0, sizeof(cachedheight));
 194
 195    // left to right mapping
 196    angle = (viewangle-ANG90)>>ANGLETOFINESHIFT;
 197
 198    // scale will be unit scale at SCREENWIDTH/2 distance
 199    basexscale = FixedDiv (finecosine[angle],centerxfrac);
 200    baseyscale = -FixedDiv (finesine[angle],centerxfrac);
 201 }
 202
 203 // New function, by Lee Killough
 204
 205 static visplane_t *new_visplane(unsigned hash)
 206 {
 207    visplane_t *check = freetail;
 208    if (!check)
 209       check = calloc(1, sizeof *check);
 210    else
 211       if (!(freetail = freetail->next))
 212          freehead = &freetail;
 213    check->next = visplanes[hash];
 214    visplanes[hash] = check;
 215    return check;
 216 }
 217
 218 /*
 219  * R_DupPlane
 220  *
 221  * cph 2003/04/18 - create duplicate of existing visplane and set initial range
 222  */
 223 visplane_t *R_DupPlane(const visplane_t *pl, int start, int stop)
 224 {
 225    unsigned hash = visplane_hash(pl->picnum, pl->lightlevel, pl->height);
 226    visplane_t *new_pl = new_visplane(hash);
 227
 228    new_pl->height = pl->height;
 229    new_pl->picnum = pl->picnum;
 230    new_pl->lightlevel = pl->lightlevel;
 231    new_pl->xoffs = pl->xoffs;           // killough 2/28/98
 232    new_pl->yoffs = pl->yoffs;
 233    new_pl->minx = start;
 234    new_pl->maxx = stop;
 235    memset(new_pl->top, 0xff, sizeof new_pl->top);
 236    return new_pl;
 237 }
 238
 239 //
 240 // R_FindPlane
 241 //
 242 // killough 2/28/98: Add offsets
 243
 244 visplane_t *R_FindPlane(fixed_t height, int picnum, int lightlevel,
 245                         fixed_t xoffs, fixed_t yoffs)
 246 {
 247    visplane_t *check;
 248    unsigned hash;                      // killough
 249
 250    if (picnum == skyflatnum || picnum & PL_SKYFLAT)
 251       height = lightlevel = 0;         // killough 7/19/98: most skies map together
 252
 253    // New visplane algorithm uses hash table -- killough
 254    hash = visplane_hash(picnum,lightlevel,height);
 255
 256    for (check=visplanes[hash]; check; check=check->next)  // killough
 257       if (height == check->height &&
 258             picnum == check->picnum &&
 259             lightlevel == check->lightlevel &&
 260             xoffs == check->xoffs &&      // killough 2/28/98: Add offset checks
 261             yoffs == check->yoffs)
 262          return check;
 263
 264    check = new_visplane(hash);         // killough
 265
 266    check->height = height;
 267    check->picnum = picnum;
 268    check->lightlevel = lightlevel;
 269    check->minx = viewwidth; // Was SCREENWIDTH -- killough 11/98
 270    check->maxx = -1;
 271    check->xoffs = xoffs;               // killough 2/28/98: Save offsets
 272    check->yoffs = yoffs;
 273
 274    memset (check->top, 0xff, sizeof check->top);
 275
 276    return check;
 277 }
 278
 279 //
 280 // R_CheckPlane
 281 //
 282 visplane_t *R_CheckPlane(visplane_t *pl, int start, int stop)
 283 {
 284    int intrl, intrh, unionl, unionh, x;
 285
 286    if (start < pl->minx)
 287       intrl   = pl->minx, unionl = start;
 288    else
 289       unionl  = pl->minx,  intrl = start;
 290
 291    if (stop  > pl->maxx)
 292       intrh   = pl->maxx, unionh = stop;
 293    else
 294       unionh  = pl->maxx, intrh  = stop;
 295
 296    for (x=intrl ; x <= intrh && pl->top[x] == 0xffff; x++)
 297       ;
 298
 299    if (x > intrh)
 300    { /* Can use existing plane; extend range */
 301       pl->minx = unionl;
 302       pl->maxx = unionh;
 303       return pl;
 304    }
 305    else /* Cannot use existing plane; create a new one */
 306       return R_DupPlane(pl,start,stop);
 307 }
 308
 309 //
 310 // R_MakeSpans
 311 //
 312
 313 static void R_MakeSpans(int x, int t1, int b1, int t2, int b2)
 314 {
 315    for (; t1 < t2 && t1 <= b1; t1++)
 316       R_MapPlane(t1, spanstart[t1], x-1);
 317    for (; b1 > b2 && b1 >= t1; b1--)
 318       R_MapPlane(b1, spanstart[b1] ,x-1);
 319    while (t2 < t1 && t2 <= b2)
 320       spanstart[t2++] = x;
 321    while (b2 > b1 && b2 >= t2)
 322       spanstart[b2--] = x;
 323 }
 324
 325 // New function, by Lee Killough
 326
 327 static void R_DoDrawPlane(visplane_t *pl)
 328 {
 329    register int x;
 330    if (pl->minx <= pl->maxx)
 331    {
 332       if (pl->picnum == skyflatnum || pl->picnum & PL_SKYFLAT)
 333       { // sky flat
 334          int texture;
 335          angle_t an, flip;
 336
 337          // killough 10/98: allow skies to come from sidedefs.
 338          // Allows scrolling and/or animated skies, as well as
 339          // arbitrary multiple skies per level without having
 340          // to use info lumps.
 341
 342          an = viewangle;
 343
 344          if (pl->picnum & PL_SKYFLAT)
 345          {
 346             // Sky Linedef
 347             const line_t *l = &lines[pl->picnum & ~PL_SKYFLAT];
 348
 349             // Sky transferred from first sidedef
 350             const side_t *s = *l->sidenum + sides;
 351
 352             // Texture comes from upper texture of reference sidedef
 353             texture = texturetranslation[s->toptexture];
 354
 355             // Horizontal offset is turned into an angle offset,
 356             // to allow sky rotation as well as careful positioning.
 357             // However, the offset is scaled very small, so that it
 358             // allows a long-period of sky rotation.
 359
 360             an += s->textureoffset;
 361
 362             // Vertical offset allows careful sky positioning.
 363
 364             dc_texturemid = s->rowoffset - 28*FRACUNIT;
 365
 366             // We sometimes flip the picture horizontally.
 367             //
 368             // Doom always flipped the picture, so we make it optional,
 369             // to make it easier to use the new feature, while to still
 370             // allow old sky textures to be used.
 371
 372             flip = l->special==272 ? 0u : ~0u;
 373          }
 374          else
 375          {    // Normal Doom sky, only one allowed per level
 376             dc_texturemid = skytexturemid;    // Default y-offset
 377             texture = skytexture;             // Default texture
 378             flip = 0;                         // Doom flips it
 379          }
 380
 381          /* Sky is always drawn full bright, i.e. colormaps[0] is used.
 382           * Because of this hack, sky is not affected by INVUL inverse mapping.
 383           * Until Boom fixed this. Compat option added in MBF. */
 384
 385          if (comp[comp_skymap] || !(dc_colormap = fixedcolormap))
 386             dc_colormap = fullcolormap;          // killough 3/20/98
 387          dc_texheight = textureheight[skytexture]>>FRACBITS; // killough
 388          // proff 09/21/98: Changed for high-res
 389          dc_iscale = FRACUNIT*200/viewheight;
 390
 391          // killough 10/98: Use sky scrolling offset, and possibly flip picture
 392          for (x = pl->minx; (dc_x = x) <= pl->maxx; x++)
 393             if ((dc_yl = pl->top[x]) <= (dc_yh = pl->bottom[x]))
 394             {
 395                dc_source = R_GetColumn(texture, ((an + xtoviewangle[x])^flip) >>
 396                                        ANGLETOSKYSHIFT);
 397                colfunc();
 398             }
 399       }
 400       else
 401       {     // regular flat
 402
 403          int stop, light;
 404
 405          ds_source = W_CacheLumpNum(firstflat + flattranslation[pl->picnum]);
 406
 407          xoffs = pl->xoffs;  // killough 2/28/98: Add offsets
 408          yoffs = pl->yoffs;
 409          planeheight = D_abs(pl->height-viewz);
 410          light = (pl->lightlevel >> LIGHTSEGSHIFT) + extralight;
 411
 412          if (light >= LIGHTLEVELS)
 413             light = LIGHTLEVELS-1;
 414
 415          if (light < 0)
 416             light = 0;
 417
 418          stop = pl->maxx + 1;
 419          planezlight = zlight[light];
 420          pl->top[pl->minx-1] = pl->top[stop] = 0xffff;
 421
 422          for (x = pl->minx ; x <= stop ; x++)
 423             R_MakeSpans(x,pl->top[x-1],pl->bottom[x-1],pl->top[x],pl->bottom[x]);
 424
 425          W_UnlockLumpNum(firstflat + flattranslation[pl->picnum]);
 426       }
 427    }
 428 }
 429
 430 //
 431 // RDrawPlanes
 432 // At the end of each frame.
 433 //
 434
 435 void R_DrawPlanes (void)
 436 {
 437    visplane_t *pl;
 438    int i;
 439    for (i=0;i<MAXVISPLANES;i++)
 440       for (pl=visplanes[i]; pl; pl=pl->next)
 441          R_DoDrawPlane(pl);
 442 }