射击游戏

开发平台：
Visual C++

r_plane.c：源码内容
							// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION:
//	Here is a core component: drawing the floors and ceilings,
//	 while maintaining a per column clipping list only.
//	Moreover, the sky areas have to be determined.
//
//-----------------------------------------------------------------------------
static const char
rcsid[] = "$Id: r_plane.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";
#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"
planefunction_t		floorfunc;
planefunction_t		ceilingfunc;
//
// opening
//
// Here comes the obnoxious "visplane".
#define MAXVISPLANES	128
visplane_t		visplanes[MAXVISPLANES];
visplane_t*		lastvisplane;
visplane_t*		floorplane;
visplane_t*		ceilingplane;
// ?
//#define MAXOPENINGS	SCREENWIDTH*64
int MAXOPENINGS = 0;
short          *openings;
//short			openings[MAXOPENINGS];
short*			lastopening;
//
// Clip values are the solid pixel bounding the range.
//  floorclip starts out SCREENHEIGHT
//  ceilingclip starts out -1
//
short          *floorclip;
short          *ceilingclip;
//short			floorclip[SCREENWIDTH];
//short			ceilingclip[SCREENWIDTH];
//
// spanstart holds the start of a plane span
// initialized to 0 at start
//
int			*spanstart;
int			*spanstop;
//int			spanstart[SCREENHEIGHT];
//int			spanstop[SCREENHEIGHT];
//
// texture mapping
//
lighttable_t**		planezlight;
fixed_t			planeheight;
fixed_t        *yslope;
fixed_t        *distscale;
//fixed_t			yslope[SCREENHEIGHT];
//fixed_t			distscale[SCREENWIDTH];
fixed_t			basexscale;
fixed_t			baseyscale;
fixed_t        *cachedheight;
fixed_t        *cacheddistance;
fixed_t        *cachedxstep;
fixed_t        *cachedystep;
//fixed_t			cachedheight[SCREENHEIGHT];
//fixed_t			cacheddistance[SCREENHEIGHT];
//fixed_t			cachedxstep[SCREENHEIGHT];
//fixed_t			cachedystep[SCREENHEIGHT];
//
// R_InitPlanes
// Only at game startup.
//
void R_InitPlanes (void)
   {
    int         i;
    // Doh!
    MAXOPENINGS = SCREENWIDTH*64;
    openings = (short *)calloc(MAXOPENINGS,sizeof(short));
    for (i = 0; i < MAXVISPLANES; i++)
       {
        visplanes[i].topbase = (unsigned short *)calloc(SCREENWIDTH+2,sizeof(unsigned short));
        visplanes[i].top = &visplanes[i].topbase[1];
        visplanes[i].bottombase = (unsigned short *)calloc(SCREENWIDTH+2,sizeof(unsigned short));
        visplanes[i].bottom = &visplanes[i].bottombase[1];
       }
    floorclip = (short *)calloc(SCREENWIDTH,sizeof(short));
    ceilingclip = (short *)calloc(SCREENWIDTH,sizeof(short));
    spanstart = (int *)calloc(SCREENHEIGHT,sizeof(int));
    spanstop = (int*)calloc(SCREENHEIGHT,sizeof(int));
    yslope = (fixed_t *)calloc(SCREENHEIGHT,sizeof(fixed_t));
    distscale = (fixed_t *)calloc(SCREENWIDTH,sizeof(fixed_t));
    cachedheight = (fixed_t *)calloc(SCREENHEIGHT,sizeof(fixed_t));
    cacheddistance = (fixed_t *)calloc(SCREENHEIGHT,sizeof(fixed_t));
    cachedxstep = (fixed_t *)calloc(SCREENHEIGHT,sizeof(fixed_t));
    cachedystep = (fixed_t *)calloc(SCREENHEIGHT,sizeof(fixed_t));
   }
//
// R_MapPlane
//
// Uses global vars:
//  planeheight
//  ds_source
//  basexscale
//  baseyscale
//  viewx
//  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>=viewwidth
	|| (unsigned)y>(unsigned)viewheight)
    {
	I_Error ("R_MapPlane: %i, %i at %i",x1,x2,y);
    }
#endif
    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;
    // high or low detail
    spanfunc ();	
}
//
// R_ClearPlanes
// At begining of frame.
//
void R_ClearPlanes(void)
   {
    int     i;
    angle_t	angle;
    
    // opening / clipping determination
    for (i = 0; i < viewwidth; i++)
       {
        floorclip[i] = viewheight;
        ceilingclip[i] = -1;
       }
    lastvisplane = visplanes;
    lastopening = openings;
    
    // texture calculation
    memset (cachedheight, 0, (sizeof(fixed_t)*SCREENHEIGHT));
    // left to right mapping
    angle = (viewangle-ANG90)>>ANGLETOFINESHIFT;
	
    // scale will be unit scale at SCREENWIDTH/2 distance
    basexscale = FixedDiv (finecosine[angle],centerxfrac);
    baseyscale = -FixedDiv (finesine[angle],centerxfrac);
   }
//
// R_FindPlane
//
visplane_t *R_FindPlane( fixed_t height, int picnum, int lightlevel )
   {
    visplane_t*	check;
	
    if (picnum == skyflatnum)
       {
        height = 0;			// all skys map together
        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->topbase,0xffff,sizeof(unsigned short)*(SCREENWIDTH+2)); // HIRES
		
    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) // HIRES
	    break;
    if (x > intrh)
    {
	pl->minx = unionl;
	pl->maxx = unionh;
	// use the same one
	return pl;		
    }
	
    // make a new visplane
    lastvisplane->height = pl->height;
    lastvisplane->picnum = pl->picnum;
    lastvisplane->lightlevel = pl->lightlevel;
    
    pl = lastvisplane++;
    pl->minx = start;
    pl->maxx = stop;
    memset (pl->topbase,0xffff,sizeof(unsigned short)*(SCREENWIDTH+2)); // HIRES
		
    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,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--;
    }
}
//
// 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 (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;
	
        // sky flat
        if (pl->picnum == skyflatnum)
           {
            dc_iscale = pspriteiscale>>detailshift;
	    
            // Sky is allways drawn full bright,
            //  i.e. colormaps[0] is used.
            // Because of this hack, sky is not affected
            //  by INVUL inverse mapping.
            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;
           }
	
        // regular flat
        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] = 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]);
           }
		Z_ChangeTag (ds_source, PU_CACHE);
       }
   }

						