From 5070a964b962ac91361e9f7448a09f8900ae4e81 Mon Sep 17 00:00:00 2001 From: RedEnchilada Date: Sat, 25 Apr 2015 22:22:50 -0500 Subject: [PATCH] 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... --- src/m_fixed.h | 22 ---- src/m_vector.c | 262 ++++++++++++++++++++++----------------------- src/p_slopes.c | 285 +------------------------------------------------ 3 files changed, 135 insertions(+), 434 deletions(-) diff --git a/src/m_fixed.h b/src/m_fixed.h index 8bf16020..92b99263 100644 --- a/src/m_fixed.h +++ b/src/m_fixed.h @@ -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 diff --git a/src/m_vector.c b/src/m_vector.c index af518985..53b869ad 100644 --- a/src/m_vector.c +++ b/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); } diff --git a/src/p_slopes.c b/src/p_slopes.c index 2c18d361..15aa6d7f 100644 --- a/src/p_slopes.c +++ b/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