Starting to clean up a bit of Kal's mess
I still don't know why Git reacts so strangely to the new files' line breaks...
This commit is contained in:
RedEnchilada
parent
bac34d783e
commit
5070a964b9
|
|
@ -357,28 +357,6 @@ FUNCMATH FUNCINLINE static ATTRINLINE fixed_t FixedRound(fixed_t x)
|
|||
return INT32_MAX;
|
||||
}
|
||||
|
||||
/*!
|
||||
\brief convert a fixed_t number into double floating number
|
||||
*/
|
||||
#define FIXED_TO_DOUBLE(f) ((double)((f) / FRACUNIT))
|
||||
|
||||
/*!
|
||||
\brief convert a double floating number into fixed_t number
|
||||
*/
|
||||
#define DOUBLE_TO_FIXED(f) ((fixed_t)((f) * FRACUNIT))
|
||||
|
||||
/*!
|
||||
\brief convert a integer into fixed_t number
|
||||
*/
|
||||
#define INT_TO_FIXED(x) ((int)((x) * FRACUNIT))
|
||||
|
||||
/*!
|
||||
\brief convert a fixed_t number into integer
|
||||
*/
|
||||
#define FIXED_TO_INT(x) (((int)(x)) / (FRACUNIT))
|
||||
|
||||
static inline int DivScale32 (fixed_t a, fixed_t b) { return (fixed_t)(((INT64)a << 32) / b); }
|
||||
|
||||
|
||||
#ifdef NEED_FIXED_VECTOR
|
||||
|
||||
|
|
|
|||
262
src/m_vector.c
262
src/m_vector.c
|
|
@ -1,4 +1,4 @@
|
|||
// Emacs style mode select -*- C++ -*-
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright(C) 2004 Stephen McGranahan
|
||||
|
|
@ -7,12 +7,12 @@
|
|||
// 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.
|
||||
//
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program; if not, write to the Free Software
|
||||
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
|
@ -87,32 +87,32 @@ v3float_t *M_MakeVec3f(const v3float_t *point1, const v3float_t *point2, v3float
|
|||
return a_o;
|
||||
}
|
||||
|
||||
//
|
||||
//
|
||||
// M_TranslateVec3
|
||||
//
|
||||
// Translates the given vector (in the game's coordinate system) to the camera
|
||||
// space (in right-handed coordinate system) This function is used for slopes.
|
||||
//
|
||||
//
|
||||
void M_TranslateVec3(v3fixed_t *vec)
|
||||
{
|
||||
fixed_t tx, ty, tz;
|
||||
|
||||
|
||||
tx = vec->x - viewx;
|
||||
ty = viewz - vec->y;
|
||||
tz = vec->z - viewy;
|
||||
|
||||
|
||||
// Just like wall projection.
|
||||
vec->x = (tx * viewcos) - (tz * viewsin);
|
||||
vec->z = (tz * viewcos) + (tx * viewsin);
|
||||
vec->y = ty;
|
||||
}
|
||||
|
||||
//
|
||||
//
|
||||
// M_TranslateVec3f
|
||||
//
|
||||
// Translates the given vector (in the game's coordinate system) to the camera
|
||||
// space (in right-handed coordinate system) This function is used for slopes.
|
||||
//
|
||||
//
|
||||
void M_TranslateVec3f(v3float_t *vec)
|
||||
{
|
||||
float tx, ty, tz;
|
||||
|
|
@ -128,20 +128,20 @@ void M_TranslateVec3f(v3float_t *vec)
|
|||
}
|
||||
|
||||
#ifdef SESLOPE
|
||||
//
|
||||
//
|
||||
// M_TranslateVec3d
|
||||
//
|
||||
// Translates the given vector (in the game's coordinate system) to the camera
|
||||
// space (in right-handed coordinate system) This function is used for slopes.
|
||||
//
|
||||
//
|
||||
void M_TranslateVec3d(v3double_t *vec)
|
||||
{
|
||||
double tx, ty, tz;
|
||||
|
||||
|
||||
tx = vec->x - viewx; // SRB2CBTODO: This may need float viewxyz
|
||||
ty = viewz - vec->y;
|
||||
tz = vec->z - viewy;
|
||||
|
||||
|
||||
// Just like wall projection.
|
||||
vec->x = (tx * viewcos) - (tz * viewsin);
|
||||
vec->z = (tz * viewcos) + (tx * viewsin);
|
||||
|
|
@ -185,7 +185,7 @@ void M_SubVec3(v3fixed_t *dest, const v3fixed_t *v1, const v3fixed_t *v2) // SRB
|
|||
dest->z = v1->z - v2->z;
|
||||
}
|
||||
|
||||
//
|
||||
//
|
||||
// M_SubVec3f
|
||||
//
|
||||
// Subtracts v2 from v1 stores in dest
|
||||
|
|
@ -197,7 +197,7 @@ void M_SubVec3f(v3float_t *dest, const v3float_t *v1, const v3float_t *v2)
|
|||
dest->z = v1->z - v2->z;
|
||||
}
|
||||
|
||||
//
|
||||
//
|
||||
// M_DotVec3
|
||||
//
|
||||
// Returns the dot product of v1 and v2
|
||||
|
|
@ -207,7 +207,7 @@ fixed_t M_DotVec3(const v3fixed_t *v1, const v3fixed_t *v2)
|
|||
return FixedMul(v1->x, v2->x) + FixedMul(v1->y, v2->y) + FixedMul(v1->z, v2->z);
|
||||
}
|
||||
|
||||
//
|
||||
//
|
||||
// M_DotVec3f
|
||||
//
|
||||
// Returns the dot product of v1 and v2
|
||||
|
|
@ -216,13 +216,11 @@ float M_DotVec3f(const v3float_t *v1, const v3float_t *v2)
|
|||
{
|
||||
if (!v1 || !v2)
|
||||
I_Error("M_DotVec3f: No vertexes!");
|
||||
if (!(v1 || v2 || v1->x || v1->y || v1->z || v2->x || v2->y || v2->z))
|
||||
I_Error("M_DotVec3f: No vertexes!");
|
||||
return (v1->x * v2->x) + (v1->y * v2->y) + (v1->z * v2->z);
|
||||
return (v1->x * v2->x) + (v1->y * v2->y) + (v1->z * v2->z);
|
||||
}
|
||||
|
||||
#ifdef SESLOPE
|
||||
//
|
||||
//
|
||||
// M_DotVec3d
|
||||
//
|
||||
// Returns the dot product of v1 and v2
|
||||
|
|
@ -236,7 +234,7 @@ double M_DotVec3d(const v3double_t *v1, const v3double_t *v2)
|
|||
//
|
||||
// M_CrossProduct3
|
||||
//
|
||||
// Gets the cross product of v1 and v2 and stores in dest
|
||||
// Gets the cross product of v1 and v2 and stores in dest
|
||||
//
|
||||
void M_CrossProduct3(v3fixed_t *dest, const v3fixed_t *v1, const v3fixed_t *v2)
|
||||
{
|
||||
|
|
@ -250,7 +248,7 @@ void M_CrossProduct3(v3fixed_t *dest, const v3fixed_t *v1, const v3fixed_t *v2)
|
|||
//
|
||||
// M_CrossProduct3f
|
||||
//
|
||||
// Gets the cross product of v1 and v2 and stores in dest
|
||||
// Gets the cross product of v1 and v2 and stores in dest
|
||||
//
|
||||
void M_CrossProduct3f(v3float_t *dest, const v3float_t *v1, const v3float_t *v2)
|
||||
{
|
||||
|
|
@ -316,7 +314,7 @@ v3float_t *FV_Midpointf(const v3float_t *a_1, const v3float_t *a_2, v3float_t *a
|
|||
// This checks to see if a point is inside the ranges of a polygon
|
||||
//
|
||||
angle_t FV_AngleBetweenVectors(const v3fixed_t *Vector1, const v3fixed_t *Vector2)
|
||||
{
|
||||
{
|
||||
// Remember, above we said that the Dot Product of returns the cosine of the angle
|
||||
// between 2 vectors? Well, that is assuming they are unit vectors (normalize vectors).
|
||||
// So, if we don't have a unit vector, then instead of just saying arcCos(DotProduct(A, B))
|
||||
|
|
@ -324,19 +322,19 @@ angle_t FV_AngleBetweenVectors(const v3fixed_t *Vector1, const v3fixed_t *Vector
|
|||
// Here is the equation: arc cosine of (V . W / || V || * || W || )
|
||||
// the || V || means the magnitude of V. This then cancels out the magnitudes dot product magnitudes.
|
||||
// But basically, if you have normalize vectors already, you can forget about the magnitude part.
|
||||
|
||||
|
||||
// Get the dot product of the vectors
|
||||
fixed_t dotProduct = M_DotVec3(Vector1, Vector2);
|
||||
|
||||
|
||||
// Get the product of both of the vectors magnitudes
|
||||
fixed_t vectorsMagnitude = FixedMul(FV_Magnitude(Vector1), FV_Magnitude(Vector2));
|
||||
|
||||
|
||||
// Return the arc cosine of the (dotProduct / vectorsMagnitude) which is the angle in RADIANS.
|
||||
return FixedAcos(FixedDiv(dotProduct, vectorsMagnitude));
|
||||
}
|
||||
|
||||
float FV_AngleBetweenVectorsf(const v3float_t *Vector1, const v3float_t *Vector2)
|
||||
{
|
||||
{
|
||||
// Remember, above we said that the Dot Product of returns the cosine of the angle
|
||||
// between 2 vectors? Well, that is assuming they are unit vectors (normalize vectors).
|
||||
// So, if we don't have a unit vector, then instead of just saying arcCos(DotProduct(A, B))
|
||||
|
|
@ -344,13 +342,13 @@ float FV_AngleBetweenVectorsf(const v3float_t *Vector1, const v3float_t *Vector2
|
|||
// Here is the equation: arc cosine of (V . W / || V || * || W || )
|
||||
// the || V || means the magnitude of V. This then cancels out the magnitudes dot product magnitudes.
|
||||
// But basically, if you have normalize vectors already, you can forget about the magnitude part.
|
||||
|
||||
|
||||
// Get the dot product of the vectors
|
||||
float dotProduct = M_DotVec3f(Vector1, Vector2);
|
||||
|
||||
|
||||
// Get the product of both of the vectors magnitudes
|
||||
float vectorsMagnitude = FV_Magnitudef(Vector1)*FV_Magnitudef(Vector2);
|
||||
|
||||
|
||||
// Return the arc cosine of the (dotProduct / vectorsMagnitude) which is the angle in RADIANS.
|
||||
return acos(dotProduct/vectorsMagnitude);
|
||||
}
|
||||
|
|
@ -370,7 +368,7 @@ float M_VectorPitch(v3float_t v)
|
|||
|
||||
#include "z_zone.h"
|
||||
|
||||
// Returns pitch roll and yaw values, allows objects to align to a slope
|
||||
// Returns pitch roll and yaw values, allows objects to align to a slope
|
||||
angles3d_t *M_VectorAlignTo(float Pitch, float Yaw, float Roll, v3float_t v, byte AngleAxis, float Rate)
|
||||
{
|
||||
CONS_Printf("P %f\n", Pitch);
|
||||
|
|
@ -380,7 +378,7 @@ angles3d_t *M_VectorAlignTo(float Pitch, float Yaw, float Roll, v3float_t v, byt
|
|||
{
|
||||
float DestYaw = (atan2(v.z,v.x)* 180 / M_PI);
|
||||
float DestRoll = (atan2(v.y,v.x)* 180 / M_PI);
|
||||
|
||||
|
||||
Yaw = Yaw+(DestYaw-Yaw)*Rate;
|
||||
Roll = Roll+(DestRoll-Roll)*Rate;
|
||||
}
|
||||
|
|
@ -388,7 +386,7 @@ angles3d_t *M_VectorAlignTo(float Pitch, float Yaw, float Roll, v3float_t v, byt
|
|||
{
|
||||
float DestPitch = (atan2(v.z,v.y)* 180 / M_PI);
|
||||
float DestRoll = (-atan2(v.x,v.y)* 180 / M_PI);
|
||||
|
||||
|
||||
Pitch = Pitch+(DestPitch-Pitch)*Rate;
|
||||
Roll = Roll+(DestRoll-Roll)*Rate;
|
||||
}
|
||||
|
|
@ -396,19 +394,19 @@ angles3d_t *M_VectorAlignTo(float Pitch, float Yaw, float Roll, v3float_t v, byt
|
|||
{
|
||||
float DestPitch = (-atan2(v.y,v.z)* 180 / M_PI);
|
||||
float DestYaw = (-atan2(v.x,v.z)* 180 / M_PI);
|
||||
|
||||
|
||||
Pitch = Pitch+(DestPitch-Pitch)*Rate;
|
||||
Yaw = Yaw+(DestYaw-Yaw)*Rate;
|
||||
}
|
||||
|
||||
|
||||
angles3d_t *returnangles = Z_Malloc(sizeof(angles3d_t), PU_LEVEL, NULL);
|
||||
memset(returnangles, 0, sizeof(*returnangles));
|
||||
returnangles->yaw = Yaw;
|
||||
returnangles->pitch = Pitch;
|
||||
returnangles->roll = Roll;
|
||||
|
||||
|
||||
return returnangles;
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -427,28 +425,28 @@ v3fixed_t *FV_SubO(const v3fixed_t *a_i, const v3fixed_t *a_c, v3fixed_t *a_o)
|
|||
boolean FV_Equal(const v3fixed_t *a_1, const v3fixed_t *a_2)
|
||||
{
|
||||
fixed_t Epsilon = FRACUNIT/FRACUNIT;
|
||||
|
||||
|
||||
if ((abs(a_2->x - a_1->x) > Epsilon) ||
|
||||
(abs(a_2->y - a_1->y) > Epsilon) ||
|
||||
(abs(a_2->z - a_1->z) > Epsilon))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
boolean FV_Equalf(const v3float_t *a_1, const v3float_t *a_2)
|
||||
{
|
||||
float Epsilon = 1.0f/1.0f;
|
||||
|
||||
|
||||
if ((abs(a_2->x - a_1->x) > Epsilon) ||
|
||||
(abs(a_2->y - a_1->y) > Epsilon) ||
|
||||
(abs(a_2->z - a_1->z) > Epsilon))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -461,12 +459,12 @@ void FV_Normal (const v3fixed_t *a_triangle, v3fixed_t *a_normal)
|
|||
{
|
||||
v3fixed_t a_1;
|
||||
v3fixed_t a_2;
|
||||
|
||||
|
||||
FV_Point2Vec(&a_triangle[2], &a_triangle[0], &a_1);
|
||||
FV_Point2Vec(&a_triangle[1], &a_triangle[0], &a_2);
|
||||
|
||||
|
||||
FV_Cross(&a_1, &a_2, a_normal);
|
||||
|
||||
|
||||
FV_NormalizeO(a_normal, a_normal);
|
||||
}
|
||||
|
||||
|
|
@ -474,30 +472,30 @@ void FV_Normal (const v3fixed_t *a_triangle, v3fixed_t *a_normal)
|
|||
// PlaneDistance
|
||||
//
|
||||
// Calculates distance between a plane and the origin.
|
||||
//
|
||||
//
|
||||
fixed_t FV_PlaneDistance(const v3fixed_t *a_normal, const v3fixed_t *a_point)
|
||||
{
|
||||
{
|
||||
return -(FixedMul(a_normal->x, a_point->x) + FixedMul(a_normal->y, a_point->y) + FixedMul(a_normal->z, a_point->z));
|
||||
}
|
||||
|
||||
boolean FV_IntersectedPlane(const v3fixed_t *a_triangle, const v3fixed_t *a_line, v3fixed_t *a_normal, fixed_t *originDistance)
|
||||
{
|
||||
fixed_t distance1 = 0, distance2 = 0;
|
||||
|
||||
|
||||
FV_Normal(a_triangle, a_normal);
|
||||
|
||||
|
||||
*originDistance = FV_PlaneDistance(a_normal, &a_triangle[0]);
|
||||
|
||||
|
||||
distance1 = (FixedMul(a_normal->x, a_line[0].x) + FixedMul(a_normal->y, a_line[0].y)
|
||||
+ FixedMul(a_normal->z, a_line[0].z)) + *originDistance;
|
||||
|
||||
|
||||
distance2 = (FixedMul(a_normal->x, a_line[1].x) + FixedMul(a_normal->y, a_line[1].y)
|
||||
+ FixedMul(a_normal->z, a_line[1].z)) + *originDistance;
|
||||
|
||||
|
||||
// Positive or zero number means no intersection
|
||||
if (FixedMul(distance1, distance2) >= 0)
|
||||
return false;
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -522,7 +520,7 @@ fixed_t FV_PlaneIntersection(const v3fixed_t *pOrigin, const v3fixed_t *pNormal,
|
|||
// IntersectRaySphere
|
||||
// Input : rO - origin of ray in world space
|
||||
// rV - vector describing direction of ray in world space
|
||||
// sO - Origin of sphere
|
||||
// sO - Origin of sphere
|
||||
// sR - radius of sphere
|
||||
// Notes : Normalized directional vectors expected
|
||||
// Return: distance to sphere in world units, -1 if no intersection.
|
||||
|
|
@ -532,15 +530,15 @@ fixed_t FV_IntersectRaySphere(const v3fixed_t *rO, const v3fixed_t *rV, const v3
|
|||
v3fixed_t Q;
|
||||
fixed_t c, v, d;
|
||||
FV_SubO(sO, rO, &Q);
|
||||
|
||||
|
||||
c = FV_Magnitude(&Q);
|
||||
v = FV_Dot(&Q, rV);
|
||||
d = FixedMul(sR, sR) - (FixedMul(c,c) - FixedMul(v,v));
|
||||
|
||||
|
||||
// If there was no intersection, return -1
|
||||
if (d < 0*FRACUNIT)
|
||||
return (-1*FRACUNIT);
|
||||
|
||||
|
||||
// Return the distance to the [first] intersecting point
|
||||
return (v - FixedSqrt(d));
|
||||
}
|
||||
|
|
@ -554,15 +552,15 @@ v3fixed_t *FV_IntersectionPoint(const v3fixed_t *vNormal, const v3fixed_t *vLine
|
|||
{
|
||||
v3fixed_t vLineDir; // Variables to hold the point and the line's direction
|
||||
fixed_t Numerator = 0, Denominator = 0, dist = 0;
|
||||
|
||||
|
||||
// Here comes the confusing part. We need to find the 3D point that is actually
|
||||
// on the plane. Here are some steps to do that:
|
||||
|
||||
|
||||
// 1) First we need to get the vector of our line, Then normalize it so it's a length of 1
|
||||
FV_Point2Vec(&vLine[1], &vLine[0], &vLineDir); // Get the Vector of the line
|
||||
FV_NormalizeO(&vLineDir, &vLineDir); // Normalize the lines vector
|
||||
|
||||
|
||||
|
||||
|
||||
// 2) Use the plane equation (distance = Ax + By + Cz + D) to find the distance from one of our points to the plane.
|
||||
// Here I just chose a arbitrary point as the point to find that distance. You notice we negate that
|
||||
// distance. We negate the distance because we want to eventually go BACKWARDS from our point to the plane.
|
||||
|
|
@ -570,17 +568,17 @@ v3fixed_t *FV_IntersectionPoint(const v3fixed_t *vNormal, const v3fixed_t *vLine
|
|||
Numerator = - (FixedMul(vNormal->x, vLine[0].x) + // Use the plane equation with the normal and the line
|
||||
FixedMul(vNormal->y, vLine[0].y) +
|
||||
FixedMul(vNormal->z, vLine[0].z) + distance);
|
||||
|
||||
|
||||
// 3) If we take the dot product between our line vector and the normal of the polygon,
|
||||
// this will give us the cosine of the angle between the 2 (since they are both normalized - length 1).
|
||||
// We will then divide our Numerator by this value to find the offset towards the plane from our arbitrary point.
|
||||
Denominator = FV_Dot(vNormal, &vLineDir); // Get the dot product of the line's vector and the normal of the plane
|
||||
|
||||
|
||||
// Since we are using division, we need to make sure we don't get a divide by zero error
|
||||
// If we do get a 0, that means that there are INFINITE points because the the line is
|
||||
// on the plane (the normal is perpendicular to the line - (Normal.Vector = 0)).
|
||||
// on the plane (the normal is perpendicular to the line - (Normal.Vector = 0)).
|
||||
// In this case, we should just return any point on the line.
|
||||
|
||||
|
||||
if( Denominator == 0*FRACUNIT) // Check so we don't divide by zero
|
||||
{
|
||||
ReturnVec->x = vLine[0].x;
|
||||
|
|
@ -588,7 +586,7 @@ v3fixed_t *FV_IntersectionPoint(const v3fixed_t *vNormal, const v3fixed_t *vLine
|
|||
ReturnVec->z = vLine[0].z;
|
||||
return ReturnVec; // Return an arbitrary point on the line
|
||||
}
|
||||
|
||||
|
||||
// We divide the (distance from the point to the plane) by (the dot product)
|
||||
// to get the distance (dist) that we need to move from our arbitrary point. We need
|
||||
// to then times this distance (dist) by our line's vector (direction). When you times
|
||||
|
|
@ -601,13 +599,13 @@ v3fixed_t *FV_IntersectionPoint(const v3fixed_t *vNormal, const v3fixed_t *vLine
|
|||
// way down the line's length. The distance from the plane is short, but the distance from
|
||||
// the actual intersection point is pretty long. If we divide the distance by the dot product
|
||||
// of our line vector and the normal of the plane, we get the correct length. Cool huh?
|
||||
|
||||
|
||||
dist = FixedDiv(Numerator, Denominator); // Divide to get the multiplying (percentage) factor
|
||||
|
||||
|
||||
// Now, like we said above, we times the dist by the vector, then add our arbitrary point.
|
||||
// This essentially moves the point along the vector to a certain distance. This now gives
|
||||
// us the intersection point. Yay!
|
||||
|
||||
|
||||
// Return the intersection point
|
||||
ReturnVec->x = vLine[0].x + FixedMul(vLineDir.x, dist);
|
||||
ReturnVec->y = vLine[0].y + FixedMul(vLineDir.y, dist);
|
||||
|
|
@ -639,16 +637,16 @@ unsigned int FV_PointOnLineSide(const v3fixed_t *point, const v3fixed_t *line)
|
|||
boolean FV_PointInsideBox(const v3fixed_t *point, const v3fixed_t *box)
|
||||
{
|
||||
v3fixed_t lastLine[2];
|
||||
|
||||
|
||||
FV_Load(&lastLine[0], box[3].x, box[3].y, box[3].z);
|
||||
FV_Load(&lastLine[1], box[0].x, box[0].y, box[0].z);
|
||||
|
||||
|
||||
if (FV_PointOnLineSide(point, &box[0])
|
||||
|| FV_PointOnLineSide(point, &box[1])
|
||||
|| FV_PointOnLineSide(point, &box[2])
|
||||
|| FV_PointOnLineSide(point, lastLine))
|
||||
return false;
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
//
|
||||
|
|
@ -660,7 +658,7 @@ void FM_LoadIdentity(fmatrix_t* matrix)
|
|||
{
|
||||
#define M(row,col) matrix->m[col * 4 + row]
|
||||
memset(matrix, 0x00, sizeof(fmatrix_t));
|
||||
|
||||
|
||||
M(0, 0) = FRACUNIT;
|
||||
M(1, 1) = FRACUNIT;
|
||||
M(2, 2) = FRACUNIT;
|
||||
|
|
@ -679,29 +677,29 @@ void FM_CreateObjectMatrix(fmatrix_t *matrix, fixed_t x, fixed_t y, fixed_t z, f
|
|||
v3fixed_t upcross;
|
||||
v3fixed_t upvec;
|
||||
v3fixed_t basevec;
|
||||
|
||||
|
||||
FV_Load(&upvec, upx, upy, upz);
|
||||
FV_Load(&basevec, anglex, angley, anglez);
|
||||
FV_Cross(&upvec, &basevec, &upcross);
|
||||
FV_Normalize(&upcross);
|
||||
|
||||
|
||||
FM_LoadIdentity(matrix);
|
||||
|
||||
|
||||
matrix->m[0] = upcross.x;
|
||||
matrix->m[1] = upcross.y;
|
||||
matrix->m[2] = upcross.z;
|
||||
matrix->m[3] = 0*FRACUNIT;
|
||||
|
||||
|
||||
matrix->m[4] = upx;
|
||||
matrix->m[5] = upy;
|
||||
matrix->m[6] = upz;
|
||||
matrix->m[7] = 0;
|
||||
|
||||
|
||||
matrix->m[8] = anglex;
|
||||
matrix->m[9] = angley;
|
||||
matrix->m[10] = anglez;
|
||||
matrix->m[11] = 0;
|
||||
|
||||
|
||||
matrix->m[12] = x - FixedMul(upx,radius);
|
||||
matrix->m[13] = y - FixedMul(upy,radius);
|
||||
matrix->m[14] = z - FixedMul(upz,radius);
|
||||
|
|
@ -720,12 +718,12 @@ void FM_MultMatrixVec(const fmatrix_t *matrix, const v3fixed_t *vec, v3fixed_t *
|
|||
+ FixedMul(vec->y,M(0, 1))
|
||||
+ FixedMul(vec->z,M(0, 2))
|
||||
+ M(0, 3);
|
||||
|
||||
|
||||
out->y = FixedMul(vec->x,M(1, 0))
|
||||
+ FixedMul(vec->y,M(1, 1))
|
||||
+ FixedMul(vec->z,M(1, 2))
|
||||
+ M(1, 3);
|
||||
|
||||
|
||||
out->z = FixedMul(vec->x,M(2, 0))
|
||||
+ FixedMul(vec->y,M(2, 1))
|
||||
+ FixedMul(vec->z,M(2, 2))
|
||||
|
|
@ -745,15 +743,15 @@ void FM_MultMatrix(fmatrix_t *dest, const fmatrix_t *multme)
|
|||
#define M(row,col) multme->m[col * 4 + row]
|
||||
#define D(row,col) dest->m[col * 4 + row]
|
||||
#define R(row,col) result.m[col * 4 + row]
|
||||
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
for (j = 0; j < 4; j++)
|
||||
R(i, j) = FixedMul(D(i, 0),M(0, j)) + FixedMul(D(i, 1),M(1, j)) + FixedMul(D(i, 2),M(2, j)) + FixedMul(D(i, 3),M(3, j));
|
||||
}
|
||||
|
||||
|
||||
M_Memcpy(dest, &result, sizeof(fmatrix_t));
|
||||
|
||||
|
||||
#undef R
|
||||
#undef D
|
||||
#undef M
|
||||
|
|
@ -768,14 +766,14 @@ void FM_Translate(fmatrix_t *dest, fixed_t x, fixed_t y, fixed_t z)
|
|||
{
|
||||
fmatrix_t trans;
|
||||
#define M(row,col) trans.m[col * 4 + row]
|
||||
|
||||
|
||||
memset(&trans, 0x00, sizeof(fmatrix_t));
|
||||
|
||||
|
||||
M(0, 0) = M(1, 1) = M(2, 2) = M(3, 3) = FRACUNIT;
|
||||
M(0, 3) = x;
|
||||
M(1, 3) = y;
|
||||
M(2, 3) = z;
|
||||
|
||||
|
||||
FM_MultMatrix(dest, &trans);
|
||||
#undef M
|
||||
}
|
||||
|
|
@ -789,14 +787,14 @@ void FM_Scale(fmatrix_t *dest, fixed_t x, fixed_t y, fixed_t z)
|
|||
{
|
||||
fmatrix_t scale;
|
||||
#define M(row,col) scale.m[col * 4 + row]
|
||||
|
||||
|
||||
memset(&scale, 0x00, sizeof(fmatrix_t));
|
||||
|
||||
|
||||
M(3, 3) = FRACUNIT;
|
||||
M(0, 0) = x;
|
||||
M(1, 1) = y;
|
||||
M(2, 2) = z;
|
||||
|
||||
|
||||
FM_MultMatrix(dest, &scale);
|
||||
#undef M
|
||||
}
|
||||
|
|
@ -824,10 +822,10 @@ v3fixed_t *FV_ClosestPointOnLine(const v3fixed_t *Line, const v3fixed_t *p, v3fi
|
|||
FV_SubO(p, &Line[0], &c);
|
||||
FV_SubO(&Line[1], &Line[0], &V);
|
||||
FV_NormalizeO(&V, &V);
|
||||
|
||||
|
||||
d = FV_Distance(&Line[0], &Line[1]);
|
||||
t = FV_Dot(&V, &c);
|
||||
|
||||
|
||||
// Check to see if ëtí is beyond the extents of the line segment
|
||||
if (t < 0)
|
||||
{
|
||||
|
|
@ -837,10 +835,10 @@ v3fixed_t *FV_ClosestPointOnLine(const v3fixed_t *Line, const v3fixed_t *p, v3fi
|
|||
{
|
||||
return FV_Copy(out, &Line[1]);
|
||||
}
|
||||
|
||||
|
||||
// Return the point between ëLine[0]í and ëLine[1]í
|
||||
FV_Mul(&V, t);
|
||||
|
||||
|
||||
return FV_AddO(&Line[0], &V, out);
|
||||
}
|
||||
|
||||
|
|
@ -857,33 +855,33 @@ void FV_ClosestPointOnTriangle (const v3fixed_t *tri, const v3fixed_t *point, v3
|
|||
fixed_t dist, closestdist;
|
||||
v3fixed_t EdgePoints[3];
|
||||
v3fixed_t Line[2];
|
||||
|
||||
|
||||
FV_Copy(&Line[0], (v3fixed_t*)&tri[0]);
|
||||
FV_Copy(&Line[1], (v3fixed_t*)&tri[1]);
|
||||
FV_ClosestPointOnLine(Line, point, &EdgePoints[0]);
|
||||
|
||||
|
||||
FV_Copy(&Line[0], (v3fixed_t*)&tri[1]);
|
||||
FV_Copy(&Line[1], (v3fixed_t*)&tri[2]);
|
||||
FV_ClosestPointOnLine(Line, point, &EdgePoints[1]);
|
||||
|
||||
|
||||
FV_Copy(&Line[0], (v3fixed_t*)&tri[2]);
|
||||
FV_Copy(&Line[1], (v3fixed_t*)&tri[0]);
|
||||
FV_ClosestPointOnLine(Line, point, &EdgePoints[2]);
|
||||
|
||||
|
||||
// Find the closest one of the three
|
||||
FV_Copy(result, &EdgePoints[0]);
|
||||
closestdist = FV_Distance(point, &EdgePoints[0]);
|
||||
for (i = 1; i < 3; i++)
|
||||
{
|
||||
dist = FV_Distance(point, &EdgePoints[i]);
|
||||
|
||||
|
||||
if (dist < closestdist)
|
||||
{
|
||||
closestdist = dist;
|
||||
FV_Copy(result, &EdgePoints[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// We now have the closest point! Whee!
|
||||
}
|
||||
|
||||
|
|
@ -897,7 +895,7 @@ boolean FV_InsidePolygon(const fvector_t *vIntersection, const fvector_t *Poly,
|
|||
int i;
|
||||
UINT64 Angle = 0; // Initialize the angle
|
||||
fvector_t vA, vB; // Create temp vectors
|
||||
|
||||
|
||||
// Just because we intersected the plane, doesn't mean we were anywhere near the polygon.
|
||||
// This functions checks our intersection point to make sure it is inside of the polygon.
|
||||
// This is another tough function to grasp at first, but let me try and explain.
|
||||
|
|
@ -911,26 +909,26 @@ boolean FV_InsidePolygon(const fvector_t *vIntersection, const fvector_t *Poly,
|
|||
// all of the angles in a triangle we get 360 right? Well, that is kinda what we are doing,
|
||||
// but the inverse of that. Say your triangle is an isosceles triangle, so add up the angles
|
||||
// and you will get 360 degree angles. 90 + 90 + 90 is 360.
|
||||
|
||||
|
||||
for (i = 0; i < vertexCount; i++) // Go in a circle to each vertex and get the angle between
|
||||
{
|
||||
{
|
||||
FV_Point2Vec(&Poly[i], vIntersection, &vA); // Subtract the intersection point from the current vertex
|
||||
// Subtract the point from the next vertex
|
||||
FV_Point2Vec(&Poly[(i + 1) % vertexCount], vIntersection, &vB);
|
||||
|
||||
|
||||
Angle += FV_AngleBetweenVectors(&vA, &vB); // Find the angle between the 2 vectors and add them all up as we go along
|
||||
}
|
||||
|
||||
|
||||
// Now that we have the total angles added up, we need to check if they add up to 360 degrees.
|
||||
// Since we are using the dot product, we are working in radians, so we check if the angles
|
||||
// equals 2*PI. We defined PI in 3DMath.h. You will notice that we use a MATCH_FACTOR
|
||||
// in conjunction with our desired degree. This is because of the inaccuracy when working
|
||||
// with floating point numbers. It usually won't always be perfectly 2 * PI, so we need
|
||||
// to use a little twiddling. I use .9999, but you can change this to fit your own desired accuracy.
|
||||
|
||||
|
||||
if(Angle >= ANGLE_MAX) // If the angle is greater than 2 PI, (360 degrees)
|
||||
return 1; // The point is inside of the polygon
|
||||
|
||||
|
||||
return 0; // If you get here, it obviously wasn't inside the polygon.
|
||||
}
|
||||
|
||||
|
|
@ -943,27 +941,27 @@ boolean FV_IntersectedPolygon(const fvector_t *vPoly, const fvector_t *vLine, co
|
|||
{
|
||||
fvector_t vNormal, vIntersection;
|
||||
fixed_t originDistance = 0*FRACUNIT;
|
||||
|
||||
|
||||
|
||||
|
||||
// First we check to see if our line intersected the plane. If this isn't true
|
||||
// there is no need to go on, so return false immediately.
|
||||
// We pass in address of vNormal and originDistance so we only calculate it once
|
||||
|
||||
|
||||
if(!FV_IntersectedPlane(vPoly, vLine, &vNormal, &originDistance))
|
||||
return false;
|
||||
|
||||
// Now that we have our normal and distance passed back from IntersectedPlane(),
|
||||
|
||||
// Now that we have our normal and distance passed back from IntersectedPlane(),
|
||||
// we can use it to calculate the intersection point. The intersection point
|
||||
// is the point that actually is ON the plane. It is between the line. We need
|
||||
// this point test next, if we are inside the polygon. To get the I-Point, we
|
||||
// give our function the normal of the plane, the points of the line, and the originDistance.
|
||||
|
||||
|
||||
FV_IntersectionPoint(&vNormal, vLine, originDistance, &vIntersection);
|
||||
|
||||
|
||||
// Now that we have the intersection point, we need to test if it's inside the polygon.
|
||||
// To do this, we pass in :
|
||||
// (our intersection point, the polygon, and the number of vertices our polygon has)
|
||||
|
||||
|
||||
if(FV_InsidePolygon(&vIntersection, vPoly, vertexCount))
|
||||
{
|
||||
if (collisionPoint != NULL) // Optional - load the collision point.
|
||||
|
|
@ -974,7 +972,7 @@ boolean FV_IntersectedPolygon(const fvector_t *vPoly, const fvector_t *vLine, co
|
|||
}
|
||||
return true; // We collided!
|
||||
}
|
||||
|
||||
|
||||
// If we get here, we must have NOT collided
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1017,7 +1015,7 @@ void FV_Rotate(fvector_t *rotVec, const fvector_t *axisVec, const angle_t angle)
|
|||
fixed_t ex = FixedMul(vz-wy, sa);
|
||||
fixed_t ey = FixedMul(wx-uz, sa);
|
||||
fixed_t ez = FixedMul(uy-vx, sa);
|
||||
|
||||
|
||||
rotVec->x = ax+dx+ex;
|
||||
rotVec->y = ay+dy+ey;
|
||||
rotVec->z = az+dz+ez;
|
||||
|
|
@ -1033,41 +1031,41 @@ void FM_Rotate(fmatrix_t *dest, angle_t angle, fixed_t x, fixed_t y, fixed_t z)
|
|||
fixed_t xSq, ySq, zSq;
|
||||
fixed_t sx, sy, sz;
|
||||
fixed_t sxy, sxz, syz;
|
||||
|
||||
|
||||
FV_Normalize(&nrm);
|
||||
|
||||
|
||||
x = nrm.x;
|
||||
y = nrm.y;
|
||||
z = nrm.z;
|
||||
|
||||
|
||||
xSq = FixedMul(x, FixedMul(invCosA,x));
|
||||
ySq = FixedMul(y, FixedMul(invCosA,y));
|
||||
zSq = FixedMul(z, FixedMul(invCosA,z));
|
||||
|
||||
|
||||
sx = FixedMul(sinA, x);
|
||||
sy = FixedMul(sinA, y);
|
||||
sz = FixedMul(sinA, z);
|
||||
|
||||
|
||||
sxy = FixedMul(x, FixedMul(invCosA,y));
|
||||
sxz = FixedMul(x, FixedMul(invCosA,z));
|
||||
syz = FixedMul(y, FixedMul(invCosA,z));
|
||||
|
||||
|
||||
|
||||
|
||||
M(0, 0) = xSq + cosA;
|
||||
M(1, 0) = sxy - sz;
|
||||
M(2, 0) = sxz + sy;
|
||||
M(3, 0) = 0;
|
||||
|
||||
|
||||
M(0, 1) = sxy + sz;
|
||||
M(1, 1) = ySq + cosA;
|
||||
M(2, 1) = syz - sx;
|
||||
M(3, 1) = 0;
|
||||
|
||||
|
||||
M(0, 2) = sxz - sy;
|
||||
M(1, 2) = syz + sx;
|
||||
M(2, 2) = zSq + cosA;
|
||||
M(3, 2) = 0;
|
||||
|
||||
|
||||
M(0, 3) = 0;
|
||||
M(1, 3) = 0;
|
||||
M(2, 3) = 0;
|
||||
|
|
@ -1127,12 +1125,12 @@ void FV_Normal(const v3fixed_t *a_triangle, v3fixed_t *a_normal)
|
|||
{
|
||||
v3fixed_t a_1;
|
||||
v3fixed_t a_2;
|
||||
|
||||
|
||||
M_MakeVec3(&a_triangle[2], &a_triangle[0], &a_1);
|
||||
M_MakeVec3(&a_triangle[1], &a_triangle[0], &a_2);
|
||||
|
||||
|
||||
M_CrossProduct3(&a_1, &a_2, a_normal);
|
||||
|
||||
|
||||
FV_NormalizeO(a_normal, a_normal);
|
||||
}
|
||||
|
||||
|
|
@ -1145,12 +1143,12 @@ void FV_Normalf(const v3float_t *a_triangle, v3float_t *a_normal)
|
|||
{
|
||||
v3float_t a_1;
|
||||
v3float_t a_2;
|
||||
|
||||
|
||||
M_MakeVec3f(&a_triangle[2], &a_triangle[0], &a_1);
|
||||
M_MakeVec3f(&a_triangle[1], &a_triangle[0], &a_2);
|
||||
|
||||
|
||||
M_CrossProduct3f(&a_1, &a_2, a_normal);
|
||||
|
||||
|
||||
FV_NormalizeOf(a_normal, a_normal);
|
||||
}
|
||||
|
||||
|
|
|
|||
285
src/p_slopes.c
285
src/p_slopes.c
|
|
@ -359,7 +359,7 @@ void P_SpawnSlope_Line(int linenum)
|
|||
srcplane->a = FLOAT_TO_FIXED (fslope->normalf.x); // cross[0]
|
||||
srcplane->b = FLOAT_TO_FIXED (fslope->normalf.y); // cross[1]
|
||||
srcplane->c = FLOAT_TO_FIXED (fslope->normalf.z); // cross[2]
|
||||
srcplane->ic = DivScale32 (1, srcplane->c); // (1 << 32/srcplane->c) or FLOAT_TO_FIXED(1.0f/cross[2]);
|
||||
srcplane->ic = FixedDiv(FRACUNIT, srcplane->c); // (1 << 32/srcplane->c) or FLOAT_TO_FIXED(1.0f/cross[2]);
|
||||
|
||||
// destheight takes the destination height used in dz
|
||||
srcplane->d = -TMulScale16 (srcplane->a, line->v1->x, // x
|
||||
|
|
@ -414,7 +414,7 @@ void P_SpawnSlope_Line(int linenum)
|
|||
srcplane->b = FLOAT_TO_FIXED (cslope->normalf.y); // cross[1]
|
||||
srcplane->c = FLOAT_TO_FIXED (cslope->normalf.z); // cross[2]
|
||||
//plane->ic = FLOAT_TO_FIXED (1.f/cross[2]);
|
||||
srcplane->ic = DivScale32 (1, srcplane->c); // (1 << 32/srcplane->c)
|
||||
srcplane->ic = FixedDiv(FRACUNIT, srcplane->c); // (1 << 32/srcplane->c)
|
||||
#ifdef SLOPETHINGS // For setting thing-based slopes
|
||||
srcplane->d = -TMulScale16 (plane->a, x,
|
||||
plane->b, y,
|
||||
|
|
@ -523,7 +523,7 @@ void P_SpawnSlope_Line(int linenum)
|
|||
srcplane->b = FLOAT_TO_FIXED (fslope->normalf.y); // cross[1]
|
||||
srcplane->c = FLOAT_TO_FIXED (fslope->normalf.z); // cross[2]
|
||||
//plane->ic = FLOAT_TO_FIXED (1.f/cross[2]);
|
||||
srcplane->ic = DivScale32 (1, srcplane->c); // (1 << 32/srcplane->c)
|
||||
srcplane->ic = FixedDiv(FRACUNIT, srcplane->c); // (1 << 32/srcplane->c)
|
||||
#ifdef SLOPETHINGS // For setting thing-based slopes
|
||||
srcplane->d = -TMulScale16 (plane->a, x,
|
||||
plane->b, y,
|
||||
|
|
@ -585,7 +585,7 @@ void P_SpawnSlope_Line(int linenum)
|
|||
srcplane->b = FLOAT_TO_FIXED (cslope->normalf.y); // cross[1]
|
||||
srcplane->c = FLOAT_TO_FIXED (cslope->normalf.z); // cross[2]
|
||||
//plane->ic = FLOAT_TO_FIXED (1.f/cross[2]);
|
||||
srcplane->ic = DivScale32 (1, srcplane->c); // (1 << 32/srcplane->c)
|
||||
srcplane->ic = FixedDiv(FRACUNIT, srcplane->c); // (1 << 32/srcplane->c)
|
||||
#ifdef SLOPETHINGS // For setting thing-based slopes
|
||||
srcplane->d = -TMulScale16 (plane->a, x,
|
||||
plane->b, y,
|
||||
|
|
@ -638,13 +638,6 @@ void P_CopySectorSlope(line_t *line)
|
|||
|
||||
#include "byteptr.h"
|
||||
|
||||
/*
|
||||
typedef struct
|
||||
{
|
||||
fixed_t z1;
|
||||
fixed_t z2;
|
||||
} mapvert_t;*/
|
||||
|
||||
#include "p_setup.h"
|
||||
#include "p_local.h"
|
||||
|
||||
|
|
@ -861,7 +854,7 @@ void P_SetSlopesFromVertexHeights(lumpnum_t lumpnum)
|
|||
srcplane->a = FLOAT_TO_FIXED (ret->normalf.x);
|
||||
srcplane->b = FLOAT_TO_FIXED (ret->normalf.y);
|
||||
srcplane->c = FLOAT_TO_FIXED (ret->normalf.z);
|
||||
//srcplane->ic = DivScale32 (1, srcplane->c);
|
||||
//srcplane->ic = FixedDiv(FRACUNIT, srcplane->c);
|
||||
srcplane->d = -TMulScale16 (srcplane->a, vertexes[vi3].x,
|
||||
srcplane->b, vertexes[vi3].y,
|
||||
srcplane->c, z3);
|
||||
|
|
@ -891,279 +884,11 @@ void P_SetSlopesFromVertexHeights(lumpnum_t lumpnum)
|
|||
}
|
||||
Z_Free(datastart);
|
||||
|
||||
#if 0 // UDMF support
|
||||
for(i = 0; i < numvertexdatas; i++)
|
||||
{
|
||||
if (vertexdatas[i].flags & VERTEXFLAG_ZCeilingEnabled)
|
||||
{
|
||||
vt_heights[1][i] = vertexdatas[i].zCeiling;
|
||||
vt_found = true;
|
||||
}
|
||||
|
||||
if (vertexdatas[i].flags & VERTEXFLAG_ZFloorEnabled)
|
||||
{
|
||||
vt_heights[0][i] = vertexdatas[i].zFloor;
|
||||
vt_found = true;
|
||||
}
|
||||
}
|
||||
|
||||
// If vertexdata_t is ever extended for non-slope usage, this will obviously have to be deferred or removed.
|
||||
delete[] vertexdatas;
|
||||
vertexdatas = NULL;
|
||||
numvertexdatas = 0;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#include "p_maputl.h"
|
||||
|
||||
#if 0
|
||||
static void P_SlopeLineToPointo (int lineid, fixed_t x, fixed_t y, fixed_t z, boolean slopeCeil)
|
||||
{
|
||||
int linenum = -1;
|
||||
|
||||
while ((linenum = P_FindLineFromID (lineid, linenum)) != -1)
|
||||
{
|
||||
const line_t *line = &lines[linenum];
|
||||
sector_t *sec;
|
||||
secplane_t *plane;
|
||||
|
||||
if (P_PointOnLineSide (x, y, line) == 0)
|
||||
{
|
||||
sec = line->frontsector;
|
||||
}
|
||||
else
|
||||
{
|
||||
sec = line->backsector;
|
||||
}
|
||||
if (sec == NULL)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (slopeCeil)
|
||||
{
|
||||
plane = &sec->ceilingplane;
|
||||
}
|
||||
else
|
||||
{
|
||||
plane = &sec->floorplane;
|
||||
}
|
||||
|
||||
FVector3 p, v1, v2, cross;
|
||||
|
||||
p[0] = FIXED2FLOAT (line->v1->x);
|
||||
p[1] = FIXED2FLOAT (line->v1->y);
|
||||
p[2] = FIXED2FLOAT (plane->ZatPoint (line->v1->x, line->v1->y));
|
||||
v1[0] = FIXED2FLOAT (line->dx);
|
||||
v1[1] = FIXED2FLOAT (line->dy);
|
||||
v1[2] = FIXED2FLOAT (plane->ZatPoint (line->v2->x, line->v2->y)) - p[2];
|
||||
v2[0] = FIXED2FLOAT (x - line->v1->x);
|
||||
v2[1] = FIXED2FLOAT (y - line->v1->y);
|
||||
v2[2] = FIXED2FLOAT (z) - p[2];
|
||||
|
||||
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.Z < 0 && !slopeCeil) || (cross.Z > 0 && slopeCeil))
|
||||
{
|
||||
cross = -cross;
|
||||
}
|
||||
|
||||
plane->a = FLOAT2FIXED (cross[0]);
|
||||
plane->b = FLOAT2FIXED (cross[1]);
|
||||
plane->c = FLOAT2FIXED (cross[2]);
|
||||
//plane->ic = FLOAT2FIXED (1.f/cross[2]);
|
||||
plane->ic = DivScale32 (1, plane->c);
|
||||
plane->d = -TMulScale16 (plane->a, x,
|
||||
plane->b, y,
|
||||
plane->c, z);
|
||||
}
|
||||
}
|
||||
#else
|
||||
#if 0
|
||||
// P_SlopeLineToPoint, start from a specific linedef number(not tag) and slope to a mapthing with the angle of the linedef
|
||||
static void P_SlopeLineToPoint(int linenum)
|
||||
{
|
||||
line_t *line = lines + linenum;
|
||||
int special = line->special;
|
||||
pslope_t *fslope = NULL, *cslope = NULL;
|
||||
v3float_t origin, point;
|
||||
v2float_t direction;
|
||||
float dz, extent;
|
||||
|
||||
boolean frontfloor = (special == 386 || special == 388 || special == 393);
|
||||
boolean backfloor = (special == 389 || special == 391 || special == 392);
|
||||
boolean frontceil = (special == 387 || special == 388 || special == 392);
|
||||
boolean backceil = (special == 390 || special == 391 || special == 393);
|
||||
|
||||
// SoM: We don't need the line to retain its special type
|
||||
line->special = 0; //SRB2CBTODO: ESLOPE: Maybe we do need it for another to check for a plane slope?
|
||||
|
||||
if(!frontfloor && !backfloor && !frontceil && !backceil)
|
||||
{
|
||||
CONS_Printf("P_SpawnSlope_Line called with non-slope line special.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if(!line->frontsector || !line->backsector)
|
||||
{
|
||||
CONS_Printf("P_SpawnSlope_Line used on a line without two sides.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
origin.x = (FIXED_TO_FLOAT(line->v2->x) + FIXED_TO_FLOAT(line->v1->x)) * 0.5f;
|
||||
origin.y = (FIXED_TO_FLOAT(line->v2->y) + FIXED_TO_FLOAT(line->v1->y)) * 0.5f;
|
||||
|
||||
if(frontfloor || frontceil)
|
||||
{
|
||||
// Do the front sector
|
||||
direction.x = line->nx;
|
||||
direction.y = line->ny;
|
||||
|
||||
extent = P_GetExtent(line->frontsector, line, &origin, &direction);
|
||||
|
||||
if(extent < 0.0f)
|
||||
{
|
||||
CONS_Printf("P_SpawnSlope_Line failed to get frontsector extent on line number %i\n", linenum);
|
||||
return;
|
||||
}
|
||||
|
||||
// reposition the origin according to the extent
|
||||
point.x = origin.x + direction.x * extent;
|
||||
point.y = origin.y + direction.y * extent;
|
||||
direction.x = -direction.x;
|
||||
direction.y = -direction.y;
|
||||
|
||||
// CONS_Printf("Test: X: %f, Y: %f\n", origin.x, origin.y);
|
||||
|
||||
if(frontfloor)
|
||||
{
|
||||
point.z = FIXED_TO_FLOAT(line->frontsector->floorheight); // Startz
|
||||
dz = (FIXED_TO_FLOAT(line->backsector->floorheight) - point.z) / extent; // Destinationz
|
||||
|
||||
fslope = line->frontsector->f_slope =
|
||||
P_MakeSlope(&point, &direction, dz, false);
|
||||
|
||||
// Sync the linedata of the line that started this slope
|
||||
// SRB2CBTODO: Anything special for remote(control sector)-based slopes later?
|
||||
line->frontsector->f_slope->sourceline = line;
|
||||
|
||||
// Remember the way the slope is formed
|
||||
fixed_t highest = line->frontsector->floorheight > line->backsector->floorheight ?
|
||||
line->frontsector->floorheight : line->backsector->floorheight;
|
||||
fixed_t lowest = line->frontsector->floorheight < line->backsector->floorheight ?
|
||||
line->frontsector->floorheight : line->backsector->floorheight;
|
||||
// This line special sets extra clipping data for the frontsector's slope
|
||||
fslope->highz = line->frontsector->f_slope->highz = highest;
|
||||
fslope->lowz = line->frontsector->f_slope->lowz = lowest;
|
||||
|
||||
// SRB2CBTODO: Get XY angle of a slope and then awesome physics! // ESLOPE:
|
||||
//fslope->zangle = line->frontsector->f_slope->zangle = P_GetSlopezangle(line->frontsector, highvert, lowvert);
|
||||
//100*(ANG45/45);//R_PointToAngle2(direction.x, direction.y, origin.x, origin.y);
|
||||
// Get slope XY angle with secplane_t
|
||||
secplane_t *srcplane = Z_Calloc(sizeof(*srcplane), PU_LEVEL, NULL);
|
||||
// ZDoom secplane port!
|
||||
// secplane_t! woot!
|
||||
// ret = f_slope or c_slope
|
||||
srcplane->a = FLOAT_TO_FIXED (fslope->normalf.x); // cross[0]
|
||||
srcplane->b = FLOAT_TO_FIXED (fslope->normalf.y); // cross[1]
|
||||
srcplane->c = FLOAT_TO_FIXED (fslope->normalf.z); // cross[2]
|
||||
//plane->ic = FLOAT_TO_FIXED (1.f/cross[2]);
|
||||
srcplane->ic = DivScale32 (1, srcplane->c); // (1 << 32/srcplane->c)
|
||||
#ifdef SLOPETHINGS // For setting thing-based slopes
|
||||
srcplane->d = -TMulScale16 (plane->a, x,
|
||||
plane->b, y,
|
||||
plane->c, z);
|
||||
#endif
|
||||
//srcheight = isceiling ? sec->GetPlaneTexZ(sector_t::floor) : sec->GetPlaneTexZ(sector_t::ceiling);
|
||||
//destheight = isceiling ? refsec->GetPlaneTexZ(sector_t::floor) : refsec->GetPlaneTexZ(sector_t::ceiling);
|
||||
//P_GetZAtf(ret, v2.x, v2.y)
|
||||
// destheight takes the destination height used in dz
|
||||
srcplane->d = -TMulScale16 (srcplane->a, line->v1->x,
|
||||
srcplane->b, line->v1->y,
|
||||
srcplane->c, line->backsector->floorheight);
|
||||
|
||||
// Sync the secplane!
|
||||
fslope->secplane = line->frontsector->f_slope->secplane = *srcplane;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
// P_SpawnSlopeMakers
|
||||
//
|
||||
//===========================================================================
|
||||
#if 0
|
||||
void P_SpawnSlopeMakers (FMapThing *firstmt, FMapThing *lastmt)
|
||||
{
|
||||
FMapThing *mt;
|
||||
|
||||
for (mt = firstmt; mt < lastmt; ++mt)
|
||||
{
|
||||
if ((mt->type >= THING_SlopeFloorPointLine &&
|
||||
mt->type <= THING_SetCeilingSlope) ||
|
||||
mt->type==THING_VavoomFloor || mt->type==THING_VavoomCeiling)
|
||||
{
|
||||
fixed_t x, y, z;
|
||||
secplane_t *refplane;
|
||||
sector_t *sec;
|
||||
|
||||
x = mt->x;
|
||||
y = mt->y;
|
||||
sec = P_PointInSector (x, y);
|
||||
if (mt->type & 1)
|
||||
{
|
||||
refplane = &sec->ceilingplane;
|
||||
}
|
||||
else
|
||||
{
|
||||
refplane = &sec->floorplane;
|
||||
}
|
||||
z = refplane->ZatPoint (x, y) + (mt->z);
|
||||
if (mt->type==THING_VavoomFloor || mt->type==THING_VavoomCeiling)
|
||||
{
|
||||
P_VavoomSlope(sec, mt->thingid, x, y, mt->z, mt->type & 1);
|
||||
}
|
||||
else if (mt->type <= THING_SlopeCeilingPointLine)
|
||||
{
|
||||
P_SlopeLineToPoint (mt->args[0], x, y, z, mt->type & 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
P_SetSlope (refplane, mt->type & 1, mt->angle, mt->args[0], x, y, z);
|
||||
}
|
||||
mt->type = 0;
|
||||
}
|
||||
}
|
||||
|
||||
for (mt = firstmt; mt < lastmt; ++mt)
|
||||
{
|
||||
if (mt->type == THING_CopyFloorPlane ||
|
||||
mt->type == THING_CopyCeilingPlane)
|
||||
{
|
||||
P_CopyPlane (mt->args[0], mt->x, mt->y, mt->type & 1);
|
||||
mt->type = 0;
|
||||
}
|
||||
}
|
||||
|
||||
P_SetSlopesFromVertexHeights(firstmt, lastmt);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue