Iskhodnyy_kod_Doom

//R_PointToAngle

//To get a global angle from cartesian coordinates,

//the coordinates are flipped until they are in

//the first octant of the coordinate system, then

//the y (<=x) is scaled and divided by x to get a

//tangent (slope) value which is looked up in the

//tantoangle[] table.

//

if ( (!x) && (!y) ) return 0;

if (x>= 0)

{

// x >=0 if (y>= 0)

{

// y>= 0

if (x>y)

{

// octant 0

return tantoangle[ SlopeDiv(y,x)];

}

else

{

// octant 1

return ANG90-1-tantoangle[ SlopeDiv(x,y)];

}

}

else

{

// y<0 y = -y;

if (x>y)

{

// octant 8

return -tantoangle[SlopeDiv(y,x)];

}

else

{

// octant 7

return ANG270+tantoangle[ SlopeDiv(x,y)];

}

}

}

else

{

// x<0 x = -x;

if (y>= 0)

651

{

// y>= 0 if (x>y)

{

// octant 3

return ANG180-1-tantoangle[ SlopeDiv(y,x)];

}

else

{

// octant 2

return ANG90+ tantoangle[ SlopeDiv(x,y)];

}

}

else

{

// y<0 y = -y;

if (x>y)

{

// octant 4

return ANG180+tantoangle[ SlopeDiv(y,x)];

}

else

{

// octant 5

return ANG270-1-tantoangle[ SlopeDiv(x,y)];

}

}

}

return 0;

}

angle_t R_PointToAngle2

(fixed_t x1, fixed_t y1,

{

viewx = x1; viewy = y1;

return R_PointToAngle (x2, y2);

}

dx = abs(x - viewx); dy = abs(y - viewy);

if (dy>dx)

{

temp = dx;

652

dx = dy; dy = temp;

}

angle = (tantoangle[ FixedDiv(dy,dx)>>DBITS ]+ANG90) >> ANGLETOFINESHIFT;

}

//

// R_InitPointToAngle

//

void R_InitPointToAngle (void)

{

// UNUSED - now getting from tables.c #if 0

int long float

//

// slope (tangent) to angle lookup

//

for (i=0 ; i<=SLOPERANGE ; i++)

{

f = atan( (float)i/SLOPERANGE )/(3.141592657*2); t = 0xffffffff*f;

tantoangle[i] = t;

}

#endif

}

//

//R_ScaleFromGlobalAngle

//Returns the texture mapping scale

//for the current line (horizontal span)

//at the given angle.

//rw_distance must be calculated first.

fixed_t R_ScaleFromGlobalAngle (angle_t visangle)

{

sinv = finesine[(visangle-rw_normalangle)>>ANGLETOFINESHIFT]; dist = FixedDiv (rw_distance, sinv);

653

cosv = finecosine[(viewangle-visangle)>>ANGLETOFINESHIFT]; z = abs(FixedMul (dist, cosv));

scale = FixedDiv(projection, z); return scale;

}

#endif

anglea = ANG90 + (visangle-viewangle); angleb = ANG90 + (visangle-rw_normalangle);

// both sines are allways positive

sinea = finesine[anglea>>ANGLETOFINESHIFT]; sineb = finesine[angleb>>ANGLETOFINESHIFT]; num = FixedMul(projection,sineb)<<detailshift; den = FixedMul(rw_distance,sinea);

if (den > num>>16)

{

scale = FixedDiv (num, den);

if (scale > 64*FRACUNIT) scale = 64*FRACUNIT;

else if (scale < 256) scale = 256;

}

else

scale = 64*FRACUNIT;

return scale;

}

//

// R_InitTables

//

void R_InitTables (void)

{

// UNUSED: now getting from tables.c

// viewangle tangent table

for (i=0 ; i<FINEANGLES/2 ; i++)

{

a = (i-FINEANGLES/4+0.5)*PI*2/FINEANGLES; fv = FRACUNIT*tan (a);

t = fv; finetangent[i] = t;

}

// finesine table

for (i=0 ; i<5*FINEANGLES/4 ; i++)

{

// OPTIMIZE: mirror...

a = (i+0.5)*PI*2/FINEANGLES; t = FRACUNIT*sin (a); finesine[i] = t;

}

#endif

}

654

//

// R_InitTextureMapping

//

void R_InitTextureMapping (void)

{

//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;

}

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];

655

}

//

//R_InitLightTables

//Only inits the zlight table,

//because the scalelight table changes with view size.

void R_InitLightTables (void)

{

//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 int

int

void R_SetViewSize ( int

int

{

setsizeneeded = true; setblocks = blocks; setdetail = detail;

}

656

//

// R_ExecuteSetViewSize

//

void R_ExecuteSetViewSize (void)

{

setsizeneeded = false;

if (setblocks == 11)

{

scaledviewwidth = SCREENWIDTH; viewheight = SCREENHEIGHT;

}

else

{

scaledviewwidth = setblocks*32; viewheight = (setblocks*168/10)&~7;

}

detailshift = setdetail;

viewwidth = scaledviewwidth>>detailshift;

centery = viewheight/2; centerx = viewwidth/2;

centerxfrac = centerx<<FRACBITS; 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);

R_InitTextureMapping ();

// psprite scales

pspritescale = FRACUNIT*viewwidth/SCREENWIDTH; pspriteiscale = FRACUNIT*SCREENWIDTH/viewwidth;

// 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;

657

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;

void R_Init (void)

{

R_InitData ();

printf ("\nR_InitData"); R_InitPointToAngle ();

printf ("\nR_InitPointToAngle"); R_InitTables ();

// viewwidth / viewheight / detailLevel are set by the defaults printf ("\nR_InitTables");

R_SetViewSize (screenblocks, detailLevel);

R_InitPlanes ();

printf ("\nR_InitPlanes"); R_InitLightTables ();

printf ("\nR_InitLightTables"); R_InitSkyMap ();

printf ("\nR_InitSkyMap"); R_InitTranslationTables ();

printf ("\nR_InitTranslationsTables");

framecount = 0;

}

//

658

// R_PointInSubsector

//

subsector_t* R_PointInSubsector

// 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

//

void R_SetupFrame (player_t* player)

{

int i;

viewplayer = player; viewx = player->mo->x; viewy = player->mo->y;

viewangle = player->mo->angle + viewangleoffset; extralight = player->extralight;

viewz = player->viewz;

viewsin = finesine[viewangle>>ANGLETOFINESHIFT]; viewcos = finecosine[viewangle>>ANGLETOFINESHIFT];

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++;

659

}

//

// R_RenderView

//

void R_RenderPlayerView (player_t* player)

{

R_SetupFrame (player);

//Clear buffers. R_ClearClipSegs (); R_ClearDrawSegs (); R_ClearPlanes (); R_ClearSprites ();

//check for new console commands. NetUpdate ();

//The head node is the last node output. R_RenderBSPNode (numnodes-1);

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

R_DrawPlanes ();

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

R_DrawMasked ();

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

}

10.10r main.h

// Emacs style mode select -*- C++ -*- //-----------------------------------------------------------------------------

//

//$Id:$

//Copyright (C) 1993-1996 by id Software, Inc.

//This program 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 2

//of the License, or (at your option) any later version.

//

//This program 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.

//

//DESCRIPTION:

//System specific interface stuff.

//-----------------------------------------------------------------------------

#ifndef __R_MAIN__ #define __R_MAIN__

660