fixed_t FixedHypot(fixed_t x, fixed_t y)
{
#ifdef HAVE_HYPOT
const float fx = FIXED_TO_FLOAT(x);
const float fy = FIXED_TO_FLOAT(y);
float fz;
#ifdef HAVE_HYPOTF
fz = hypotf(fx, fy);
#else
fz = (float)hypot(fx, fy);
#endif
return FLOAT_TO_FIXED(fz);
#else // !HAVE_HYPOT
fixed_t ax, yx, yx2, yx1;
if (abs(y) > abs(x)) // |y|>|x|
{
ax = abs(y); // |y| => ax
yx = FixedDiv(x, y); // (x/y)
}
else // |x|>|y|
{
ax = abs(x); // |x| => ax
yx = FixedDiv(y, x); // (x/y)
}
yx2 = FixedMul(yx, yx); // (x/y)^2
yx1 = FixedSqrt(1+FRACUNIT + yx2); // (1 + (x/y)^2)^1/2
return FixedMul(ax, yx1); // |x|*((1 + (x/y)^2)^1/2)
#endif
}
/*
void AM_addMark(void)
{
markpoints[markpointnum].x = m_x + m_w/2;
markpoints[markpointnum].y = m_y + m_h/2;
markpointnum = (markpointnum + 1) % AM_NUMMARKPOINTS;
}
*/
void AM_findMinMaxBoundaries(void)
{
int i;
fixed_t a, b;
min_x = min_y = INT_MAX;
max_x = max_y = -INT_MAX;
for (i = 0; i < numvertexes; i++)
{
if (vertexes[i].x < min_x)
min_x = vertexes[i].x;
else if (vertexes[i].x > max_x)
max_x = vertexes[i].x;
if (vertexes[i].y < min_y)
min_y = vertexes[i].y;
else if (vertexes[i].y > max_y)
max_y = vertexes[i].y;
}
max_w = max_x - min_x;
max_h = max_y - min_y;
min_w = 2 * PLAYERRADIUS;
min_h = 2 * PLAYERRADIUS;
a = FixedDiv(f_w << FRACBITS, max_w);
b = FixedDiv(f_h << FRACBITS, max_h);
min_scale_mtof = a < b ? a : b;
max_scale_mtof = FixedDiv(f_h << FRACBITS, 2 * PLAYERRADIUS);
}
vector_t *FV_DivideEx(const vector_t *a_i, fixed_t a_c, vector_t *a_o)
{
a_o->x = FixedDiv(a_i->x, a_c);
a_o->y = FixedDiv(a_i->y, a_c);
a_o->z = FixedDiv(a_i->z, a_c);
return a_o;
}
int EV_BuildPillar(line_t *line, byte *args, boolean crush)
{
int secnum;
sector_t *sec;
pillar_t *pillar;
int newHeight;
int rtn;
rtn = 0;
secnum = -1;
while((secnum = P_FindSectorFromTag(args[0], secnum)) >= 0)
{
sec = §ors[secnum];
if(sec->specialdata)
continue; // already moving
if(sec->floorheight == sec->ceilingheight)
{ // pillar is already closed
continue;
}
rtn = 1;
if(!args[2])
{
newHeight = sec->floorheight+
((sec->ceilingheight-sec->floorheight)/2);
}
else
{
newHeight = sec->floorheight+(args[2]<<FRACBITS);
}
pillar = Z_Malloc(sizeof(*pillar), PU_LEVSPEC, 0);
sec->specialdata = pillar;
P_AddThinker(&pillar->thinker);
pillar->thinker.function = T_BuildPillar;
pillar->sector = sec;
if(!args[2])
{
pillar->ceilingSpeed = pillar->floorSpeed = args[1]*(FRACUNIT/8);
}
else if(newHeight-sec->floorheight > sec->ceilingheight-newHeight)
{
pillar->floorSpeed = args[1]*(FRACUNIT/8);
pillar->ceilingSpeed = FixedMul(sec->ceilingheight-newHeight,
FixedDiv(pillar->floorSpeed, newHeight-sec->floorheight));
}
else
{
pillar->ceilingSpeed = args[1]*(FRACUNIT/8);
pillar->floorSpeed = FixedMul(newHeight-sec->floorheight,
FixedDiv(pillar->ceilingSpeed, sec->ceilingheight-newHeight));
}
pillar->floordest = newHeight;
pillar->ceilingdest = newHeight;
pillar->direction = 1;
pillar->crush = crush*args[3];
SN_StartSequence((mobj_t *)&pillar->sector->soundorg,
SEQ_PLATFORM+pillar->sector->seqType);
}
return rtn;
}
void R_InitSkyMap ()
{
if (textureheight == NULL)
return;
if (textureheight[skytexture] <= (128 << FRACBITS))
{
skytexturemid = 100*FRACUNIT;
skystretch = (r_stretchsky && allowfreelook);
}
else
{
skytexturemid = 100*FRACUNIT;
skystretch = 0;
}
skyheight = textureheight[skytexture] << skystretch;
if (viewwidth && viewheight)
{
skyiscale = (200*FRACUNIT) / (((freelookviewheight<<detailxshift) * viewwidth) / (viewwidth<<detailxshift));
skyscale = ((((freelookviewheight<<detailxshift) * viewwidth) / (viewwidth<<detailxshift)) << FRACBITS) /(200);
skyiscale = FixedMul (skyiscale, FixedDiv (clipangle, ANG45));
skyscale = FixedMul (skyscale, FixedDiv (ANG45, clipangle));
}
// The sky map is 256*128*4 maps.
skyshift = 22+skystretch-16;
if (texturewidthmask[skytexture] >= 256*2-1)
skyshift -= skystretch;
}
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(cachedheight));
angle = (viewangle - ANG90) >> ANGLETOFINESHIFT; // left to right mapping
// scale will be unit scale at SCREENWIDTH/2 distance
basexscale = FixedDiv(finecosine[angle], centerxfrac);
baseyscale = -FixedDiv(finesine[angle], centerxfrac);
}
void R_BlastSpriteColumn(void (*drawfunc)())
{
tallpost_t* post = dcol.post;
while (!post->end())
{
// calculate unclipped screen coordinates for post
int topscreen = sprtopscreen + spryscale * post->topdelta + 1;
dcol.yl = (topscreen + FRACUNIT) >> FRACBITS;
dcol.yh = (topscreen + spryscale * post->length) >> FRACBITS;
dcol.yl = MAX(dcol.yl, mceilingclip[dcol.x] + 1);
dcol.yh = MIN(dcol.yh, mfloorclip[dcol.x] - 1);
dcol.texturefrac = dcol.texturemid - (post->topdelta << FRACBITS)
+ (dcol.yl * dcol.iscale) - FixedMul(centeryfrac - FRACUNIT, dcol.iscale);
if (dcol.texturefrac < 0)
{
int cnt = (FixedDiv(-dcol.texturefrac, dcol.iscale) + FRACUNIT - 1) >> FRACBITS;
dcol.yl += cnt;
dcol.texturefrac += cnt * dcol.iscale;
}
const fixed_t endfrac = dcol.texturefrac + (dcol.yh - dcol.yl) * dcol.iscale;
const fixed_t maxfrac = post->length << FRACBITS;
if (endfrac >= maxfrac)
{
int cnt = (FixedDiv(endfrac - maxfrac - 1, dcol.iscale) + FRACUNIT - 1) >> FRACBITS;
dcol.yh -= cnt;
}
void Scene::showSprites() {
// TODO: This is all experimental code, it needs heavy restructuring
// and cleanup
// taken from set_walker_scaling() in adv_walk.cpp. A proper implementation will need
// to store these in global variables
int minScaling = FixedDiv(_sceneResources->backScale << 16, 100 << 16);
int maxScaling = FixedDiv(_sceneResources->frontScale << 16, 100 << 16);
int scaler;
_vm->_actor->setWalkerDirection(kFacingSouthEast);
//_vm->_actor->setWalkerPalette();
// taken from set_walker_scaling() in adv_walk.cpp
if (_sceneResources->frontY == _sceneResources->backY)
scaler = 0;
else
scaler = FixedDiv(maxScaling - minScaling,
(_sceneResources->frontY << 16) - (_sceneResources->backY << 16));
// FIXME: For now, we (incorrectly) scale the walker to 50% of the scene's max scaling
_vm->_actor->setWalkerScaling(scaler / 2);
// Test code to display the protagonist
_vm->_actor->placeWalkerSpriteAt(0, 320, 200);
// Test code to display scene sprites
// TODO
}
static void InitializeFade(boolean fadeIn)
{
unsigned i;
Palette = Z_Malloc(768*sizeof(fixed_t), PU_STATIC, 0);
PaletteDelta = Z_Malloc(768*sizeof(fixed_t), PU_STATIC, 0);
RealPalette = Z_Malloc(768*sizeof(byte), PU_STATIC, 0);
if(fadeIn)
{
memset(RealPalette, 0, 768*sizeof(byte));
for(i = 0; i < 768; i++)
{
Palette[i] = 0;
PaletteDelta[i] = FixedDiv((*((byte *)W_CacheLumpName("playpal",
PU_CACHE)+i))<<FRACBITS, 70*FRACUNIT);
}
}
else
{
for(i = 0; i < 768; i++)
{
RealPalette[i] = *((byte *)W_CacheLumpName("playpal", PU_CACHE)+i);
Palette[i] = RealPalette[i]<<FRACBITS;
PaletteDelta[i] = FixedDiv(Palette[i], -70*FRACUNIT);
}
}
I_SetPalette(RealPalette);
}
// Also returns the magnitude
fixed_t FV_NormalizeEx(const vector_t *a_normal, vector_t *a_o)
{
fixed_t magnitude = FV_Magnitude(a_normal);
a_o->x = FixedDiv(a_normal->x, magnitude);
a_o->y = FixedDiv(a_normal->y, magnitude);
a_o->z = FixedDiv(a_normal->z, magnitude);
return magnitude;
}
// Vector Complex Math
vector_t *FV_Midpoint(const vector_t *a_1, const vector_t *a_2, vector_t *a_o)
{
a_o->x = FixedDiv(a_2->x - a_1->x, 2*FRACUNIT);
a_o->y = FixedDiv(a_2->y - a_1->y, 2*FRACUNIT);
a_o->z = FixedDiv(a_2->z - a_1->z, 2*FRACUNIT);
a_o->x = a_1->x + a_o->x;
a_o->y = a_1->y + a_o->y;
a_o->z = a_1->z + a_o->z;
return a_o;
}
//
// PTR_chaseTraverse
//
// go til you hit a wall
// set the chasecam target x and ys if you hit one
// originally based on the shooting traverse function in p_maputl.c
//
static bool PTR_chaseTraverse(intercept_t *in)
{
fixed_t dist, frac;
subsector_t *ss;
int x, y;
int z;
sector_t *othersector;
if(in->isaline)
{
line_t *li = in->d.line;
dist = FixedMul(trace.attackrange, in->frac);
frac = in->frac - FixedDiv(12*FRACUNIT, trace.attackrange);
// hit line
// position a bit closer
x = trace.dl.x + FixedMul(trace.dl.dx, frac);
y = trace.dl.y + FixedMul(trace.dl.dy, frac);
// ioanch 20160225: portal lines are currently not crossed
if(li->flags & ML_TWOSIDED && !(li->pflags & PS_PASSABLE))
{ // crosses a two sided line
// sf: find which side it hit
ss = R_PointInSubsector (x, y);
othersector = li->backsector;
if(ss->sector==li->backsector) // other side
othersector = li->frontsector;
// interpolate, find z at the point of intersection
z = zi(dist, trace.attackrange, targetz, playermobj->z+28*FRACUNIT);
// found which side, check for intersections
if((li->flags & ML_BLOCKING) ||
(othersector->floorheight>z) || (othersector->ceilingheight<z)
|| (othersector->ceilingheight-othersector->floorheight
< 40*FRACUNIT)); // hit
else
{
return true; // continue
}
}
targetx = x; // point the new chasecam target at the intersection
targety = y;
targetz = zi(dist, trace.attackrange, targetz, playermobj->z+28*FRACUNIT);
// don't go any farther
return false;
}
return true;
}
//
// PlaneIntersection
//
// Returns the distance from
// rOrigin to where the ray
// intersects the plane. Assumes
// you already know it intersects
// the plane.
//
fixed_t FV_PlaneIntersection(const vector_t *pOrigin, const vector_t *pNormal, const vector_t *rOrigin, const vector_t *rVector)
{
fixed_t d = -(FV_Dot(pNormal, pOrigin));
fixed_t number = FV_Dot(pNormal,rOrigin) + d;
fixed_t denom = FV_Dot(pNormal,rVector);
return -FixedDiv(number, denom);
}
void R_InitLightTables (void)
{
int i;
// killough 4/4/98: dynamic colormaps
c_zlight = malloc(sizeof(*c_zlight) * numcolormaps);
// Calculate the light levels to use
// for each level / distance combination.
for (i=0; i< LIGHTLEVELS; i++)
{
int j, startmap = ((LIGHTLEVELS-1-i)*2)*NUMCOLORMAPS/LIGHTLEVELS;
for (j=0; j<MAXLIGHTZ; j++)
{
// CPhipps - use 320 here instead of SCREENWIDTH, otherwise hires is
// brighter than normal res
int scale = FixedDiv ((320/2*FRACUNIT), (j+1)<<LIGHTZSHIFT);
int t, level = startmap - (scale >>= LIGHTSCALESHIFT)/DISTMAP;
if (level < 0)
level = 0;
else
if (level >= NUMCOLORMAPS)
level = NUMCOLORMAPS-1;
// killough 3/20/98: Initialize multiple colormaps
level *= 256;
for (t=0; t<numcolormaps; t++) // killough 4/4/98
c_zlight[t][i][j] = colormaps[t] + level;
}
}
}
void AM_LevelInit(void)
{
leveljuststarted = 0;
f_x = f_y = 0;
f_w = finit_width;
f_h = finit_height;
mapxstart = mapystart = 0;
// AM_clearMarks();
AM_findMinMaxBoundaries();
scale_mtof = FixedDiv(min_scale_mtof, (int) (0.7*FRACUNIT));
if (scale_mtof > max_scale_mtof) scale_mtof = min_scale_mtof;
scale_ftom = FixedDiv(FRACUNIT, scale_mtof);
}
//
// AM_getIslope()
//
// Calculates the slope and slope according to the x-axis of a line
// segment in map coordinates (with the upright y-axis n' all) so
// that it can be used with the brain-dead drawing stuff.
//
// Passed the line slope is desired for and an islope_t structure for return
// Returns nothing
//
void AM_getIslope
( mline_t* ml,
islope_t* is )
{
int dx, dy;
dy = ml->a.y - ml->b.y;
dx = ml->b.x - ml->a.x;
if (!dy)
is->islp = (dx<0?-MAXINT:MAXINT);
else
is->islp = FixedDiv(dx, dy);
if (!dx)
is->slp = (dy<0?-MAXINT:MAXINT);
else
is->slp = FixedDiv(dy, dx);
}
//
// AM_LevelInit()
//
// Initialize the automap at the start of a new level
// should be called at the start of every level
//
// Passed nothing, returns nothing
// Affects automap's global variables
//
void AM_LevelInit(void)
{
f_x = f_y = 0;
// killough 2/7/98: get rid of finit_ vars
// to allow runtime setting of width/height
//
// killough 11/98: ... finally add hires support :)
f_w = (SCREENWIDTH) << hires;
f_h = (SCREENHEIGHT-ST_HEIGHT) << hires;
AM_findMinMaxBoundaries();
scale_mtof = FixedDiv(min_scale_mtof, (int) (0.7*FRACUNIT));
if (scale_mtof > max_scale_mtof)
scale_mtof = min_scale_mtof;
scale_ftom = FixedDiv(FRACUNIT, scale_mtof);
}
//
// R_CopySubimage
//
// Copies a portion of source_texture and draws it into dest_texture.
// The source subimage is scaled to fit the dimensions of the destination
// texture.
//
// Note: no clipping is performed so it is possible to read past the
// end of the source texture.
//
void R_CopySubimage(Texture* dest_texture, const Texture* source_texture,
int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2)
{
const int destwidth = dx2 - dx1 + 1;
const int destheight = dy2 - dy1 + 1;
const int sourcewidth = sx2 - sx1 + 1;
const int sourceheight = sy2 - sy1 + 1;
const fixed_t xstep = FixedDiv(sourcewidth << FRACBITS, destwidth << FRACBITS) + 1;
const fixed_t ystep = FixedDiv(sourceheight << FRACBITS, destheight << FRACBITS) + 1;
int dest_offset = dx1 * dest_texture->getHeight() + dy1;
byte* dest = dest_texture->getData() + dest_offset;
byte* dest_mask = dest_texture->getMaskData() + dest_offset;
fixed_t xfrac = 0;
for (int xcount = destwidth; xcount > 0; xcount--)
{
int source_offset = (sx1 + (xfrac >> FRACBITS)) * source_texture->getHeight() + sy1;
const byte* source = source_texture->getData() + source_offset;
const byte* source_mask = source_texture->getMaskData() + source_offset;
fixed_t yfrac = 0;
for (int ycount = destheight; ycount > 0; ycount--)
{
*dest++ = source[yfrac >> FRACBITS];
*dest_mask++ = source_mask[yfrac >> FRACBITS];
yfrac += ystep;
}
dest += dest_texture->getHeight() - destheight;
dest_mask += dest_texture->getHeight() - destheight;
xfrac += xstep;
}
// copy the source texture's offset info
int xoffs = FixedDiv(source_texture->getOffsetX() << FRACBITS, xstep) >> FRACBITS;
int yoffs = FixedDiv(source_texture->getOffsetY() << FRACBITS, ystep) >> FRACBITS;
dest_texture->setOffsetX(xoffs);
dest_texture->setOffsetY(yoffs);
}
static void R_InitTextureMapping (void)
{
register int i,x;
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++)
{
int t;
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++)
{
for (i=0; viewangletox[i] > x; i++)
;
xtoviewangle[x] = (i<<ANGLETOFINESHIFT)-ANG90;
}
// Take out the fencepost cases from viewangletox.
for (i=0; i<FINEANGLES/2; i++)
if (viewangletox[i] == -1)
viewangletox[i] = 0;
else
if (viewangletox[i] == viewwidth+1)
viewangletox[i] = viewwidth;
clipangle = xtoviewangle[0];
}
function int sqrt(int number)
{
if (number == 1.0) return 1.0;
if (number <= 0) return 0;
int val = 150.0;
for (int i=0; i<15; i++)
val = (val + FixedDiv(number, val)) >> 1;
return val;
}
static fixed_t R_ScaleFromGlobalAngle(angle_t visangle)
{
int anglea = ANG90 + (visangle-viewangle);
int angleb = ANG90 + (visangle-rw_normalangle);
int den = FixedMul(rw_distance, finesine[anglea>>ANGLETOFINESHIFT]);
// proff 11/06/98: Changed for high-res
fixed_t num = FixedMul(projectiony, finesine[angleb>>ANGLETOFINESHIFT]);
return den > num>>16 ? (num = FixedDiv(num, den)) > 64*FRACUNIT ?
64*FRACUNIT : num < 256 ? 256 : num : 64*FRACUNIT;
}
//
// R_InitTextureMapping
//
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.
const fixed_t hitan = finetangent[FINEANGLES / 4 + FIELDOFVIEW / 2];
const fixed_t lotan = finetangent[FINEANGLES / 4 - FIELDOFVIEW / 2];
const int highend = viewwidth + 1;
// Calc focallength
// so FIELDOFVIEW angles covers SCREENWIDTH.
focallength = FixedDiv(centerxfrac, hitan);
for (i = 0; i < FINEANGLES / 2; i++)
{
fixed_t tangent = finetangent[i];
if (tangent > hitan)
t = -1;
else if (tangent < lotan)
t = highend;
else
{
t = (centerxfrac - FixedMul(tangent, focallength) + FRACUNIT - 1) >> FRACBITS;
t = MAX(-1, (MIN(t, highend)));
}
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++)
{
for (i = 0; viewangletox[i] > x; i++);
xtoviewangle[x] = (i << ANGLETOFINESHIFT) - ANG90;
}
// Take out the fencepost cases from viewangletox.
for (i = 0; i < FINEANGLES / 2; i++)
{
if (viewangletox[i] == -1)
viewangletox[i] = 0;
else if (viewangletox[i] == highend)
viewangletox[i]--;
}
clipangle = xtoviewangle[0];
}
void AM_restoreScaleAndLoc(void)
{
m_w = old_m_w;
m_h = old_m_h;
if (!followplayer)
{
m_x = old_m_x;
m_y = old_m_y;
} else {
m_x = plr->mo->x - m_w/2;
m_y = plr->mo->y - m_h/2;
}
m_x2 = m_x + m_w;
m_y2 = m_y + m_h;
// Change the scaling multipliers
scale_mtof = FixedDiv(f_w<<FRACBITS, m_w);
scale_ftom = FixedDiv(FRACUNIT, scale_mtof);
}
void AM_changeWindowScale(void)
{
// Change the scaling multipliers
scale_mtof = FixedMul(scale_mtof, mtof_zoommul);
scale_ftom = FixedDiv(FRACUNIT, scale_mtof);
if (scale_mtof < min_scale_mtof) AM_minOutWindowScale();
else if (scale_mtof > max_scale_mtof) AM_maxOutWindowScale();
else AM_activateNewScale();
}
static void R_DrawMaskedSpriteColumn(column_t *column, int baseclip)
{
while (column->topdelta != 0xff)
{
// calculate unclipped screen coordinates for post
int topscreen = sprtopscreen + spryscale * column->topdelta + 1;
dc_yl = MAX((topscreen + FRACUNIT) >> FRACBITS, mceilingclip[dc_x] + 1);
dc_yh = MIN((topscreen + spryscale * column->length) >> FRACBITS, mfloorclip[dc_x] - 1);
if (baseclip != -1)
dc_yh = MIN(baseclip, dc_yh);
fuzzclip = baseclip;
dc_texturefrac = dc_texturemid - (column->topdelta << FRACBITS) +
FixedMul((dc_yl - centery) << FRACBITS, dc_iscale);
if (dc_texturefrac < 0)
{
int cnt = (FixedDiv(-dc_texturefrac, dc_iscale) + FRACUNIT - 1) >> FRACBITS;
dc_yl += cnt;
dc_texturefrac += cnt * dc_iscale;
}
{
const fixed_t endfrac = dc_texturefrac + (dc_yh - dc_yl) * dc_iscale;
const fixed_t maxfrac = column->length << FRACBITS;
if (endfrac >= maxfrac)
dc_yh -= (FixedDiv(endfrac - maxfrac - 1, dc_iscale) + FRACUNIT - 1) >> FRACBITS;
}
if (dc_yl <= dc_yh && dc_yh < viewheight)
{
dc_source = (byte *)column + 3;
colfunc();
}
column = (column_t *)((byte *)column + column->length + 4);
}
void R_DrawMaskedColumn(tallpost_t *post)
{
while (!post->end())
{
if (post->length == 0)
{
post = post->next();
continue;
}
// calculate unclipped screen coordinates for post
int topscreen = sprtopscreen + spryscale * post->topdelta + 1;
dc_yl = (topscreen + FRACUNIT) >> FRACBITS;
dc_yh = (topscreen + spryscale * post->length) >> FRACBITS;
if (dc_yh >= mfloorclip[dc_x])
dc_yh = mfloorclip[dc_x] - 1;
if (dc_yl <= mceilingclip[dc_x])
dc_yl = mceilingclip[dc_x] + 1;
dc_texturefrac = dc_texturemid - (post->topdelta << FRACBITS)
+ (dc_yl*dc_iscale) - FixedMul(centeryfrac-FRACUNIT, dc_iscale);
if (dc_texturefrac < 0)
{
int cnt = (FixedDiv(-dc_texturefrac, dc_iscale) + FRACUNIT - 1) >> FRACBITS;
dc_yl += cnt;
dc_texturefrac += cnt * dc_iscale;
}
const fixed_t endfrac = dc_texturefrac + (dc_yh-dc_yl)*dc_iscale;
const fixed_t maxfrac = post->length << FRACBITS;
if (endfrac >= maxfrac)
{
int cnt = (FixedDiv(endfrac - maxfrac - 1, dc_iscale) + FRACUNIT - 1) >> FRACBITS;
dc_yh -= cnt;
}
void P_SpawnLightSequence(Sector* sector, int indexStep)
{
int count;
{
findlightsequencesectorparams_t params;
params.seqSpecial = LIGHT_SEQUENCE; // Look for Light_Sequence, first.
params.count = 1;
params.sec = sector;
do
{
// Make sure that the search doesn't back up.
P_ToXSector(params.sec)->special = LIGHT_SEQUENCE_START;
params.nextSec = NULL;
P_Iteratep(params.sec, DMU_LINE, ¶ms,
findLightSequenceSector);
params.sec = params.nextSec;
} while(params.sec);
count = params.count;
}
{
findlightsequencestartsectorparams_t params;
float base;
fixed_t index, indexDelta;
params.sec = sector;
count *= indexStep;
index = 0;
indexDelta = FixedDiv(64 * FRACUNIT, count * FRACUNIT);
base = P_SectorLight(sector);
do
{
if(P_SectorLight(params.sec))
{
base = P_SectorLight(params.sec);
}
P_SpawnPhasedLight(params.sec, base, index >> FRACBITS);
index += indexDelta;
params.nextSec = NULL;
P_Iteratep(params.sec, DMU_LINE, ¶ms,
findLightSequenceStartSector);
params.sec = params.nextSec;
} while(params.sec);
}
}
// Called at new frame, if the video mode has changed
//
void SCR_Recalc(void)
{
if (dedicated)
return;
// bytes per pixel quick access
scr_bpp = vid.bpp;
// scale 1,2,3 times in x and y the patches for the menus and overlays...
// calculated once and for all, used by routines in v_video.c
vid.dupx = vid.width / BASEVIDWIDTH;
vid.dupy = vid.height / BASEVIDHEIGHT;
vid.fdupx = (float)vid.width / BASEVIDWIDTH;
vid.fdupy = (float)vid.height / BASEVIDHEIGHT;
vid.baseratio = FixedDiv(vid.height << FRACBITS, BASEVIDHEIGHT << FRACBITS);
// patch the asm code depending on vid buffer rowbytes
#ifdef RUSEASM
if (R_ASM)
ASM_PatchRowBytes(vid.rowbytes);
// if (R_486 || R_586 || R_MMX)
// MMX_PatchRowBytes(vid.rowbytes);
#endif
// toggle off automap because some screensize-dependent values will
// be calculated next time the automap is activated.
if (automapactive)
AM_Stop();
// r_plane stuff: visplanes, openings, floorclip, ceilingclip, spanstart,
// spanstop, yslope, distscale, cachedheight, cacheddistance,
// cachedxstep, cachedystep
// -> allocated at the maximum vidsize, static.
// r_main: xtoviewangle, allocated at the maximum size.
// r_things: negonearray, screenheightarray allocated max. size.
// set the screen[x] ptrs on the new vidbuffers
V_Init();
// scr_viewsize doesn't change, neither detailLevel, but the pixels
// per screenblock is different now, since we've changed resolution.
R_SetViewSize(); //just set setsizeneeded true now ..
// vid.recalc lasts only for the next refresh...
con_recalc = true;
am_recalc = true;
}
static void P_GetChasecamTarget()
{
int aimfor;
subsector_t *ss;
int ceilingheight, floorheight;
// aimfor is the preferred height of the chasecam above
// the player
// haleyjd: 1 unit for each degree of pitch works surprisingly well
aimfor = players[displayplayer].viewheight + chasecam_height*FRACUNIT
+ FixedDiv(players[displayplayer].pitch, ANGLE_1);
trace.sin = finesine[playerangle>>ANGLETOFINESHIFT];
trace.cos = finecosine[playerangle>>ANGLETOFINESHIFT];
targetx = playermobj->x - chasecam_dist * trace.cos;
targety = playermobj->y - chasecam_dist * trace.sin;
targetz = playermobj->z + aimfor;
#ifdef R_LINKEDPORTALS
targetgroupid = playermobj->groupid;
#endif
// the intersections test mucks up the first time, but
// aiming at something seems to cure it
// ioanch 20160101: don't let P_AimLineAttack change global trace.attackrange
fixed_t oldAttackRange = trace.attackrange;
// ioanch 20160225: just change trace.attackrange, don't call P_AimLineAttack
trace.attackrange = MELEERANGE;
// check for intersections
P_PathTraverse(playermobj->x, playermobj->y, targetx, targety,
PT_ADDLINES, PTR_chaseTraverse);
trace.attackrange = oldAttackRange;
ss = R_PointInSubsector(targetx, targety);
floorheight = ss->sector->floorheight;
ceilingheight = ss->sector->ceilingheight;
// don't aim above the ceiling or below the floor
if(targetz > ceilingheight - 10*FRACUNIT)
targetz = ceilingheight - 10*FRACUNIT;
if(targetz < floorheight + 10*FRACUNIT)
targetz = floorheight + 10*FRACUNIT;
}
void R_InitLightTables(void)
{
int i;
// Calculate the light levels to use
// for each level / distance combination.
for (i = 0; i < LIGHTLEVELS; i++)
{
int j, startmap = ((LIGHTLEVELS - 1 - i) * 2) * NUMCOLORMAPS / LIGHTLEVELS;
for (j = 0; j < MAXLIGHTZ; j++)
{
int scale = FixedDiv(SCREENWIDTH / 2 * FRACUNIT, (j + 1) << LIGHTZSHIFT);
int level = startmap - (scale >> LIGHTSCALESHIFT) / DISTMAP;
if (level < 0)
level = 0;
else if (level >= NUMCOLORMAPS)
level = NUMCOLORMAPS - 1;
zlight[i][j] = colormaps + level * 256;
}
}
}
