zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-24 13:11:33 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Replaced the vector math routines with the ones I developed for the FP code.

Browse source 
SVN r454 (trunk)
This commit is contained in:
Randy Heit 2007-01-19 02:00:39 +00:00
parent f0f976c4f5
commit 47c401f4ec
20 changed files with 2279 additions and 1395 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
docs/rh-log.txt
View file

@ -1,3 +1,6 @@
January 18, 2007
- Replaced the vector math routines with the ones I developed for the FP code.
January 15, 2007
- Added a summonfoe CCMD, which is analagous to summonfriend but forces the
summoned creature to be hostile instead.

4
src/b_func.cpp
View file

@ -482,13 +482,13 @@ fixed_t DCajunMaster::FakeFire (AActor *source, AActor *dest, ticcmd_t *cmd)
th->target = source; // where it came from
vec3_t velocity;
float speed = (float)th->Speed;
FVector3 velocity;
velocity[0] = FIXED2FLOAT(dest->x - source->x);
velocity[1] = FIXED2FLOAT(dest->y - source->y);
velocity[2] = FIXED2FLOAT(dest->z - source->z);
VectorNormalize (velocity);
velocity.MakeUnit();
th->momx = FLOAT2FIXED(velocity[0] * speed);
th->momy = FLOAT2FIXED(velocity[1] * speed);
th->momz = FLOAT2FIXED(velocity[2] * speed);

2
src/empty.cpp
View file

@ -3,7 +3,7 @@
**
**
**---------------------------------------------------------------------------
** Copyright 1998-2006 Randy Heit
** Copyright 1998-2007 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without

18
src/g_strife/a_loremaster.cpp
View file

@ -148,18 +148,18 @@ END_DEFAULTS
int ALoreShot::DoSpecialDamage (AActor *target, int damage)
{
vec3_t thrust;
FVector3 thrust;
thrust[0] = float(this->target->x - target->x);
thrust[1] = float(this->target->y - target->y);
thrust[2] = float(this->target->z - target->z);
thrust.X = float(this->target->x - target->x);
thrust.Y = float(this->target->y - target->y);
thrust.Z = float(this->target->z - target->z);
VectorNormalize (thrust);
VectorScale (thrust, float((255*50*FRACUNIT) / (target->Mass ? target->Mass : 1)), thrust);
thrust.MakeUnit();
thrust *= float((255*50*FRACUNIT) / (target->Mass ? target->Mass : 1));
target->momx += fixed_t(thrust[0]);
target->momy += fixed_t(thrust[1]);
target->momz += fixed_t(thrust[2]);
target->momx += fixed_t(thrust.X);
target->momy += fixed_t(thrust.Y);
target->momz += fixed_t(thrust.Z);
return damage;
}

8
src/nodebuild_gl.cpp
View file

