doom

r_plane.c (6029B)

---

 #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"
 
 planefunction_t		floorfunc;
 planefunction_t		ceilingfunc;
 #define MAXVISPLANES	128
 visplane_t		visplanes[MAXVISPLANES];
 visplane_t*		lastvisplane;
 visplane_t*		floorplane;
 visplane_t*		ceilingplane;
 #define MAXOPENINGS	SCREENWIDTH*64
 short			openings[MAXOPENINGS];
 short*			lastopening;
 short			floorclip[SCREENWIDTH];
 short			ceilingclip[SCREENWIDTH];
 int			spanstart[SCREENHEIGHT];
 int			spanstop[SCREENHEIGHT];
 lighttable_t**		planezlight;
 fixed_t			planeheight;
 fixed_t			yslope[SCREENHEIGHT];
 fixed_t			distscale[SCREENWIDTH];
 fixed_t			basexscale;
 fixed_t			baseyscale;
 fixed_t			cachedheight[SCREENHEIGHT];
 fixed_t			cacheddistance[SCREENHEIGHT];
 fixed_t			cachedxstep[SCREENHEIGHT];
 fixed_t			cachedystep[SCREENHEIGHT];
 
 void
 R_InitPlanes()
 {
 }
 
 void
 R_MapPlane(int y, int x1, int x2)
 {
     angle_t angle;
     fixed_t distance, length;
     uint index;
 	
     if (planeheight != cachedheight[y]) {
 		cachedheight[y] = planeheight;
 		distance = cacheddistance[y] = FixedMul (planeheight, yslope[y]);
 		ds_xstep = cachedxstep[y] = FixedMul (distance,basexscale);
 		ds_ystep = cachedystep[y] = FixedMul (distance,baseyscale);
     } else {
 		distance = cacheddistance[y];
 		ds_xstep = cachedxstep[y];
 		ds_ystep = cachedystep[y];
     }
     length = FixedMul (distance,distscale[x1]);
     angle = (viewangle + xtoviewangle[x1])>>ANGLETOFINESHIFT;
     ds_xfrac = viewx + FixedMul(finecosine[angle], length);
     ds_yfrac = -viewy - FixedMul(finesine[angle], length);
     if (fixedcolormap) {
 		ds_colormap = fixedcolormap;
 	} else {
 		index = distance >> LIGHTZSHIFT;
 		if (index >= MAXLIGHTZ )
 			index = MAXLIGHTZ-1;
 		ds_colormap = planezlight[index];
     }
     ds_y = y;
     ds_x1 = x1;
     ds_x2 = x2;
     spanfunc();	
 }
 
 void
 R_ClearPlanes (void)
 {
     int		i;
     angle_t	angle;
     
     
     for (i=0 ; i<viewwidth ; i++)
     {
 	floorclip[i] = viewheight;
 	ceilingclip[i] = -1;
     }
 
     lastvisplane = visplanes;
     lastopening = openings;
     
     
     memset (cachedheight, 0, sizeof(cachedheight));
 
     
     angle = (viewangle-ANG90)>>ANGLETOFINESHIFT;
 	
     
     basexscale = FixedDiv (finecosine[angle],centerxfrac);
     baseyscale = -FixedDiv (finesine[angle],centerxfrac);
 }
 
 
 
 
 
 
 
 visplane_t*
 R_FindPlane
 ( fixed_t	height,
   int		picnum,
   int		lightlevel )
 {
     visplane_t*	check;
 	
     if (picnum == skyflatnum)
     {
 	height = 0;			
 	lightlevel = 0;
     }
 	
     for (check=visplanes; check<lastvisplane; check++)
     {
 	if (height == check->height
 	    && picnum == check->picnum
 	    && lightlevel == check->lightlevel)
 	{
 	    break;
 	}
     }
     
 			
     if (check < lastvisplane)
 	return check;
 		
     if (lastvisplane - visplanes == MAXVISPLANES)
 	I_Error ("R_FindPlane: no more visplanes");
 		
     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;
 }
 
 
 
 
 
 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] != 0xff)
 	    break;
 
     if (x > intrh)
     {
 	pl->minx = unionl;
 	pl->maxx = unionh;
 
 	
 	return pl;		
     }
 	
     
     lastvisplane->height = pl->height;
     lastvisplane->picnum = pl->picnum;
     lastvisplane->lightlevel = pl->lightlevel;
     
     pl = lastvisplane++;
     pl->minx = start;
     pl->maxx = stop;
 
     memset (pl->top,0xff,sizeof(pl->top));
 		
     return pl;
 }
 
 
 
 
 
 void
 R_MakeSpans
 ( int		x,
   int		t1,
   int		b1,
   int		t2,
   int		b2 )
 {
     while (t1 < t2 && t1<=b1)
     {
 	R_MapPlane (t1,spanstart[t1],x-1);
 	t1++;
     }
     while (b1 > b2 && b1>=t1)
     {
 	R_MapPlane (b1,spanstart[b1],x-1);
 	b1--;
     }
 	
     while (t2 < t1 && t2<=b2)
     {
 	spanstart[t2] = x;
 	t2++;
     }
     while (b2 > b1 && b2>=t2)
     {
 	spanstart[b2] = x;
 	b2--;
     }
 }
 
 
 
 
 
 
 
 void R_DrawPlanes (void)
 {
     visplane_t*		pl;
     int			light;
     int			x;
     int			stop;
     int			angle;
 				
 #ifdef RANGECHECK
     if (ds_p - drawsegs > MAXDRAWSEGS)
 	I_Error ("R_DrawPlanes: drawsegs overflow (%i)",
 		 ds_p - drawsegs);
     
     if (lastvisplane - visplanes > MAXVISPLANES)
 	I_Error ("R_DrawPlanes: visplane overflow (%i)",
 		 lastvisplane - visplanes);
     
     if (lastopening - openings > MAXOPENINGS)
 	I_Error ("R_DrawPlanes: opening overflow (%i)",
 		 lastopening - openings);
 #endif
 
     for (pl = visplanes ; pl < lastvisplane ; pl++)
     {
 	if (pl->minx > pl->maxx)
 	    continue;
 
 	
 	
 	if (pl->picnum == skyflatnum)
 	{
 	    dc_iscale = pspriteiscale>>detailshift;
 	    
 	    
 	    
 	    
 	    
 	    dc_colormap = colormaps;
 	    dc_texturemid = skytexturemid;
 	    for (x=pl->minx ; x <= pl->maxx ; x++)
 	    {
 		dc_yl = pl->top[x];
 		dc_yh = pl->bottom[x];
 
 		if (dc_yl <= dc_yh)
 		{
 		    angle = (viewangle + xtoviewangle[x])>>ANGLETOSKYSHIFT;
 		    dc_x = x;
 		    dc_source = R_GetColumn(skytexture, angle);
 		    colfunc ();
 		}
 	    }
 	    continue;
 	}
 	
 	
 	ds_source = W_CacheLumpNum(firstflat +
 				   flattranslation[pl->picnum],
 				   PU_STATIC);
 	
 	planeheight = abs(pl->height-viewz);
 	light = (pl->lightlevel >> LIGHTSEGSHIFT)+extralight;
 
 	if (light >= LIGHTLEVELS)
 	    light = LIGHTLEVELS-1;
 
 	if (light < 0)
 	    light = 0;
 
 	planezlight = zlight[light];
 
 	pl->top[pl->maxx+1] = 0xff;
 	pl->top[pl->minx-1] = 0xff;
 		
 	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]);
 	}
 	
 	Z_ChangeTag (ds_source, PU_CACHE);
     }
 }