mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2025-03-16 15:41:16 +00:00
458 lines
8.9 KiB
C++
458 lines
8.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] );
|
|
}
|
|
}
|
|
}
|
|
|