mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-02 00:41:51 +00:00
437 lines
9 KiB
C++
437 lines
9 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition Source Code 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 BFG Edition Source Code 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 Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "Precompiled.h"
|
|
#include "globaldata.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "i_system.h"
|
|
#include "z_zone.h"
|
|
#include "w_wad.h"
|
|
|
|
#include "doomdef.h"
|
|
#include "doomstat.h"
|
|
|
|
#include "r_local.h"
|
|
#include "r_sky.h"
|
|
|
|
|
|
|
|
|
|
//
|
|
// opening
|
|
//
|
|
|
|
// Here comes the obnoxious "visplane".
|
|
|
|
|
|
|
|
//
|
|
// Clip values are the solid pixel bounding the range.
|
|
// ::g->floorclip starts out SCREENHEIGHT
|
|
// ::g->ceilingclip starts out -1
|
|
//
|
|
|
|
//
|
|
// ::g->spanstart holds the start of a plane span
|
|
// initialized to 0 at start
|
|
//
|
|
|
|
//
|
|
// texture mapping
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// R_InitPlanes
|
|
// Only at game startup.
|
|
//
|
|
void R_InitPlanes (void)
|
|
{
|
|
// Doh!
|
|
}
|
|
|
|
|
|
//
|
|
// R_MapPlane
|
|
//
|
|
// Uses global vars:
|
|
// ::g->planeheight
|
|
// ::g->ds_source
|
|
// ::g->basexscale
|
|
// ::g->baseyscale
|
|
// ::g->viewx
|
|
// ::g->viewy
|
|
//
|
|
// BASIC PRIMITIVE
|
|
//
|
|
void
|
|
R_MapPlane
|
|
( int y,
|
|
int x1,
|
|
int x2 )
|
|
{
|
|
angle_t angle;
|
|
fixed_t distance;
|
|
fixed_t length;
|
|
unsigned index;
|
|
|
|
//#ifdef RANGECHECK
|
|
if ( x2 < x1 || x1<0 || x2>=::g->viewwidth || y>::g->viewheight )
|
|
{
|
|
//I_Error ("R_MapPlane: %i, %i at %i",x1,x2,y);
|
|
return;
|
|
}
|
|
//#endif
|
|
|
|
if (::g->planeheight != ::g->cachedheight[y])
|
|
{
|
|
::g->cachedheight[y] = ::g->planeheight;
|
|
distance = ::g->cacheddistance[y] = FixedMul (::g->planeheight, ::g->yslope[y]);
|
|
::g->ds_xstep = ::g->cachedxstep[y] = FixedMul (distance,::g->basexscale);
|
|
::g->ds_ystep = ::g->cachedystep[y] = FixedMul (distance,::g->baseyscale);
|
|
}
|
|
else
|
|
{
|
|
distance = ::g->cacheddistance[y];
|
|
::g->ds_xstep = ::g->cachedxstep[y];
|
|
::g->ds_ystep = ::g->cachedystep[y];
|
|
}
|
|
|
|
extern angle_t GetViewAngle();
|
|
length = FixedMul (distance,::g->distscale[x1]);
|
|
angle = (GetViewAngle() + ::g->xtoviewangle[x1])>>ANGLETOFINESHIFT;
|
|
extern fixed_t GetViewX(); extern fixed_t GetViewY();
|
|
::g->ds_xfrac = GetViewX() + FixedMul(finecosine[angle], length);
|
|
::g->ds_yfrac = -GetViewY() - FixedMul(finesine[angle], length);
|
|
|
|
if (::g->fixedcolormap)
|
|
::g->ds_colormap = ::g->fixedcolormap;
|
|
else
|
|
{
|
|
index = distance >> LIGHTZSHIFT;
|
|
|
|
if (index >= MAXLIGHTZ )
|
|
index = MAXLIGHTZ-1;
|
|
|
|
::g->ds_colormap = ::g->planezlight[index];
|
|
}
|
|
|
|
::g->ds_y = y;
|
|
::g->ds_x1 = x1;
|
|
::g->ds_x2 = x2;
|
|
|
|
// high or low detail
|
|
spanfunc (
|
|
::g->ds_xfrac,
|
|
::g->ds_yfrac,
|
|
::g->ds_y,
|
|
::g->ds_x1,
|
|
::g->ds_x2,
|
|
::g->ds_xstep,
|
|
::g->ds_ystep,
|
|
::g->ds_colormap,
|
|
::g->ds_source );
|
|
}
|
|
|
|
|
|
//
|
|
// R_ClearPlanes
|
|
// At begining of frame.
|
|
//
|
|
void R_ClearPlanes (void)
|
|
{
|
|
int i;
|
|
angle_t angle;
|
|
|
|
// opening / clipping determination
|
|
for (i=0 ; i < ::g->viewwidth ; i++)
|
|
{
|
|
::g->floorclip[i] = ::g->viewheight;
|
|
::g->ceilingclip[i] = -1;
|
|
}
|
|
|
|
::g->lastvisplane = ::g->visplanes;
|
|
::g->lastopening = ::g->openings;
|
|
|
|
// texture calculation
|
|
memset (::g->cachedheight, 0, sizeof(::g->cachedheight));
|
|
|
|
// left to right mapping
|
|
extern angle_t GetViewAngle();
|
|
angle = (GetViewAngle()-ANG90)>>ANGLETOFINESHIFT;
|
|
|
|
// scale will be unit scale at SCREENWIDTH/2 distance
|
|
::g->basexscale = FixedDiv (finecosine[angle],::g->centerxfrac);
|
|
::g->baseyscale = -FixedDiv (finesine[angle],::g->centerxfrac);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// R_FindPlane
|
|
//
|
|
visplane_t* R_FindPlane( fixed_t height, int picnum, int lightlevel ) {
|
|
visplane_t* check;
|
|
|
|
if (picnum == ::g->skyflatnum) {
|
|
height = 0; // all skys map together
|
|
lightlevel = 0;
|
|
}
|
|
|
|
for (check=::g->visplanes; check < ::g->lastvisplane; check++) {
|
|
if (height == check->height && picnum == check->picnum && lightlevel == check->lightlevel) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (check < ::g->lastvisplane)
|
|
return check;
|
|
|
|
//if (::g->lastvisplane - ::g->visplanes == MAXVISPLANES)
|
|
//I_Error ("R_FindPlane: no more visplanes");
|
|
if ( ::g->lastvisplane - ::g->visplanes == MAXVISPLANES ) {
|
|
check = ::g->visplanes;
|
|
return check;
|
|
}
|
|
|
|
::g->lastvisplane++;
|
|
|
|
check->height = height;
|
|
check->picnum = picnum;
|
|
check->lightlevel = lightlevel;
|
|
check->minx = SCREENWIDTH;
|
|
check->maxx = -1;
|
|
|
|
memset(check->top,0xff,sizeof(check->top));
|
|
|
|
return check;
|
|
}
|
|
|
|
|
|
//
|
|
// R_CheckPlane
|
|
//
|
|
visplane_t*
|
|
R_CheckPlane
|
|
( visplane_t* pl,
|
|
int start,
|
|
int stop )
|
|
{
|
|
int intrl;
|
|
int intrh;
|
|
int unionl;
|
|
int unionh;
|
|
int x;
|
|
|
|
if (start < pl->minx)
|
|
{
|
|
intrl = pl->minx;
|
|
unionl = start;
|
|
}
|
|
else
|
|
{
|
|
unionl = pl->minx;
|
|
intrl = start;
|
|
}
|
|
|
|
if (stop > pl->maxx)
|
|
{
|
|
intrh = pl->maxx;
|
|
unionh = stop;
|
|
}
|
|
else
|
|
{
|
|
unionh = pl->maxx;
|
|
intrh = stop;
|
|
}
|
|
|
|
for (x=intrl ; x<= intrh ; x++)
|
|
if (pl->top[x] != 0xffff)
|
|
break;
|
|
|
|
if (x > intrh)
|
|
{
|
|
pl->minx = unionl;
|
|
pl->maxx = unionh;
|
|
|
|
// use the same one
|
|
return pl;
|
|
}
|
|
|
|
if ( ::g->lastvisplane - ::g->visplanes == MAXVISPLANES ) {
|
|
return pl;
|
|
}
|
|
|
|
// make a new visplane
|
|
::g->lastvisplane->height = pl->height;
|
|
::g->lastvisplane->picnum = pl->picnum;
|
|
::g->lastvisplane->lightlevel = pl->lightlevel;
|
|
|
|
pl = ::g->lastvisplane++;
|
|
pl->minx = start;
|
|
pl->maxx = stop;
|
|
|
|
memset(pl->top,0xff,sizeof(pl->top));
|
|
|
|
return pl;
|
|
}
|
|
|
|
|
|
//
|
|
// R_MakeSpans
|
|
//
|
|
void
|
|
R_MakeSpans
|
|
( int x,
|
|
int t1,
|
|
int b1,
|
|
int t2,
|
|
int b2 )
|
|
{
|
|
while (t1 < t2 && t1<=b1)
|
|
{
|
|
R_MapPlane (t1,::g->spanstart[t1],x-1);
|
|
t1++;
|
|
}
|
|
while (b1 > b2 && b1>=t1)
|
|
{
|
|
R_MapPlane (b1,::g->spanstart[b1],x-1);
|
|
b1--;
|
|
}
|
|
|
|
while (t2 < t1 && t2<=b2)
|
|
{
|
|
::g->spanstart[t2] = x;
|
|
t2++;
|
|
}
|
|
while (b2 > b1 && b2>=t2)
|
|
{
|
|
::g->spanstart[b2] = x;
|
|
b2--;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// R_DrawPlanes
|
|
// At the end of each frame.
|
|
//
|
|
void R_DrawPlanes (void)
|
|
{
|
|
visplane_t* pl;
|
|
int light;
|
|
int x;
|
|
int stop;
|
|
int angle;
|
|
|
|
#ifdef RANGECHECK
|
|
if (::g->ds_p - ::g->drawsegs > MAXDRAWSEGS)
|
|
I_Error ("R_DrawPlanes: ::g->drawsegs overflow (%i)",
|
|
::g->ds_p - ::g->drawsegs);
|
|
|
|
if (::g->lastvisplane - ::g->visplanes > MAXVISPLANES)
|
|
I_Error ("R_DrawPlanes: visplane overflow (%i)",
|
|
::g->lastvisplane - ::g->visplanes);
|
|
|
|
if (::g->lastopening - ::g->openings > MAXOPENINGS)
|
|
I_Error ("R_DrawPlanes: opening overflow (%i)",
|
|
::g->lastopening - ::g->openings);
|
|
#endif
|
|
|
|
for (pl = ::g->visplanes ; pl < ::g->lastvisplane ; pl++)
|
|
{
|
|
if (pl->minx > pl->maxx)
|
|
continue;
|
|
|
|
|
|
// sky flat
|
|
if (pl->picnum == ::g->skyflatnum)
|
|
{
|
|
::g->dc_iscale = ::g->pspriteiscale>>::g->detailshift;
|
|
|
|
// Sky is allways drawn full bright,
|
|
// i.e. ::g->colormaps[0] is used.
|
|
// Because of this hack, sky is not affected
|
|
// by INVUL inverse mapping.
|
|
::g->dc_colormap = ::g->colormaps;
|
|
::g->dc_texturemid = ::g->skytexturemid;
|
|
for (x=pl->minx ; x <= pl->maxx ; x++)
|
|
{
|
|
::g->dc_yl = pl->top[x];
|
|
::g->dc_yh = pl->bottom[x];
|
|
|
|
if (::g->dc_yl <= ::g->dc_yh)
|
|
{
|
|
extern angle_t GetViewAngle();
|
|
angle = (GetViewAngle() + ::g->xtoviewangle[x])>>ANGLETOSKYSHIFT;
|
|
::g->dc_x = x;
|
|
::g->dc_source = R_GetColumn(::g->skytexture, angle);
|
|
colfunc ( ::g->dc_colormap, ::g->dc_source );
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// regular flat
|
|
::g->ds_source = (byte*)W_CacheLumpNum(::g->firstflat +
|
|
::g->flattranslation[pl->picnum],
|
|
PU_CACHE_SHARED);
|
|
|
|
::g->planeheight = abs(pl->height-::g->viewz);
|
|
light = (pl->lightlevel >> LIGHTSEGSHIFT)+::g->extralight;
|
|
|
|
if (light >= LIGHTLEVELS)
|
|
light = LIGHTLEVELS-1;
|
|
|
|
if (light < 0)
|
|
light = 0;
|
|
|
|
::g->planezlight = ::g->zlight[light];
|
|
|
|
pl->top[pl->maxx+1] = 0xffff;
|
|
pl->top[pl->minx-1] = 0xffff;
|
|
|
|
stop = pl->maxx + 1;
|
|
|
|
for (x=pl->minx ; x<= stop ; x++)
|
|
{
|
|
R_MakeSpans(x,pl->top[x-1],
|
|
pl->bottom[x-1],
|
|
pl->top[x],
|
|
pl->bottom[x]);
|
|
}
|
|
}
|
|
}
|
|
|