r_main.c

游戏类程序源代码---WinDoom 3D源程序.zip

	// OPTIMIZE: mirror...
	a = (i+0.5)*PI*2/FINEANGLES;
	t = FRACUNIT*sin (a);
	finesine[i] = t;
    }
#endif

}



//
// R_InitTextureMapping
//
// original function, before stereoscopy added
//void R_InitTextureMapping (void)
//{
//    int			i;
//    int			x;
//    int			t;
//    fixed_t		focallength;
//    
//    // Use tangent table to generate viewangletox:
//    //  viewangletox will give the next greatest x
//    //  after the view angle.
//    //
//    // Calc focallength
//    //  so FIELDOFVIEW angles covers SCREENWIDTH.
//    focallength = FixedDiv (centerxfrac,
//			    finetangent[FINEANGLES/4+FIELDOFVIEW/2] );
//	
//    for (i=0 ; i<FINEANGLES/2 ; i++)
//    {
//	if (finetangent[i] > FRACUNIT*2)
//	    t = -1;
//	else if (finetangent[i] < -FRACUNIT*2)
//	    t = viewwidth+1;
//	else
//	{
//	    t = FixedMul (finetangent[i], focallength);
//	    t = (centerxfrac - t+FRACUNIT-1)>>FRACBITS;
//
//	    if (t < -1)
//		t = -1;
//	    else if (t>viewwidth+1)
//		t = viewwidth+1;
//	}
//	viewangletox[i] = t;
//    }
//    
//    // Scan viewangletox[] to generate xtoviewangle[]:
//    //  xtoviewangle will give the smallest view angle
//    //  that maps to x.	
//    for (x=0;x<=viewwidth;x++)
//    {
//	i = 0;
//	while (viewangletox[i]>x)
//	    i++;
//	xtoviewangle[x] = (i<<ANGLETOFINESHIFT)-ANG90;
//    }
//    
//    // Take out the fencepost cases from viewangletox.
//    for (i=0 ; i<FINEANGLES/2 ; i++)
//    {
//	t = FixedMul (finetangent[i], focallength);
//	t = centerx - t;
//	
//	if (viewangletox[i] == -1)
//	    viewangletox[i] = 0;
//	else if (viewangletox[i] == viewwidth+1)
//	    viewangletox[i]  = viewwidth;
//    }
//	
//    clipangle = xtoviewangle[0];
//}

// DQ start addition
void R_InitTextureMapping (fixed_t fcenterxfrac,
									int PixelOffset,
									int lpviewangletox[], 
									angle_t lpxtoviewangle[],
									fixed_t *eyecameraxfrac,
									angle_t *lpleftclipangle,
									angle_t *lprightclipangle)
{
	int			i;
	int			t;
	int			x;
	fixed_t		cameraxfrac;
	int			camerax;
	fixed_t		focallength;

	// this does not make sense, unless we are expecting to have a variable field of
	// view.  For a 90 degree FOV, focallength is SCREENWIDTH/2
	focallength = FixedDiv (fcenterxfrac, finetangent[FINEANGLES/4+FIELDOFVIEW/2] );

	// DQ note
	// I had planned to adjust the angle tables to accomodate the different camera.
	// positions.  I want to put the plane of zero disparity at PLAYERRADIUS, so the
	// walls will never stick out of the screen.  But, I found that if each eye has
	// a different angle table, then narrow horizontal lines differ between the views.  For
	// example, a narrow horizontal line may not be seen by one eye (or be very narrow), yet
	// be seen as usual by the other eye.  This makes it difficult to view stereo.  I
	// think that this is due to rounding problems.  I need to track it down.  So, for now
	// each eye sees the same angles.  The stereo effect will be done exclusively by
	// sidestepping the player for each rendering (in R_SetupFrame).  The plane of 
	// zero disparity will be moved in by adjusting LCD_YAW.
	camerax = (fcenterxfrac >> FRACBITS); // + PixelOffset;
	cameraxfrac = camerax << FRACBITS;
	if (eyecameraxfrac != NULL)
	{
		*eyecameraxfrac = cameraxfrac;
	}
	for (i=0 ; i<FINEANGLES/2 ; i++)
	{
		if (finetangent[i] > FRACUNIT*2)
			t = -1;
		else if (finetangent[i] < -FRACUNIT*2)
			t = viewwidth+1;
		else
		{
			t = FixedMul (finetangent[i], focallength);
			t = (cameraxfrac - t+FRACUNIT-1)>>FRACBITS;

			if (t < -1)
				t = -1;
			else if (t>viewwidth+1)
				t = viewwidth+1;
		}
		lpviewangletox[i] = t;
	}

	// Scan viewangletox[] to generate xtoviewangle[]:
	//  xtoviewangle will give the smallest view angle
	//  that maps to x.	
	for (x=0;x<=viewwidth;x++)
	{
		i = 0;
		while (lpviewangletox[i]>x)
			i++;
		lpxtoviewangle[x] = (i<<ANGLETOFINESHIFT)-ANG90;
	}

	// Take out the fencepost cases from viewangletox.
	for (i=0 ; i<FINEANGLES/2 ; i++)
	{
		t = FixedMul (finetangent[i], focallength);
		t = camerax - t;

		if (lpviewangletox[i] == -1)
			lpviewangletox[i] = 0;
		else if (lpviewangletox[i] == viewwidth+1)
			lpviewangletox[i]  = viewwidth;
	}

	// left clip angle is measured clockwise from straight ahead.
	*lpleftclipangle = lpxtoviewangle[0];
	// right clip angle is desired to be measured from straight ahead, counterclockwise.
	// but, it is currently recorded as the angle from straight ahead, all the clockwise way
	// around to the right edge.  Thus, the angle we want is 360 - lpxtoviewangle[viewwidth];
	// Since 360 degrees equals 0 degrees, the angle we want is - lpxtoviewangle[viewwidth]
	*lprightclipangle = (lpxtoviewangle[viewwidth] * -1);
}
// DQ end addition


