//
// P_AproxDistance
// Gives an estimation of distance (not exact)
//
fixed_t P_AproxDistance(fixed_t dx, fixed_t dy)
{
dx = D_abs(dx);
dy = D_abs(dy);
if(dx < dy)
return dx+dy-(dx>>1);
return dx+dy-(dy>>1);
}
//
// PIT_VileCheck
//
// Detect a corpse that could be raised.
//
bool PIT_VileCheck(Mobj *thing)
{
int maxdist;
bool check;
int vileType = E_SafeThingType(MT_VILE);
if(!(thing->flags & MF_CORPSE))
return true; // not a monster
if(thing->tics != -1)
return true; // not lying still yet
if(thing->info->raisestate == NullStateNum)
return true; // monster doesn't have a raise state
maxdist = thing->info->radius + mobjinfo[vileType]->radius;
if(D_abs(thing->x-viletryx) > maxdist ||
D_abs(thing->y-viletryy) > maxdist)
return true; // not actually touching
// Check to see if the radius and height are zero. If they are // phares
// then this is a crushed monster that has been turned into a // |
// gib. One of the options may be to ignore this guy. // V
// Option 1: the original, buggy method, -> ghost (compatibility)
// Option 2: resurrect the monster, but not as a ghost
// Option 3: ignore the gib
// if (Option3) // ^
// if ((thing->height == 0) && (thing->radius == 0)) // |
// return true; // phares
corpsehit = thing;
corpsehit->momx = corpsehit->momy = 0;
if(comp[comp_vile])
{ // phares
corpsehit->height <<= 2; // V
// haleyjd 11/11/04: this is also broken by Lee's change to
// PIT_CheckThing when not in demo_compatibility.
if(demo_version >= 331)
corpsehit->flags |= MF_SOLID;
check = P_CheckPosition(corpsehit, corpsehit->x, corpsehit->y);
if(demo_version >= 331)
corpsehit->flags &= ~MF_SOLID;
corpsehit->height >>= 2;
}
else
{
static void Add_WallScroller(int64_t dx, int64_t dy, const line_t *l,
int control, int accel)
{
fixed_t x = D_abs(l->dx), y = D_abs(l->dy), d;
if(y > x)
d = x, x = y, y = d;
d = FixedDiv(x,
finesine[(tantoangle[FixedDiv(y,x)>>DBITS]+ANG90) >> ANGLETOFINESHIFT]);
x = (int)((dy * -l->dy - dx * l->dx) / d); // killough 10/98:
y = (int)((dy * l->dx - dx * l->dy) / d); // Use 64-bit arithmetic
Add_Scroller(ScrollThinker::sc_side, x, y, control, *l->sidenum, accel);
}
void do_bump_map(
//const eiScalar i_bumpValue,
//const eiScalar i_bumpDepth,
const normal& i_normalCamera,
normal& o_outNormal )
{
eiScalar LOW = -1.0f, HEIGHT=1.0f;
eiScalar offset = clamp(bumpValue(), LOW, HEIGHT) * abs(bumpDepth());
//Du_offset=d(offset)/du, Dv_offset=d(offset)/dv
eiScalar Du_offset, Dv_offset;
eiScalar DbumpValue_du, DbumpValue_dv;
eiScalar DbumpDepth_du, DbumpDepth_dv;
Du(bumpValue, DbumpValue_du);
Dv(bumpValue, DbumpValue_dv);
Du(bumpDepth, DbumpDepth_du);
Dv(bumpDepth, DbumpDepth_dv);
Du_offset = D_clamp(bumpValue(), LOW,HEIGHT) * DbumpValue_du * abs(bumpDepth())
+ clamp(bumpValue(), LOW,HEIGHT) * D_abs(bumpDepth()) * DbumpDepth_du;
Dv_offset = D_clamp(bumpValue(), LOW,HEIGHT) * DbumpValue_dv * abs(bumpDepth())
+ clamp(bumpValue(), LOW,HEIGHT) * D_abs(bumpDepth()) * DbumpDepth_dv;
/*
These scale factors are a bit experimental. The constant is to roughly
match maya's bump mapping. The part about dPdu/dPdv ensures that the
bump's scale does not depend on the underlying parametrization of the
patch (the use of Du and Dv below introduce that) and that it happens
in object space. Note that maya's handling of object space appears to
be slightly broken since an enlarged sphere will have the same bump as
a sphere with its control points moved outwards by a scale, somehow.
*/
matrix toLocal = to_object();
eiScalar uscale = 1.0f / len(&(dPdu() * toLocal)) * 6.0f;
eiScalar vscale = 1.0f / len(&(dPdv() * toLocal)) * 6.0f;
vector gu = vector(1.0f, 0.0f, Du_offset * uscale);
vector gv = vector(0.0f, 1.0f, Dv_offset * vscale);
normal n = normal(gu ^ gv);
vector basisz = normalize(i_normalCamera);
vector basisx = normalize((basisz ^ dPdu()) ^ basisz);
vector basisy = normalize((basisz ^ dPdv()) ^ basisz);
o_outNormal = normal(
n.x * basisx + n.y * basisy + n.z * basisz);
o_outNormal = normalize(o_outNormal);
}
angle_t gld_FrustumAngle(void)
{
double floatangle;
angle_t a1;
float tilt = (float)fabs(((double)(int)viewpitch) / ANG1);
if (tilt > 90.0f)
{
tilt = 90.0f;
}
// If the pitch is larger than this you can look all around at a FOV of 90
if (D_abs(viewpitch) > 46 * ANG1)
return 0xffffffff;
// ok, this is a gross hack that barely works...
// but at least it doesn't overestimate too much...
floatangle = 2.0f + (45.0f + (tilt / 1.9f)) * (float)render_fov * ratio_scale / render_multiplier / 90.0f;
a1 = ANG1 * (int)floatangle;
if (a1 >= ANG180)
return 0xffffffff;
return a1;
}
void R_ExecuteSetViewSize (void)
{
int i;
setsizeneeded = false;
if (setblocks == 11)
{
scaledviewwidth = SCREENWIDTH;
viewheight = SCREENHEIGHT;
}
// proff 09/24/98: Added for high-res
else if (setblocks == 10)
{
scaledviewwidth = SCREENWIDTH;
viewheight = SCREENHEIGHT-ST_SCALED_HEIGHT;
}
else
{
// proff 08/17/98: Changed for high-res
scaledviewwidth = setblocks*SCREENWIDTH/10;
viewheight = (setblocks*(SCREENHEIGHT-ST_SCALED_HEIGHT)/10) & ~7;
}
viewwidth = scaledviewwidth;
centery = viewheight/2;
centerx = viewwidth/2;
centerxfrac = centerx<<FRACBITS;
centeryfrac = centery<<FRACBITS;
projection = centerxfrac;
// proff 11/06/98: Added for high-res
projectiony = ((SCREENHEIGHT * centerx * 320) / 200) / SCREENWIDTH * FRACUNIT;
R_InitBuffer (scaledviewwidth, viewheight);
R_InitTextureMapping();
// psprite scales
// proff 08/17/98: Changed for high-res
pspritescale = FRACUNIT*viewwidth/320;
pspriteiscale = FRACUNIT*320/viewwidth;
// proff 11/06/98: Added for high-res
pspriteyscale = (((SCREENHEIGHT*viewwidth)/SCREENWIDTH) << FRACBITS) / 200;
// thing clipping
for (i=0 ; i<viewwidth ; i++)
screenheightarray[i] = viewheight;
// planes
for (i=0 ; i<viewheight ; i++)
{ // killough 5/2/98: reformatted
fixed_t dy = D_abs(((i-viewheight/2)<<FRACBITS)+FRACUNIT/2);
// proff 08/17/98: Changed for high-res
yslope[i] = FixedDiv(projectiony, dy);
}
for (i=0 ; i<viewwidth ; i++)
{
fixed_t cosadj = D_abs(finecosine[xtoviewangle[i]>>ANGLETOFINESHIFT]);
distscale[i] = FixedDiv(FRACUNIT,cosadj);
}
}
dsvars->ystep = cachedystep[y];
}
length = FixedMul (distance,distscale[x1]);
angle = (viewangle + xtoviewangle[x1])>>ANGLETOFINESHIFT;
// killough 2/28/98: Add offsets
dsvars->xfrac = viewx + FixedMul(finecosine[angle], length) + xoffs;
dsvars->yfrac = -viewy - FixedMul(finesine[angle], length) + yoffs;
}
else
{
float slope, realy;
distance = FixedMul (planeheight, yslope[y]);
slope = (float)(planeheight / 65535.0f / D_abs(centery - y));
realy = (float)distance / 65536.0f;
dsvars->xstep = (fixed_t)(viewsin * slope * viewfocratio);
dsvars->ystep = (fixed_t)(viewcos * slope * viewfocratio);
dsvars->xfrac = viewx + xoffs + (int)(viewcos * realy) + (x1 - centerx) * dsvars->xstep;
dsvars->yfrac = -viewy + yoffs - (int)(viewsin * realy) + (x1 - centerx) * dsvars->ystep;
}
if (drawvars.filterfloor == RDRAW_FILTER_LINEAR) {
dsvars->xfrac -= (FRACUNIT>>1);
dsvars->yfrac -= (FRACUNIT>>1);
}
if (!(dsvars->colormap = fixedcolormap))