@ -231,10 +231,10 @@ DWORD FNodeBuilder::AddMiniseg (int v1, int v2, DWORD partner, DWORD seg1, DWORD
newseg.linedef = -1;
newseg.loopnum = 0;
newseg.next = DWORD_MAX;
newseg.planefront = true;
newseg.hashnext = NULL;
newseg.storedseg = NULL;
newseg.frontsector = NULL;
newseg.planefront = true;
newseg.hashnext = NULL;
newseg.storedseg = DWORD_MAX;
newseg.frontsector = NULL;
newseg.backsector = NULL;
if (splitseg != DWORD_MAX)

22
src/p_buildmap.cpp
View file

@ -692,7 +692,7 @@ static void CreateStartSpot (fixed_t *pos, mapthing2_t *start)
static void CalcPlane (SlopeWork &slope, secplane_t &plane)
{
vec3_t pt[3];
FVector3 pt[3];
long j;
slope.x[0] = slope.wal->x; slope.y[0] = slope.wal->y;
@ -711,23 +711,13 @@ static void CalcPlane (SlopeWork &slope, secplane_t &plane)
-slope.dy, slope.x[2]-slope.wal->x);
slope.z[2] += Scale (slope.heinum, j, slope.i);
pt[0][0] = float(slope.dx);
pt[0][1] = float(-slope.dy);
pt[0][2] = 0.f;
pt[0] = FVector3(slope.dx, -slope.dy, 0);
pt[1] = FVector3(slope.x[2] - slope.x[0], slope.y[0] - slope.y[2], (slope.z[2] - slope.z[0]) / 16);
pt[2] = (pt[0] ^ pt[1]).Unit();
pt[1][0] = float(slope.x[2] - slope.x[0]);
pt[1][1] = float(slope.y[0] - slope.y[2]);
pt[1][2] = float(slope.z[2] - slope.z[0]) / 16.f;
CrossProduct (pt[0], pt[1], pt[2]);
VectorNormalize (pt[2]);
if ((pt[2][2] < 0 && plane.c > 0) ||
(pt[2][2] > 0 && plane.c < 0))
if ((pt[2][2] < 0 && plane.c > 0) || (pt[2][2] > 0 && plane.c < 0))
{
pt[2][0] = -pt[2][0];
pt[2][1] = -pt[2][1];
pt[2][2] = -pt[2][2];
pt[2] = -pt[2];
}
plane.a = fixed_t(pt[2][0]*65536.f);

143
src/p_effect.cpp
View file

@ -423,21 +423,20 @@ void P_DrawSplash2 (int count, fixed_t x, fixed_t y, fixed_t z, angle_t angle, i
}
}
void P_DrawRailTrail (AActor * source, vec3_t start, vec3_t end, int color1, int color2, float maxdiff, bool silent)
void P_DrawRailTrail (AActor *source, const FVector3 &start, const FVector3 &end, int color1, int color2, float maxdiff, bool silent)
{
float length;
double length, lengthsquared;
int steps, i;
float deg;
vec3_t step, dir, pos, extend;
FAngle deg;
FVector3 step, dir, pos, extend;
VectorSubtract (end, start, dir);
length = VectorLength (dir);
steps = (int)(length*0.3333f);
dir = end - start;
lengthsquared = dir | dir;
length = sqrt(lengthsquared);
steps = int(length / 3);
if (length)
if (steps)
{
length = 1 / length;
if (!silent)
{
int sound;
@ -451,27 +450,27 @@ void P_DrawRailTrail (AActor * source, vec3_t start, vec3_t end, int color1, int
// The railgun's sound is special. It gets played from the
// point on the slug's trail that is closest to the hearing player.
AActor *mo = players[consoleplayer].camera;
vec3_t point;
float r;
FVector3 point;
double r;
float dirz;
if (abs(mo->x - FLOAT2FIXED(start[0])) < 20 * FRACUNIT
&& (mo->y - FLOAT2FIXED(start[1])) < 20 * FRACUNIT)
if (abs(mo->x - FLOAT2FIXED(start.X)) < 20 * FRACUNIT
&& (mo->y - FLOAT2FIXED(start.Y)) < 20 * FRACUNIT)
{ // This player (probably) fired the railgun
S_SoundID (mo, CHAN_WEAPON, sound, 1, ATTN_NORM);
}
else
{
// Only consider sound in 2D (for now, anyway)
r = ((start[1] - FIXED2FLOAT(mo->y)) * (-dir[1]) -
(start[0] - FIXED2FLOAT(mo->x)) * (dir[0])) * length * length;
r = ((start.Y - FIXED2FLOAT(mo->y)) * (-dir.Y) -
(start.X - FIXED2FLOAT(mo->x)) * (dir.X)) * length * length;
dirz = dir[2];
dir[2] = 0;
VectorMA (start, r, dir, point);
dir[2] = dirz;
dirz = dir.Z;
dir.Z = 0;
point = start + r * dir;
dir.Z = dirz;
S_SoundID (FLOAT2FIXED(point[0]), FLOAT2FIXED(point[1]), mo->z,
S_SoundID (FLOAT2FIXED(point.X), FLOAT2FIXED(point.Y), mo->z,
CHAN_WEAPON, sound, 1, ATTN_NORM);
}
}
@ -482,20 +481,37 @@ void P_DrawRailTrail (AActor * source, vec3_t start, vec3_t end, int color1, int
return;
}
VectorScale2 (dir, length);
PerpendicularVector (extend, dir);
VectorScale2 (extend, 3);
VectorScale (dir, 3, step);
dir /= length;
//Calculate PerpendicularVector (extend, dir):
double minelem = 1;
int epos;
for (epos = 0, i = 0; i < 3; ++i)
{
if (fabs(dir[i]) < minelem)
{
epos = i;
minelem = fabs(dir[i]);
}
}
FVector3 tempvec(0,0,0);
tempvec[epos] = 1;
extend = tempvec - (dir | tempvec) * dir;
//
extend *= 3;
step = dir * 3;
// Create the outer spiral.
if (color1 != -1)
{
color1 = color1==0? -1: ColorMatcher.Pick(RPART(color1), GPART(color1), BPART(color1));
VectorCopy (start, pos);
deg = 270;
color1 = color1 == 0 ? -1 : ColorMatcher.Pick(RPART(color1), GPART(color1), BPART(color1));
pos = start;
deg = FAngle(270);
for (i = steps; i; i--)
{
particle_t *p = NewParticle ();
vec3_t tempvec;
FVector3 tempvec;
if (!p)
return;
@ -505,20 +521,18 @@ void P_DrawRailTrail (AActor * source, vec3_t start, vec3_t end, int color1, int
p->fade = FADEFROMTTL(35);
p->size = 3;
RotatePointAroundVector (tempvec, dir, extend, deg);
p->velx = FLOAT2FIXED(tempvec[0])>>4;
p->vely = FLOAT2FIXED(tempvec[1])>>4;
p->velz = FLOAT2FIXED(tempvec[2])>>4;
VectorAdd (tempvec, pos, tempvec);
deg += 14;
if (deg >= 360)
deg -= 360;
p->x = FLOAT2FIXED(tempvec[0]);
p->y = FLOAT2FIXED(tempvec[1]);
p->z = FLOAT2FIXED(tempvec[2]);
VectorAdd (pos, step, pos);
tempvec = FMatrix3x3(dir, deg) * extend;
p->velx = FLOAT2FIXED(tempvec.X)>>4;
p->vely = FLOAT2FIXED(tempvec.Y)>>4;
p->velz = FLOAT2FIXED(tempvec.Z)>>4;
tempvec += pos;
p->x = FLOAT2FIXED(tempvec.X);
p->y = FLOAT2FIXED(tempvec.Y);
p->z = FLOAT2FIXED(tempvec.Z);
pos += step;
deg += FAngle(14);
if (color1==-1)
if (color1 == -1)
{
int rand = M_Random();
@ -538,13 +552,13 @@ void P_DrawRailTrail (AActor * source, vec3_t start, vec3_t end, int color1, int
}
}
// Create the inner trail.
if (color2 != -1)
{
color2 = color2==0? -1: ColorMatcher.Pick(RPART(color2), GPART(color2), BPART(color2));
vec3_t diff;
VectorSet (diff, 0, 0, 0);
color2 = color2 == 0 ? -1 : ColorMatcher.Pick(RPART(color2), GPART(color2), BPART(color2));
FVector3 diff(0, 0, 0);
VectorCopy (start, pos);
pos = start;
for (i = steps; i; i--)
{
particle_t *p = JitterParticle (33);
@ -556,38 +570,33 @@ void P_DrawRailTrail (AActor * source, vec3_t start, vec3_t end, int color1, int
{
int rnd = M_Random ();
if (rnd & 1)
diff[0] = clamp<float> (diff[0] + ((rnd & 8) ? 1 : -1), -maxdiff, maxdiff);
diff.X = clamp<float> (diff.X + ((rnd & 8) ? 1 : -1), -maxdiff, maxdiff);
if (rnd & 2)
diff[1] = clamp<float> (diff[1] + ((rnd & 16) ? 1 : -1), -maxdiff, maxdiff);
diff.Y = clamp<float> (diff.Y + ((rnd & 16) ? 1 : -1), -maxdiff, maxdiff);
if (rnd & 4)
diff[2] = clamp<float> (diff[2] + ((rnd & 32) ? 1 : -1), -maxdiff, maxdiff);
diff.Z = clamp<float> (diff.Z + ((rnd & 32) ? 1 : -1), -maxdiff, maxdiff);
}
vec3_t postmp;
VectorCopy (pos, postmp);
VectorAdd (postmp, diff, postmp);
FVector3 postmp = pos + diff;
p->size = 2;
p->x = FLOAT2FIXED(postmp[0]);
p->y = FLOAT2FIXED(postmp[1]);
p->z = FLOAT2FIXED(postmp[2]);
p->x = FLOAT2FIXED(postmp.X);
p->y = FLOAT2FIXED(postmp.Y);
p->z = FLOAT2FIXED(postmp.Z);
if (color1 != -1)
p->accz -= FRACUNIT/4096;
VectorAdd (pos, step, pos);
pos += step;
if (color2==-1)
if (color2 == -1)
{
{
int rand = M_Random();
int rand = M_Random();
if (rand < 85)
p->color = grey4;
else if (rand < 170)
p->color = grey2;
else
p->color = grey1;
}
p->color = white;
if (rand < 85)
p->color = grey4;
else if (rand < 170)
p->color = grey2;
else
p->color = grey1;
}
else
{

3
src/p_effect.h
View file

@ -32,6 +32,7 @@
*/
#include "vectors.h"
#include "tables.h"
#define FX_ROCKET 0x00000001
#define FX_GRENADE 0x00000002
@ -58,7 +59,7 @@ void P_RunEffects (void);
void P_RunEffect (AActor *actor, int effects);
void P_DrawRailTrail (AActor * source, vec3_t start, vec3_t end, int color1, int color2, float maxdiff = 0, bool silent = false);
void P_DrawRailTrail (AActor *source, const FVector3 &start, const FVector3 &end, int color1, int color2, float maxdiff = 0, bool silent = false);
void P_DrawSplash (int count, fixed_t x, fixed_t y, fixed_t z, angle_t angle, int kind);
void P_DrawSplash2 (int count, fixed_t x, fixed_t y, fixed_t z, angle_t angle, int updown, int kind);
void P_DisconnectEffect (AActor *actor);

16
src/p_map.cpp
View file

@ -3081,7 +3081,7 @@ void P_RailAttack (AActor *source, int damage, int offset, int color1, int color
fixed_t vx, vy, vz;
angle_t angle, pitch;
fixed_t x1, y1;
vec3_t start, end;
FVector3 start, end;
FTraceResults trace;
pitch = (angle_t)(-source->pitch) >> ANGLETOFINESHIFT;
@ -3100,7 +3100,9 @@ void P_RailAttack (AActor *source, int damage, int offset, int color1, int color
y1 += offset*finesine[angle];
RailHits.Clear ();
VectorFixedSet (start, x1, y1, shootz);
start.X = FIXED2FLOAT(x1);
start.Y = FIXED2FLOAT(y1);
start.Z = FIXED2FLOAT(shootz);
Trace (x1, y1, shootz, source->Sector, vx, vy, vz,
8192*FRACUNIT, MF_SHOOTABLE, ML_BLOCKEVERYTHING, source, trace,
@ -3179,7 +3181,9 @@ void P_RailAttack (AActor *source, int damage, int offset, int color1, int color
P_TraceBleed (damage, x, y, z, RailHits[i].HitActor, angle, pitch);
}
VectorFixedSet (end, trace.X, trace.Y, trace.Z);
end.X = FIXED2FLOAT(trace.X);
end.Y = FIXED2FLOAT(trace.Y);
end.Z = FIXED2FLOAT(trace.Z);
P_DrawRailTrail (source, start, end, color1, color2, maxdiff, silent);
}
@ -3508,7 +3512,7 @@ int bombdistance;
float bombdistancefloat;
bool DamageSource;
FName bombmod;
vec3_t bombvec;
FVector3 bombvec;
bool bombdodamage;
//=============================================================================
@ -3710,7 +3714,9 @@ void P_RadiusAttack (AActor *spot, AActor *source, int damage, int distance, FNa
bombdamagefloat = (float)damage;
bombmod = damageType;
bombdodamage = dodamage;
VectorPosition (spot, bombvec);
bombvec.X = FIXED2FLOAT(spot->x);
bombvec.Y = FIXED2FLOAT(spot->y);
bombvec.Z = FIXED2FLOAT(spot->z);
radbt.Clear();

17
src/p_mobj.cpp
View file

@ -4402,7 +4402,6 @@ AActor *P_SpawnMissileXYZ (fixed_t x, fixed_t y, fixed_t z,
P_PlaySpawnSound(th, source);
th->target = source; // record missile's originator
vec3_t velocity;
float speed = (float)(th->Speed);
// [RH]
@ -4411,23 +4410,21 @@ AActor *P_SpawnMissileXYZ (fixed_t x, fixed_t y, fixed_t z,
// missile? I'll leave it like this for now.
// Answer. No, because this way, you can set up sets of parallel missiles.
velocity[0] = (float)(dest->x - source->x);
velocity[1] = (float)(dest->y - source->y);
velocity[2] = (float)(dest->z - source->z);
FVector3 velocity(dest->x - source->x, dest->y - source->y, dest->z - source->z);
// Floor and ceiling huggers should never have a vertical component to their velocity
if (defflags3 & (MF3_FLOORHUGGER|MF3_CEILINGHUGGER))
{
velocity[2] = 0.f;
velocity.Z = 0;
}
// [RH] Adjust the trajectory if the missile will go over the player's head.
else if (z - source->z >= dest->height)
{
velocity[2] += (float)(dest->height - z + source->z);
velocity.Z += dest->height - z + source->z;
}
VectorNormalize (velocity);
th->momx = (fixed_t)(velocity[0] * speed);
th->momy = (fixed_t)(velocity[1] * speed);
th->momz = (fixed_t)(velocity[2] * speed);
velocity.Resize (speed);
th->momx = (fixed_t)(velocity.X);
th->momy = (fixed_t)(velocity.Y);
th->momz = (fixed_t)(velocity.Z);
// invisible target: rotate velocity vector in 2D
if (dest->flags & MF_SHADOW)

61
src/p_setup.cpp
View file

@ -1299,7 +1299,7 @@ static void P_SlopeLineToPoint (int lineid, fixed_t x, fixed_t y, fixed_t z, boo
plane = &sec->floorplane;
}
vec3_t p, v1, v2, cross;
FVector3 p, v1, v2, cross;
p[0] = FIXED2FLOAT (line->v1->x);
p[1] = FIXED2FLOAT (line->v1->y);
@ -1311,19 +1311,18 @@ static void P_SlopeLineToPoint (int lineid, fixed_t x, fixed_t y, fixed_t z, boo
v2[1] = FIXED2FLOAT (y - line->v1->y);
v2[2] = FIXED2FLOAT (z) - p[2];
CrossProduct (v1, v2, cross);
if (VectorLength (cross) == 0)
cross = v1 ^ v2;
double len = cross.Length();
if (len == 0)
{
Printf ("Slope thing at (%d,%d) lies directly on its target line.\n", int(x>>16), int(y>>16));
return;
}
VectorNormalize (cross);
cross /= len;
// Fix backward normals
if ((cross[2] < 0 && !slopeCeil) || (cross[2] > 0 && slopeCeil))
if ((cross.Z < 0 && !slopeCeil) || (cross.Z > 0 && slopeCeil))
{
cross[0] = -cross[0];
cross[1] = -cross[1];
cross[2] = -cross[2];
cross = -cross;
}
plane->a = FLOAT2FIXED (cross[0]);
@ -1401,12 +1400,12 @@ void P_SetSlope (secplane_t *plane, bool setCeil, int xyangi, int zangi,
xyang = (angle_t)Scale (xyangi, ANGLE_90, 90 << ANGLETOFINESHIFT);
vec3_t norm;
FVector3 norm;
norm[0] = float(finecosine[zang]) * float(finecosine[xyang]);
norm[1] = float(finecosine[zang]) * float(finesine[xyang]);
norm[2] = float(finesine[zang]) * 65536.f;
VectorNormalize (norm);
norm.MakeUnit();
plane->a = (int)(norm[0] * 65536.f);
plane->b = (int)(norm[1] * 65536.f);
plane->c = (int)(norm[2] * 65536.f);
@ -1432,7 +1431,7 @@ void P_VavoomSlope(sector_t * sec, int id, fixed_t x, fixed_t y, fixed_t z, int
if (l->args[0]==id)
{
vec3_t v1, v2, cross;
FVector3 v1, v2, cross;
secplane_t *srcplane = (which == 0) ? &sec->floorplane : &sec->ceilingplane;
fixed_t srcheight = (which == 0) ? sec->floortexz : sec->ceilingtexz;
@ -1444,15 +1443,19 @@ void P_VavoomSlope(sector_t * sec, int id, fixed_t x, fixed_t y, fixed_t z, int
v2[1] = FIXED2FLOAT (y - l->v1->y);
v2[2] = FIXED2FLOAT (z - srcheight);
CrossProduct (v1, v2, cross);
VectorNormalize (cross);
cross = v1 ^ v2;
double len = cross.Length();
if (len == 0)
{
Printf ("Slope thing at (%d,%d) lies directly on its target line.\n", int(x>>16), int(y>>16));
return;
}
cross /= len;
// Fix backward normals
if ((cross[2] < 0 && which == 0) || (cross[2] > 0 && which == 1))
if ((cross.Z < 0 && which == 0) || (cross.Z > 0 && which == 1))
{
cross[0] = -cross[0];
cross[1] = -cross[1];
cross[2] = -cross[2];
cross = -cross;
}
@ -2322,14 +2325,7 @@ static void P_AlignPlane (sector_t *sec, line_t *line, int which)
refsec = line->frontsector == sec ? line->backsector : line->frontsector;
vec3_t p, v1, v2, cross;
p[0] = FIXED2FLOAT (line->v1->x);
p[1] = FIXED2FLOAT (line->v1->y);
v1[0] = FIXED2FLOAT (line->dx);
v1[1] = FIXED2FLOAT (line->dy);
v2[0] = FIXED2FLOAT (refvert->x - line->v1->x);
v2[1] = FIXED2FLOAT (refvert->y - line->v1->y);
FVector3 p, v1, v2, cross;
const secplane_t *refplane;
secplane_t *srcplane;
@ -2340,19 +2336,22 @@ static void P_AlignPlane (sector_t *sec, line_t *line, int which)
srcheight = (which == 0) ? sec->floortexz : sec->ceilingtexz;
destheight = (which == 0) ? refsec->floortexz : refsec->ceilingtexz;
p[0] = FIXED2FLOAT (line->v1->x);
p[1] = FIXED2FLOAT (line->v1->y);
p[2] = FIXED2FLOAT (destheight);
v1[0] = FIXED2FLOAT (line->dx);
v1[1] = FIXED2FLOAT (line->dy);
v1[2] = 0;
v2[0] = FIXED2FLOAT (refvert->x - line->v1->x);
v2[1] = FIXED2FLOAT (refvert->y - line->v1->y);
v2[2] = FIXED2FLOAT (srcheight - destheight);
CrossProduct (v1, v2, cross);
VectorNormalize (cross);
cross = (v1 ^ v2).Unit();
// Fix backward normals
if ((cross[2] < 0 && which == 0) || (cross[2] > 0 && which == 1))
if ((cross.Z < 0 && which == 0) || (cross.Z > 0 && which == 1))
{
cross[0] = -cross[0];
cross[1] = -cross[1];
cross[2] = -cross[2];
cross = -cross;
}
srcplane->a = FLOAT2FIXED (cross[0]);

53
src/p_things.cpp
View file

@ -259,12 +259,7 @@ bool P_Thing_Projectile (int tid, AActor *source, int type, const char * type_na
if (targ != NULL)
{
fixed_t spot[3] = { targ->x, targ->y, targ->z+targ->height/2 };
vec3_t aim =
{
float(spot[0] - mobj->x),
float(spot[1] - mobj->y),
float(spot[2] - mobj->z)
};
FVector3 aim(float(spot[0] - mobj->x), float(spot[1] - mobj->y), float(spot[2] - mobj->z));
if (leadTarget && speed > 0 && (targ->momx | targ->momy | targ->momz))
{
@ -275,55 +270,35 @@ bool P_Thing_Projectile (int tid, AActor *source, int type, const char * type_na
// with the math. I don't think I would have thought of using
// trig alone had I been left to solve it by myself.
double tvel[3] = { double(targ->momx), double(targ->momy), double(targ->momz) };
FVector3 tvel(targ->momx, targ->momy, targ->momz);
if (!(targ->flags & MF_NOGRAVITY) && targ->waterlevel < 3)
{ // If the target is subject to gravity and not underwater,
// assume that it isn't moving vertically. Thanks to gravity,
// even if we did consider the vertical component of the target's
// velocity, we would still miss more often than not.
tvel[2] = 0.0;
tvel.Z = 0.0;
if ((targ->momx | targ->momy) == 0)
{
goto nolead;
}
}
double dist = sqrt (aim[0]*aim[0] + aim[1]*aim[1] + aim[2]*aim[2]);
double targspeed = sqrt (tvel[0]*tvel[0] + tvel[1]*tvel[1] + tvel[2]*tvel[2]);
double ydotx = -aim[0]*tvel[0] - aim[1]*tvel[1] - aim[2]*tvel[2];
double dist = aim | aim;
double targspeed = tvel.Length();
double ydotx = -aim | tvel;
double a = acos (clamp (ydotx / targspeed / dist, -1.0, 1.0));
double multiplier = double(pr_leadtarget.Random2())*0.1/255+1.1;
double sinb = clamp (targspeed*multiplier * sin(a) / fspeed, -1.0, 1.0);
double cosb = cos (asin (sinb));
// Use the cross product of two of the triangle's sides to get a
// rotation vector.
double rv[3] =
{
tvel[1]*aim[2] - tvel[2]*aim[1],
tvel[2]*aim[0] - tvel[0]*aim[2],
tvel[0]*aim[1] - tvel[1]*aim[0]
};
FVector3 rv(tvel ^ aim);
// The vector must be normalized.
double irvlen = 1.0 / sqrt(rv[0]*rv[0] + rv[1]*rv[1] + rv[2]*rv[2]);
rv[0] *= irvlen;
rv[1] *= irvlen;
rv[2] *= irvlen;
rv.MakeUnit();
// Now combine the rotation vector with angle b to get a rotation matrix.
double t = 1.0 - cosb;
double rm[3][3] =
{
{t*rv[0]*rv[0]+cosb, t*rv[0]*rv[1]-sinb*rv[2], t*rv[0]*rv[2]+sinb*rv[1]},
{t*rv[0]*rv[1]+sinb*rv[2], t*rv[1]*rv[1]+cosb, t*rv[1]*rv[2]-sinb*rv[0]},
{t*rv[0]*rv[2]-sinb*rv[1], t*rv[1]*rv[2]+sinb*rv[0], t*rv[2]*rv[2]+cosb}
};
FMatrix3x3 rm(rv, cos(asin(sinb)), sinb);
// And multiply the original aim vector with the matrix to get a
// new aim vector that leads the target.
double aimvec[3] =
{
rm[0][0]*aim[0] + rm[1][0]*aim[1] + rm[2][0]*aim[2],
rm[0][1]*aim[0] + rm[1][1]*aim[1] + rm[2][1]*aim[2],
rm[0][2]*aim[0] + rm[1][2]*aim[1] + rm[2][2]*aim[2]
};
FVector3 aimvec = rm * aim;
// And make the projectile follow that vector at the desired speed.
double aimscale = fspeed / dist;
mobj->momx = fixed_t (aimvec[0] * aimscale);
@ -335,10 +310,10 @@ bool P_Thing_Projectile (int tid, AActor *source, int type, const char * type_na
{
nolead:
mobj->angle = R_PointToAngle2 (mobj->x, mobj->y, targ->x, targ->y);
VectorNormalize (aim);
mobj->momx = fixed_t(aim[0] * fspeed);
mobj->momy = fixed_t(aim[1] * fspeed);
mobj->momz = fixed_t(aim[2] * fspeed);
aim.Resize (fspeed);
mobj->momx = fixed_t(aim[0]);
mobj->momy = fixed_t(aim[1]);
mobj->momz = fixed_t(aim[2]);
}
if (mobj->flags2 & MF2_SEEKERMISSILE)
{

26
src/r_plane.cpp
View file

@ -121,7 +121,7 @@ short spanend[MAXHEIGHT];
BYTE *tiltlighting[MAXWIDTH];
int planeshade;
vec3_t plane_sz, plane_su, plane_sv;
FVector3 plane_sz, plane_su, plane_sv;
float planelightfloat;
bool plane_shade;
fixed_t pviewx, pviewy;
@ -1446,7 +1446,7 @@ void R_DrawTiltedPlane (visplane_t *pl, fixed_t alpha, bool masked)
float xscale, yscale;
fixed_t ixscale, iyscale;
angle_t ang;
vec3_t p, m, n;
FVector3 p, m, n;
fixed_t zeroheight;
if (alpha <= 0)
@ -1503,21 +1503,21 @@ void R_DrawTiltedPlane (visplane_t *pl, fixed_t alpha, bool masked)
viewx + MulScale16 (ixscale, finesine[ang]),
viewy + MulScale16 (ixscale, finecosine[ang])) - zeroheight);
CrossProduct (p, m, plane_su);
CrossProduct (p, n, plane_sv);
CrossProduct (m, n, plane_sz);
plane_su = p ^ m;
plane_sv = p ^ n;
plane_sz = m ^ n;
plane_su[2] *= FocalLengthXfloat;
plane_sv[2] *= FocalLengthXfloat;
plane_sz[2] *= FocalLengthXfloat;
plane_su.Z *= FocalLengthXfloat;
plane_sv.Z *= FocalLengthXfloat;
plane_sz.Z *= FocalLengthXfloat;
plane_su[1] *= iyaspectmulfloat;
plane_sv[1] *= iyaspectmulfloat;
plane_sz[1] *= iyaspectmulfloat;
plane_su.Y *= iyaspectmulfloat;
plane_sv.Y *= iyaspectmulfloat;
plane_sz.Y *= iyaspectmulfloat;
// Premultiply the texture vectors with the scale factors
VectorScale2 (plane_su, 4294967296.f);
VectorScale2 (plane_sv, 4294967296.f);
plane_su *= 4294967296.f;
plane_sv *= 4294967296.f;
if (MirrorFlags & RF_XFLIP)
{

498
src/sdl/i_main.cpp
View file

@ -1,250 +1,250 @@
/*
** i_main.cpp
** System-specific startup code. Eventually calls D_DoomMain.
**
**---------------------------------------------------------------------------
** Copyright 1998-2007 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
*/
// HEADER FILES ------------------------------------------------------------
#include <SDL.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <new>
#include <sys/param.h>
#include <gtk/gtk.h>
#include "doomerrors.h"
#include "m_argv.h"
#include "d_main.h"
#include "i_system.h"
#include "i_video.h"
#include "c_console.h"
#include "errors.h"
#include "version.h"
#include "w_wad.h"
// MACROS ------------------------------------------------------------------
// The maximum number of functions that can be registered with atterm.
#define MAX_TERMS 32
// TYPES -------------------------------------------------------------------
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
extern "C" int cc_install_handlers(int, int*, const char*, int(*)(char*, char*));
// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
// EXTERNAL DATA DECLARATIONS ----------------------------------------------
// PUBLIC DATA DEFINITIONS -------------------------------------------------
bool GtkAvailable;
// The command line arguments.
DArgs Args;
// PRIVATE DATA DEFINITIONS ------------------------------------------------
static void (*TermFuncs[MAX_TERMS]) ();
static const char *TermNames[MAX_TERMS];
static int NumTerms;
// CODE --------------------------------------------------------------------
void addterm (void (*func) (), const char *name)
{
// Make sure this function wasn't already registered.
for (int i = 0; i < NumTerms; ++i)
{
if (TermFuncs[i] == func)
{
return;
}
}
if (NumTerms == MAX_TERMS)
{
func ();
I_FatalError (
"Too many exit functions registered.\n"
"Increase MAX_TERMS in i_main.cpp");
}
TermNames[NumTerms] = name;
TermFuncs[NumTerms++] = func;
}
void popterm ()
{
if (NumTerms)
NumTerms--;
}
void STACK_ARGS call_terms ()
{
while (NumTerms > 0)
{
// printf ("term %d - %s\n", NumTerms, TermNames[NumTerms-1]);
TermFuncs[--NumTerms] ();
}
}
static void STACK_ARGS NewFailure ()
{
I_FatalError ("Failed to allocate memory from system heap");
}
static int DoomSpecificInfo (char *buffer, char *end)
{
const char *arg;
int size = end-buffer;
int i, p;
SDL_Quit();
p = 0;
p += snprintf (buffer+p, size-p, "ZDoom version " DOTVERSIONSTR " (" __DATE__ ")\n");
p += snprintf (buffer+p, size-p, "\nCommand line:");
for (i = 0; i < Args.NumArgs(); ++i)
{
p += snprintf (buffer+p, size-p, " %s", Args.GetArg(i));
}
p += snprintf (buffer+p, size-p, "\n");
for (i = 0; (arg = Wads.GetWadName (i)) != NULL; ++i)
{
p += snprintf (buffer+p, size-p, "\nWad %d: %s", i, arg);
}
if (gamestate != GS_LEVEL && gamestate != GS_TITLELEVEL)
{
p += snprintf (buffer+p, size-p, "\n\nNot in a level.");
}
else
{
char name[9];
strncpy (name, level.mapname, 8);
name[8] = 0;
p += snprintf (buffer+p, size-p, "\n\nCurrent map: %s", name);
if (!viewactive)
{
buffer += snprintf (buffer+p, size-p, "\n\nView not active.");
}
else
{
p += snprintf (buffer+p, size-p, "\n\nviewx = %d", (int)viewx);
p += snprintf (buffer+p, size-p, "\nviewy = %d", (int)viewy);
p += snprintf (buffer+p, size-p, "\nviewz = %d", (int)viewz);
p += snprintf (buffer+p, size-p, "\nviewangle = %x", (unsigned int)viewangle);
}
}
buffer[p++] = '\n';
buffer[p++] = '\0';
return p;
}
int main (int argc, char **argv)
{
printf("ZDoom v%s - SVN revision %s - SDL version\nCompiled on %s\n\n",
DOTVERSIONSTR_NOREV,SVN_REVISION_STRING,__DATE__);
{
int s[4] = { SIGSEGV, SIGILL, SIGFPE, SIGBUS };
cc_install_handlers(4, s, "zdoom-crash.log", DoomSpecificInfo);
}
seteuid (getuid ());
std::set_new_handler (NewFailure);
GtkAvailable = gtk_init_check (&argc, &argv);
if (SDL_Init (SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_NOPARACHUTE) == -1)
{
fprintf (stderr, "Could not initialize SDL:\n%s\n", SDL_GetError());
return -1;
}
atterm (SDL_Quit);
SDL_WM_SetCaption (GAMESIG " " DOTVERSIONSTR " (" __DATE__ ")", NULL);
try
{
Args.SetArgs (argc, argv);
/*
killough 1/98:
This fixes some problems with exit handling
during abnormal situations.
The old code called I_Quit() to end program,
while now I_Quit() is installed as an exit
handler and exit() is called to exit, either
normally or abnormally. Seg faults are caught
and the error handler is used, to prevent
being left in graphics mode or having very
loud SFX noise because the sound card is
left in an unstable state.
*/
atexit (call_terms);
atterm (I_Quit);
if (realpath (argv[0], progdir) == NULL)
strcpy (progdir, argv[0]);
char *slash = strrchr (progdir, '/');
if (slash)
*(slash + 1) = '\0';
else
progdir[0] = '.', progdir[1] = '/', progdir[2] = '\0';
C_InitConsole (80*8, 25*8, false);
D_DoomMain ();
}
catch (class CDoomError &error)
{
if (error.GetMessage ())
fprintf (stderr, "%s\n", error.GetMessage ());
exit (-1);
}
catch (...)
{
call_terms ();
throw;
}
return 0;
/*
** i_main.cpp
** System-specific startup code. Eventually calls D_DoomMain.
**
**---------------------------------------------------------------------------
** Copyright 1998-2007 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
*/
// HEADER FILES ------------------------------------------------------------
#include <SDL.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <new>
#include <sys/param.h>
#include <gtk/gtk.h>
#include "doomerrors.h"
#include "m_argv.h"
#include "d_main.h"
#include "i_system.h"
#include "i_video.h"
#include "c_console.h"
#include "errors.h"
#include "version.h"
#include "w_wad.h"
// MACROS ------------------------------------------------------------------
// The maximum number of functions that can be registered with atterm.
#define MAX_TERMS 32
// TYPES -------------------------------------------------------------------
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
extern "C" int cc_install_handlers(int, int*, const char*, int(*)(char*, char*));
// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
// EXTERNAL DATA DECLARATIONS ----------------------------------------------
// PUBLIC DATA DEFINITIONS -------------------------------------------------
bool GtkAvailable;
// The command line arguments.
DArgs Args;
// PRIVATE DATA DEFINITIONS ------------------------------------------------
static void (*TermFuncs[MAX_TERMS]) ();
static const char *TermNames[MAX_TERMS];
static int NumTerms;
// CODE --------------------------------------------------------------------
void addterm (void (*func) (), const char *name)
{
// Make sure this function wasn't already registered.
for (int i = 0; i < NumTerms; ++i)
{
if (TermFuncs[i] == func)
{
return;
}
}
if (NumTerms == MAX_TERMS)
{
func ();
I_FatalError (
"Too many exit functions registered.\n"
"Increase MAX_TERMS in i_main.cpp");
}
TermNames[NumTerms] = name;
TermFuncs[NumTerms++] = func;
}
void popterm ()
{
if (NumTerms)
NumTerms--;
}
void STACK_ARGS call_terms ()
{
while (NumTerms > 0)
{
// printf ("term %d - %s\n", NumTerms, TermNames[NumTerms-1]);
TermFuncs[--NumTerms] ();
}
}
static void STACK_ARGS NewFailure ()
{
I_FatalError ("Failed to allocate memory from system heap");
}
static int DoomSpecificInfo (char *buffer, char *end)
{
const char *arg;
int size = end-buffer;
int i, p;
SDL_Quit();
p = 0;
p += snprintf (buffer+p, size-p, "ZDoom version " DOTVERSIONSTR " (" __DATE__ ")\n");
p += snprintf (buffer+p, size-p, "\nCommand line:");
for (i = 0; i < Args.NumArgs(); ++i)
{
p += snprintf (buffer+p, size-p, " %s", Args.GetArg(i));
}
p += snprintf (buffer+p, size-p, "\n");
for (i = 0; (arg = Wads.GetWadName (i)) != NULL; ++i)
{
p += snprintf (buffer+p, size-p, "\nWad %d: %s", i, arg);
}
if (gamestate != GS_LEVEL && gamestate != GS_TITLELEVEL)
{
p += snprintf (buffer+p, size-p, "\n\nNot in a level.");
}
else
{
char name[9];
strncpy (name, level.mapname, 8);
name[8] = 0;
p += snprintf (buffer+p, size-p, "\n\nCurrent map: %s", name);
if (!viewactive)
{
buffer += snprintf (buffer+p, size-p, "\n\nView not active.");
}
else
{
p += snprintf (buffer+p, size-p, "\n\nviewx = %d", (int)viewx);
p += snprintf (buffer+p, size-p, "\nviewy = %d", (int)viewy);
p += snprintf (buffer+p, size-p, "\nviewz = %d", (int)viewz);
p += snprintf (buffer+p, size-p, "\nviewangle = %x", (unsigned int)viewangle);
}
}
buffer[p++] = '\n';
buffer[p++] = '\0';
return p;
}
int main (int argc, char **argv)
{
printf("ZDoom v%s - SVN revision %s - SDL version\nCompiled on %s\n\n",
DOTVERSIONSTR_NOREV,SVN_REVISION_STRING,__DATE__);
{
int s[4] = { SIGSEGV, SIGILL, SIGFPE, SIGBUS };
cc_install_handlers(4, s, "zdoom-crash.log", DoomSpecificInfo);
}
seteuid (getuid ());
std::set_new_handler (NewFailure);
GtkAvailable = gtk_init_check (&argc, &argv);
if (SDL_Init (SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_NOPARACHUTE) == -1)
{
fprintf (stderr, "Could not initialize SDL:\n%s\n", SDL_GetError());
return -1;
}
atterm (SDL_Quit);
SDL_WM_SetCaption (GAMESIG " " DOTVERSIONSTR " (" __DATE__ ")", NULL);
try
{
Args.SetArgs (argc, argv);
/*
killough 1/98:
This fixes some problems with exit handling
during abnormal situations.
The old code called I_Quit() to end program,
while now I_Quit() is installed as an exit
handler and exit() is called to exit, either
normally or abnormally. Seg faults are caught
and the error handler is used, to prevent
being left in graphics mode or having very
loud SFX noise because the sound card is
left in an unstable state.
*/
atexit (call_terms);
atterm (I_Quit);
if (realpath (argv[0], progdir) == NULL)
strcpy (progdir, argv[0]);
char *slash = strrchr (progdir, '/');
if (slash)
*(slash + 1) = '\0';
else
progdir[0] = '.', progdir[1] = '/', progdir[2] = '\0';
C_InitConsole (80*8, 25*8, false);
D_DoomMain ();
}
catch (class CDoomError &error)
{
if (error.GetMessage ())
fprintf (stderr, "%s\n", error.GetMessage ());
exit (-1);
}
catch (...)
{
call_terms ();
throw;
}
return 0;
}

6
src/tarray.h
View file

@ -122,9 +122,9 @@ public:
item = Array[--Count];
Array[Count].~T();
return true;
}
return false;
}
}
return false;
}
void Delete (unsigned int index)
{
if (index < Count)

8
src/thingdef_codeptr.cpp
View file

@ -736,9 +736,9 @@ void A_CustomMissile(AActor * self)
// Use the actual momentum instead of the missile's Speed property
// so that this can handle missiles with a high vertical velocity
// component properly.
vec3_t velocity = { missile->momx, missile->momy, 0 };
FVector3 velocity (missile->momx, missile->momy, 0);
fixed_t missilespeed=(fixed_t)VectorLength(velocity);
fixed_t missilespeed = (fixed_t)velocity.Length();
missile->angle += Angle;
ang = missile->angle >> ANGLETOFINESHIFT;
@ -1044,8 +1044,8 @@ void A_FireCustomMissile (AActor * self)
{
// This original implementation is to aim straight ahead and then offset
// the angle from the resulting direction.
vec3_t velocity = { misl->momx, misl->momy, 0 };
fixed_t missilespeed=(fixed_t)VectorLength(velocity);
FVector3 velocity(misl->momx, misl->momy, 0);
fixed_t missilespeed = (fixed_t)velocity.Length();
misl->angle += Angle;
angle_t an = misl->angle >> ANGLETOFINESHIFT;
misl->momx = FixedMul (missilespeed, finecosine[an]);

253
src/vectors.cpp
View file

@ -1,253 +0,0 @@
#include "vectors.h"
#include "actor.h"
#include "tables.h"
#define DEG2RAD( a ) ( a * M_PI ) / 180.0F
// [RH] Convert a thing's position into a vec3_t
void VectorPosition (const AActor *thing, vec3_t out)
{
out[0] = (float)thing->x / 65536.0f;
out[1] = (float)thing->y / 65536.0f;
out[2] = (float)thing->z / 65536.0f;
}
void FixedAngleToVector (angle_t an, int pitch, vec3_t v)
{
an >>= ANGLETOFINESHIFT;
v[0] = ((float)finecosine[an]) / 65536.0f;
v[1] = ((float)finesine[an]) / 65536.0f;
v[2] = ((float)finetangent[FINEANGLES/4-(pitch>>ANGLETOFINESHIFT)]) / 65536.0f;
VectorNormalize (v);
}
// Taken from Q2
vec_t VectorLength (const vec3_t v)
{
float length;
length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
length = sqrtf (length);
return length;
}
void VectorMA (const vec3_t a, float scale, const vec3_t b, vec3_t out)
{
out[0] = a[0] + scale * b[0];
out[1] = a[1] + scale * b[1];
out[2] = a[2] + scale * b[2];
}
void VectorScale (const vec3_t v, float scale, vec3_t out)
{
out[0] = v[0] * scale;
out[1] = v[1] * scale;
out[2] = v[2] * scale;
}
void VectorScale2 (vec3_t v, float scale)
{
v[0] = v[0] * scale;
v[1] = v[1] * scale;
v[2] = v[2] * scale;
}
int VectorCompare (const vec3_t v1, const vec3_t v2)
{
if (v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2])
return 0;
return 1;
}
vec_t VectorNormalize (vec3_t v)
{
double length, ilength;
length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
length = sqrt (length);
if (length)
{
ilength = 1/length;
v[0] = vec_t(v[0] * ilength);
v[1] = vec_t(v[1] * ilength);
v[2] = vec_t(v[2] * ilength);
}
return vec_t(length);
}
vec_t VectorNormalize2 (const vec3_t v, vec3_t out)
{
double length, ilength;
length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
length = sqrt (length);
if (length)
{
ilength = 1/length;
out[0] = vec_t(v[0] * ilength);
out[1] = vec_t(v[1] * ilength);
out[2] = vec_t(v[2] * ilength);
}
return vec_t(length);
}
void CrossProduct (const vec3_t v1, const vec3_t v2, vec3_t cross)
{
cross[0] = v1[1]*v2[2] - v1[2]*v2[1];
cross[1] = v1[2]*v2[0] - v1[0]*v2[2];
cross[2] = v1[0]*v2[1] - v1[1]*v2[0];
}
#ifdef _MSC_VER
#pragma optimize( "", off )
#endif
void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point, float degrees )
{
float m[3][3];
float im[3][3];
float zrot[3][3];
float tmpmat[3][3];
float rot[3][3];
int i;
vec3_t vr, vup, vf;
vf[0] = dir[0];
vf[1] = dir[1];
vf[2] = dir[2];
PerpendicularVector( vr, dir );
CrossProduct( vr, vf, vup );
m[0][0] = vr[0];
m[1][0] = vr[1];
m[2][0] = vr[2];
m[0][1] = vup[0];
m[1][1] = vup[1];
m[2][1] = vup[2];
m[0][2] = vf[0];
m[1][2] = vf[1];
m[2][2] = vf[2];
memcpy( im, m, sizeof( im ) );
im[0][1] = m[1][0];
im[0][2] = m[2][0];
im[1][0] = m[0][1];
im[1][2] = m[2][1];
im[2][0] = m[0][2];
im[2][1] = m[1][2];
memset( zrot, 0, sizeof( zrot ) );
zrot[0][0] = zrot[1][1] = zrot[2][2] = 1.0F;
zrot[0][0] = (float)cos( DEG2RAD( degrees ) );
zrot[0][1] = (float)sin( DEG2RAD( degrees ) );
zrot[1][0] = (float)-sin( DEG2RAD( degrees ) );
zrot[1][1] = (float)cos( DEG2RAD( degrees ) );
R_ConcatRotations( m, zrot, tmpmat );
R_ConcatRotations( tmpmat, im, rot );
for ( i = 0; i < 3; i++ )
{
dst[i] = rot[i][0] * point[0] + rot[i][1] * point[1] + rot[i][2] * point[2];
}
}
#ifdef _MSC_VER
#pragma optimize( "", on )
#endif
void ProjectPointOnPlane (vec3_t dst, const vec3_t p, const vec3_t normal)
{
float d;
vec3_t n;
float inv_denom;
inv_denom = 1.0F / DotProduct( normal, normal );
d = DotProduct( normal, p ) * inv_denom;
n[0] = normal[0] * inv_denom;
n[1] = normal[1] * inv_denom;
n[2] = normal[2] * inv_denom;
dst[0] = p[0] - d * n[0];
dst[1] = p[1] - d * n[1];
dst[2] = p[2] - d * n[2];
}
/*
** assumes "src" is normalized
*/
void PerpendicularVector (vec3_t dst, const vec3_t src)
{
int pos;
int i;
float minelem = 1.0F;
vec3_t tempvec;
/*
** find the smallest magnitude axially aligned vector
*/
for ( pos = 0, i = 0; i < 3; i++ )
{
if ( fabs( src[i] ) < minelem )
{
pos = i;
minelem = (float)fabs( src[i] );
}
}
tempvec[0] = tempvec[1] = tempvec[2] = 0.0F;
tempvec[pos] = 1.0F;
/*
** project the point onto the plane defined by src
*/
ProjectPointOnPlane( dst, tempvec, src );
/*
** normalize the result
*/
VectorNormalize( dst );
}
/*
================
R_ConcatRotations
================
*/
void R_ConcatRotations (const float in1[3][3], const float in2[3][3], float out[3][3])
{
out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] +
in1[0][2] * in2[2][0];
out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] +
in1[0][2] * in2[2][1];
out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] +
in1[0][2] * in2[2][2];
out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] +
in1[1][2] * in2[2][0];
out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] +
in1[1][2] * in2[2][1];
out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] +
in1[1][2] * in2[2][2];
out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] +
in1[2][2] * in2[2][0];
out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] +
in1[2][2] * in2[2][1];
out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] +
in1[2][2] * in2[2][2];
}

1261
src/vectors.h
View file

File diff suppressed because it is too large Load diff

2
src/win32/i_main.cpp
View file

@ -683,7 +683,7 @@ void ShowErrorPane(const char *text)
{
SetWindowLong (ErrorIcon, GWL_ID, IDC_ICONPIC);
}
ErrorPane = CreateDialogParam (g_hInst, MAKEINTRESOURCE(IDD_ERRORPANE), Window, ErrorPaneProc, NULL);
ErrorPane = CreateDialogParam (g_hInst, MAKEINTRESOURCE(IDD_ERRORPANE), Window, ErrorPaneProc, (LONG_PTR)NULL);
CHARRANGE end;
CHARFORMAT2 oldformat, newformat;

1270
zdoom.vcproj
View file

File diff suppressed because it is too large Load diff