//
// R_InitLightTables
// Only inits the zlight table,
//  because the scalelight table changes with view size.
//
#define DISTMAP		2

void R_InitLightTables (void)
{
    int		i;
    int		j;
    int		level;
    int		startmap; 	
    int		scale;
    
    // Calculate the light levels to use
    //  for each level / distance combination.
    for (i=0 ; i< LIGHTLEVELS ; i++)
    {
	startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
	for (j=0 ; j<MAXLIGHTZ ; j++)
	{
	    scale = FixedDiv ((SCREENWIDTH/2*FRACUNIT), (j+1)<<LIGHTZSHIFT);
	    scale >>= LIGHTSCALESHIFT;
	    level = startmap - scale/DISTMAP;
	    
	    if (level < 0)
		level = 0;

	    if (level >= NUMCOLORMAPS)
		level = NUMCOLORMAPS-1;

	    zlight[i][j] = colormaps + level*256;
	}
    }
}



//
// R_SetViewSize
// Do not really change anything here,
//  because it might be in the middle of a refresh.
// The change will take effect next refresh.
//
boolean		setsizeneeded;
int		setblocks;
int		setdetail;


void
R_SetViewSize
( int		blocks,
  int		detail )
{
    setsizeneeded = true;
    setblocks = blocks;
    setdetail = detail;
}


void WriteDebug(char *);

// DQ start addition
// recompute the camera position, based upon the eye position

void R_SetCameraPosition(BOOL bLeftEye)
{
	if (bLeftEye)
	{
		viewangletox = lefteyeviewangletox;
		xtoviewangle = lefteyextoviewangle;
		centerxfrac = leftcameraxfrac;
		projection = leftcameraxfrac;
		leftclipangle = lefteyeleftclipangle;
		rightclipangle = lefteyeleftclipangle;
	}
	else
	{
		viewangletox = righteyeviewangletox;
		xtoviewangle = righteyextoviewangle;
		centerxfrac = rightcameraxfrac;
		projection = rightcameraxfrac;
		leftclipangle = righteyeleftclipangle;
		rightclipangle = righteyerightclipangle;
	}
}
// DQ end addition


//
// R_ExecuteSetViewSize
//
// DQ start addition
void R_ExecuteSetViewSize (int iRightPixelOffset, 
									int iLeftPixelOffset)
