::zerowing-base=428

libs/mathlib/mathlib.c

@@ -78,6 +78,54 @@ qboolean VectorIsOnAxialPlane(vec3_t v)
 	return qfalse;
 }
 
+/*
+================
+VectorIsOnAxis
+================
+*/
+qboolean VectorIsOnAxis(vec3_t v)
+{
+	int	i, zeroComponentCount;
+
+	zeroComponentCount = 0;
+	for (i = 0; i < 3; i++)
+	{
+		if (v[i] == 0.0)
+		{
+			zeroComponentCount++;
+		}
+	}
+
+	if (zeroComponentCount > 1)
+	{
+		// The zero vector will be on axis.
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+================
+VectorIsOnAxialPlane
+================
+*/
+qboolean VectorIsOnAxialPlane(vec3_t v)
+{
+	int	i;
+
+	for (i = 0; i < 3; i++)
+	{
+		if (v[i] == 0.0)
+		{
+			// The zero vector will be on axial plane.
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
 /*
 ================
 MakeNormalVectors
@@ -168,6 +216,8 @@ void _VectorCopy (vec3_t in, vec3_t out)
 
 vec_t VectorNormalize( const vec3_t in, vec3_t out ) {
 
+#if MATHLIB_VECTOR_NORMALIZE_PRECISION_FIX
+
 	// The sqrt() function takes double as an input and returns double as an
 	// output according the the man pages on Debian and on FreeBSD.  Therefore,
 	// I don't see a reason why using a double outright (instead of using the
@@ -191,6 +241,27 @@ vec_t VectorNormalize( const vec3_t in, vec3_t out ) {
 	out[2] = (vec_t) (z / length);
 
 	return (vec_t) length;
+
+#else
+
+	vec_t	length, ilength;
+
+	length = (vec_t)sqrt (in[0]*in[0] + in[1]*in[1] + in[2]*in[2]);
+	if (length == 0)
+	{
+		VectorClear (out);
+		return 0;
+	}
+
+	ilength = 1.0f/length;
+	out[0] = in[0]*ilength;
+	out[1] = in[1]*ilength;
+	out[2] = in[2]*ilength;
+
+	return length;
+
+#endif
+
 }
 
 vec_t ColorNormalize( const vec3_t in, vec3_t out ) {
@@ -791,3 +862,153 @@ vec_accu_t VectorNormalizeAccu(const vec3_accu_t in, vec3_accu_t out)
 
 	return length;
 }
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Below is double-precision math stuff.  This was initially needed by the new
+// "base winding" code in q3map2 brush processing in order to fix the famous
+// "disappearing triangles" issue.  These definitions can be used wherever extra
+// precision is needed.
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+=================
+VectorLengthAccu
+=================
+*/
+vec_accu_t VectorLengthAccu(const vec3_accu_t v)
+{
+	return (vec_accu_t) sqrt((v[0] * v[0]) + (v[1] * v[1]) + (v[2] * v[2]));
+}
+
+/*
+=================
+DotProductAccu
+=================
+*/
+vec_accu_t DotProductAccu(const vec3_accu_t a, const vec3_accu_t b)
+{
+	return (a[0] * b[0]) + (a[1] * b[1]) + (a[2] * b[2]);
+}
+
+/*
+=================
+VectorSubtractAccu
+=================
+*/
+void VectorSubtractAccu(const vec3_accu_t a, const vec3_accu_t b, vec3_accu_t out)
+{
+	out[0] = a[0] - b[0];
+	out[1] = a[1] - b[1];
+	out[2] = a[2] - b[2];
+}
+
+/*
+=================
+VectorAddAccu
+=================
+*/
+void VectorAddAccu(const vec3_accu_t a, const vec3_accu_t b, vec3_accu_t out)
+{
+	out[0] = a[0] + b[0];
+	out[1] = a[1] + b[1];
+	out[2] = a[2] + b[2];
+}
+
+/*
+=================
+VectorCopyAccu
+=================
+*/
+void VectorCopyAccu(const vec3_accu_t in, vec3_accu_t out)
+{
+	out[0] = in[0];
+	out[1] = in[1];
+	out[2] = in[2];
+}
+
+/*
+=================
+VectorScaleAccu
+=================
+*/
+void VectorScaleAccu(const vec3_accu_t in, vec_accu_t scaleFactor, vec3_accu_t out)
+{
+	out[0] = in[0] * scaleFactor;
+	out[1] = in[1] * scaleFactor;
+	out[2] = in[2] * scaleFactor;
+}
+
+/*
+=================
+CrossProductAccu
+=================
+*/
+void CrossProductAccu(const vec3_accu_t a, const vec3_accu_t b, vec3_accu_t out)
+{
+	out[0] = (a[1] * b[2]) - (a[2] * b[1]);
+	out[1] = (a[2] * b[0]) - (a[0] * b[2]);
+	out[2] = (a[0] * b[1]) - (a[1] * b[0]);
+}
+
+/*
+=================
+Q_rintAccu
+=================
+*/
+vec_accu_t Q_rintAccu(vec_accu_t val)
+{
+	return (vec_accu_t) floor(val + 0.5);
+}
+
+/*
+=================
+VectorCopyAccuToRegular
+=================
+*/
+void VectorCopyAccuToRegular(const vec3_accu_t in, vec3_t out)
+{
+	out[0] = (vec_t) in[0];
+	out[1] = (vec_t) in[1];
+	out[2] = (vec_t) in[2];
+}
+
+/*
+=================
+VectorCopyRegularToAccu
+=================
+*/
+void VectorCopyRegularToAccu(const vec3_t in, vec3_accu_t out)
+{
+	out[0] = (vec_accu_t) in[0];
+	out[1] = (vec_accu_t) in[1];
+	out[2] = (vec_accu_t) in[2];
+}
+
+/*
+=================
+VectorNormalizeAccu
+=================
+*/
+vec_accu_t VectorNormalizeAccu(const vec3_accu_t in, vec3_accu_t out)
+{
+	// The sqrt() function takes double as an input and returns double as an
+	// output according the the man pages on Debian and on FreeBSD.  Therefore,
+	// I don't see a reason why using a double outright (instead of using the
+	// vec_accu_t alias for example) could possibly be frowned upon.
+
+	vec_accu_t	length;
+
+	length = (vec_accu_t) sqrt((in[0] * in[0]) + (in[1] * in[1]) + (in[2] * in[2]));
+	if (length == 0)
+	{
+		VectorClear(out);
+		return 0;
+	}
+
+	out[0] = in[0] / length;
+	out[1] = in[1] / length;
+	out[2] = in[2] / length;
+
+	return length;
+}