// DQ end addition
// void R_ExecuteSetViewSize (void)  // original value
   {
    fixed_t	cosadj;
    fixed_t	dy;
    int		i;
    int		j;
    int		level;
    int		startmap; 	

    setsizeneeded = false;

    if (setblocks == 11)
       {
        scaledviewwidth = SCREENWIDTH;
        viewheight = SCREENHEIGHT;
       }
    else
       {
        scaledviewwidth = (setblocks*SCREENWIDTH)/10;
        viewheight = ((setblocks*(SCREENHEIGHT-SBARHEIGHT))/10)&~7;
       }
    
    detailshift = setdetail;
	 viewwidth = scaledviewwidth>>detailshift;
	
    centery = viewheight/2;
	 // DQ start addition
    //centerx = viewwidth/2;		
    centerxfrac = viewwidth/2<<FRACBITS;
	 // DQ end addition
    // centerx = viewwidth/2;  // original line
    //centerxfrac = centerx<<FRACBITS;	// original line
    centeryfrac = centery<<FRACBITS;
    projection = centerxfrac;

    if (!detailshift)
    {
	colfunc = basecolfunc = R_DrawColumn;
	fuzzcolfunc = R_DrawFuzzColumn;
	transcolfunc = R_DrawTranslatedColumn;
	spanfunc = R_DrawSpan;
    }
    else
    {
	colfunc = basecolfunc = R_DrawColumnLow;
	fuzzcolfunc = R_DrawFuzzColumn;
	transcolfunc = R_DrawTranslatedColumn;
	spanfunc = R_DrawSpanLow;
    }

    R_InitBuffer (scaledviewwidth, viewheight);

	 // DQ start addition
	 // create separate angle/x tables for each eye's perspective

	 R_InitTextureMapping (centerxfrac,
									iRightPixelOffset << detailshift,  // offset more to counter the lower detail
									righteyeviewangletox, 
									righteyextoviewangle,
									&rightcameraxfrac,
									&righteyeleftclipangle,
									&righteyerightclipangle);
	 R_InitTextureMapping (centerxfrac,
									iLeftPixelOffset << detailshift,  // offset more to counter the lower detail
									lefteyeviewangletox, 
									lefteyextoviewangle,
									&leftcameraxfrac,
									&lefteyeleftclipangle,
									&lefteyerightclipangle);
//DD_Error(rightcameraxfrac, "rightcameraxfrac");
//DD_Error(leftcameraxfrac, "leftcameraxfrac");
	 // DQ end addition
    // R_InitTextureMapping ();		// original line
    
    // psprite scales
//    pspritescale = FRACUNIT*viewwidth/SCREENWIDTH;
//    pspriteiscale = FRACUNIT*SCREENWIDTH/viewwidth;

    //pspritescale = FRACUNIT*viewwidth/320;
    //pspriteiscale = FRACUNIT*320/viewheight;
    if (setblocks != 10)
       {
        pspritescale = FRACUNIT*viewheight/200;
        pspriteiscale = FRACUNIT*200/viewheight;
       }
    else
       {
        pspritescale = FRACUNIT*(viewheight+32)/200;
        pspriteiscale = FRACUNIT*200/(viewheight+32);
       }
    
    // thing clipping
    for (i=0 ; i<viewwidth ; i++)
	screenheightarray[i] = viewheight;
    
    // planes
    for (i=0 ; i<viewheight ; i++)
    {
	dy = ((i-viewheight/2)<<FRACBITS)+FRACUNIT/2;
	dy = abs(dy);
	yslope[i] = FixedDiv ( (viewwidth<<detailshift)/2*FRACUNIT, dy);
    }
	
    for (i=0 ; i<viewwidth ; i++)
    {
	cosadj = abs(finecosine[xtoviewangle[i]>>ANGLETOFINESHIFT]);
	distscale[i] = FixedDiv (FRACUNIT,cosadj);
    }
    
    // Calculate the light levels to use
    //  for each level / scale combination.
    for (i=0 ; i< LIGHTLEVELS ; i++)
    {
	startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
	for (j=0 ; j<MAXLIGHTSCALE ; j++)
	{
	    level = startmap - j*SCREENWIDTH/(viewwidth<<detailshift)/DISTMAP;
	    
	    if (level < 0)
		level = 0;

	    if (level >= NUMCOLORMAPS)
		level = NUMCOLORMAPS-1;

	    scalelight[i][j] = colormaps + level*256;
	}
    }
//    R_DrawViewBorder(RenderBuffer, BackBuffer);	// DQ removed, distributed to calls to R_ExecuteSetViewSize
}



//
// R_Init
//
extern int	detailLevel;
extern int	screenblocks;



void R_Init (void)
   {
    R_InitData ();
    //WriteDebug("\nR_InitData");
    R_InitPointToAngle();
    //WriteDebug("\nR_InitPointToAngle");
    R_InitTables ();
    // viewwidth / viewheight / detailLevel are set by the defaults
    //WriteDebug("\nR_InitTables");

    R_SetViewSize (screenblocks, detailLevel);
    R_InitPlanes ();
    //WriteDebug("\nR_InitPlanes");
    R_InitLightTables ();
    //WriteDebug("\nR_InitLightTables");
    R_InitSkyMap ();
    //WriteDebug("\nR_InitSkyMap");
    R_InitTranslationTables ();
    //WriteDebug("\nR_InitTranslationsTables");
    R_InitFuzzTable();

    framecount = 0;
   }


//
// R_PointInSubsector
//
subsector_t*
R_PointInSubsector
( fixed_t	x,
  fixed_t	y )
{
    node_t*	node;
    int		side;
    int		nodenum;

    // single subsector is a special case
    if (!numnodes)				
	return subsectors;
		
    nodenum = numnodes-1;

    while (! (nodenum & NF_SUBSECTOR) )
    {
	node = &nodes[nodenum];
	side = R_PointOnSide (x, y, node);
	nodenum = node->children[side];
    }
	
    return &subsectors[nodenum & ~NF_SUBSECTOR];
}



//
// R_SetupFrame
//
// DQ - modified to support eyesep and eyeviewangle (in 16th of a degree)
void R_SetupFrame (player_t* player, fixed_t PixelOffset, int eyeviewangle)
// void R_SetupFrame (player_t* player)  // original
   {		
    int  i;
    
    viewplayer = player;
    viewx = player->mo->x;
    viewy = player->mo->y;
    viewangle = player->mo->angle + viewangleoffset;

	 // DQ start addition
	 if (eyeviewangle != 0)
	 {
		 viewangle += ANG90 / ((90 * 16) / eyeviewangle);  // no multiply, to avoid overflow
	 }
	 // DQ end addition

    extralight = player->extralight;

    viewz = player->viewz;
    
    viewsin = finesine[viewangle>>ANGLETOFINESHIFT];
    viewcos = finecosine[viewangle>>ANGLETOFINESHIFT];

	 // DQ start addition
	 // offset the camera position to the point used to generate the angle vs x table
	 viewx += FixedMul(PixelOffset, viewsin);
	 viewy -= FixedMul(PixelOffset, viewcos);
//DD_Error(FixedMul(PixelOffset, viewsin), "X camera offset");
//DD_Error(FixedMul(PixelOffset, viewcos), "Y camera offset");
	 // DQ end addition

    sscount = 0;
	
    if (player->fixedcolormap)
       {
        fixedcolormap = colormaps + player->fixedcolormap*256*sizeof(lighttable_t);
        walllights = scalelightfixed;
        for (i = 0; i < MAXLIGHTSCALE; i++)
           scalelightfixed[i] = fixedcolormap;
       }
    else
       fixedcolormap = 0;
	
    framecount++;
    validcount++;
   }

//
// R_RenderView
//
// DQ - modified to support eyesep and eyeviewangle (in 16th of a degree)
void R_RenderPlayerView (player_t* player, 
								 fixed_t PixelOffset, 
								 int eyeviewangle,
								 PBUFFER ViewWindowBuffer)
//void R_RenderPlayerView (player_t* player)
   {
    R_SetupFrame(player, PixelOffset, eyeviewangle);

    // Clear buffers.
    R_ClearClipSegs();
    R_ClearDrawSegs();
    R_ClearPlanes();
    R_ClearSprites();
    
    // check for new console commands.
    NetUpdate ();

	 if (bInGame) /*DQ*/
	 {
		// The head node is the last node output.
		R_RenderBSPNode (numnodes-1, ViewWindowBuffer/*DQ*/);
	 }
    
    // Check for new console commands.
    NetUpdate ();
    
	 if (bInGame) // DQ
	 {
		R_DrawPlanes (ViewWindowBuffer/*DQ*/);
	 }
    
    // Check for new console commands.
    NetUpdate ();
    
	 if (bInGame)
	 {
		R_DrawMasked (ViewWindowBuffer/*DQ*/);
	 }

    // Check for new console commands.
    NetUpdate ();				
}