Implemented member function ProjectToAxis() to most of the geometry classes.

Author: juj

src/Geometry/Capsule.cpp

@@ -84,6 +84,20 @@ float3 Capsule::ExtremePoint(const float3 &direction) const
 	return (Dot(direction, l.b - l.a) >= 0.f ? l.b : l.a) + direction.ScaledToLength(r);
 }
 
+void Capsule::ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const
+{
+	outMin = Dot(direction, l.a);
+	outMax = Dot(direction, l.b);
+	if (outMax < outMin)
+		Swap(outMin, outMax);
+
+	// The following requires that direction is normalized, otherwise we would have to sub/add 'r * direction.Length()', but
+	// don't want to do that for performance reasons.
+	assume(direction.IsNormalized());
+	outMin -= r;
+	outMax += r;
+}
+
 float3 Capsule::Top() const
 {
 	return l.b + UpDirection() * r;

src/Geometry/Capsule.h

@@ -95,6 +95,15 @@ class Capsule
 		@return The extreme point of this Capsule in the given direction. */
 	float3 ExtremePoint(const float3 &direction) const;
 
+	/// Projects this Capsule onto the given 1D axis direction vector.
+	/** This function collapses this Capsule onto an 1D axis for the purposes of e.g. separate axis test computations.
+		The function returns a 1D range [outMin, outMax] denoting the interval of the projection.
+		@param direction The 1D axis to project to. This vector may be unnormalized, in which case the output
+			of this function gets scaled by the length of this vector.
+		@param outMin [out] Returns the minimum extent of this object along the projection axis.
+		@param outMax [out] Returns the maximum extent of this object along the projection axis. */
+	void ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const;
+
 	/// Returns the topmost point of this Capsule.
 	/** <img src="CapsuleFunctions.png" />
 		@note The topmost point is only a naming convention, and does not correspond to the topmost point along any world axis. The returned

src/Geometry/Frustum.cpp

@@ -508,6 +508,15 @@ float3 Frustum::ExtremePoint(const float3 &direction) const
 	return mostExtreme;
 }
 
+void Frustum::ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const
+{
+	///\todo Optimize!
+	float3 minPt = ExtremePoint(-direction);
+	float3 maxPt = ExtremePoint(direction);
+	outMin = Dot(minPt, direction);
+	outMax = Dot(maxPt, direction);
+}
+
 AABB Frustum::MinimalEnclosingAABB() const
 {
 	AABB aabb;

src/Geometry/Frustum.h

@@ -173,6 +173,15 @@ class Frustum
 		@see CornerPoint(). */
 	float3 ExtremePoint(const float3 &direction) const;
 
+	/// Projects this Frustum onto the given 1D axis direction vector.
+	/** This function collapses this Frustum onto an 1D axis for the purposes of e.g. separate axis test computations.
+		The function returns a 1D range [outMin, outMax] denoting the interval of the projection.
+		@param direction The 1D axis to project to. This vector may be unnormalized, in which case the output
+			of this function gets scaled by the length of this vector.
+		@param outMin [out] Returns the minimum extent of this object along the projection axis.
+		@param outMax [out] Returns the maximum extent of this object along the projection axis. */
+	void ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const;
+
 	/// Sets the pos, front and up members of this frustum from the given world transform.
 	/** This function sets the 'front' parameter of this Frustum to look towards the -Z axis of the given matrix, 
 		and the 'up' parameter of this Frustum to point towards the +Y axis of the given matrix.

src/Geometry/Line.cpp

@@ -321,6 +321,20 @@ LineSegment Line::ToLineSegment(float d) const
 	return LineSegment(pos, GetPoint(d));
 }
 
+void Line::ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const
+{
+	// Most of the time, the projection of a line spans the whole 1D axis.
+	// As a special case, if the line is perpendicular to the direction vector in question,
+	// then the projection interval of this line is a single point.
+	if (dir.IsPerpendicular(direction))
+		outMin = outMax = Dot(direction, pos);
+	else
+	{
+		outMin = -FLOAT_INF;
+		outMax = FLOAT_INF;
+	}
+}
+
 LineSegment Line::ToLineSegment(float dStart, float dEnd) const
 {
 	return LineSegment(GetPoint(dStart), GetPoint(dEnd));

src/Geometry/Line.h

@@ -191,6 +191,15 @@ class Line
 		@see pos, dir, Line::Line, class LineSegment, ToLine(). */
 	LineSegment ToLineSegment(float dStart, float dEnd) const;
 
+	/// Projects this Line onto the given 1D axis direction vector.
+	/** This function collapses this Line onto an 1D axis for the purposes of e.g. separate axis test computations.
+		The function returns a 1D range [outMin, outMax] denoting the interval of the projection.
+		@param direction The 1D axis to project to. This vector may be unnormalized, in which case the output
+			of this function gets scaled by the length of this vector.
+		@param outMin [out] Returns the minimum extent of this object along the projection axis.
+		@param outMax [out] Returns the maximum extent of this object along the projection axis. */
+	void ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const;
+
 	/// Tests if the given three points are collinear.
 	/** This function tests whether the given three functions all lie on the same line.
 		@param epsilon The comparison threshold to use to account for floating-point inaccuracies. */

src/Geometry/LineSegment.cpp

@@ -333,6 +333,14 @@ Line LineSegment::ToLine() const
 	return Line(a, Dir());
 }
 
+void LineSegment::ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const
+{
+	outMin = Dot(direction, a);
+	outMax = Dot(direction, b);
+	if (outMax < outMin)
+		Swap(outMin, outMax);
+}
+
 LineSegment operator *(const float3x3 &transform, const LineSegment &l)
 {
 	return LineSegment(transform * l.a, transform * l.b);

src/Geometry/LineSegment.h

@@ -207,6 +207,15 @@ class LineSegment
 		@see class Line, ToRay(). */
 	Line ToLine() const;
 
+	/// Projects this LineSegment onto the given 1D axis direction vector.
+	/** This function collapses this LineSegment onto an 1D axis for the purposes of e.g. separate axis test computations.
+		The function returns a 1D range [outMin, outMax] denoting the interval of the projection.
+		@param direction The 1D axis to project to. This vector may be unnormalized, in which case the output
+			of this function gets scaled by the length of this vector.
+		@param outMin [out] Returns the minimum extent of this object along the projection axis.
+		@param outMax [out] Returns the maximum extent of this object along the projection axis. */
+	void ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const;
+
 #ifdef MATH_ENABLE_STL_SUPPORT
 	/// Returns a human-readable representation of this LineSegment. Most useful for debugging purposes.
 	std::string ToString() const;

src/Geometry/OBB.cpp

@@ -297,6 +297,16 @@ float3 OBB::ExtremePoint(const float3 &direction) const
 	return pt;
 }
 
+void OBB::ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const
+{
+	float x = Abs(Dot(direction, axis[0]) * r.x);
+	float y = Abs(Dot(direction, axis[1]) * r.y);
+	float z = Abs(Dot(direction, axis[2]) * r.z);
+	float pt = Dot(direction, pos);
+	outMin = pt - x - y - z;
+	outMax = pt + x + y + z;
+}
+
 float3 OBB::PointOnEdge(int edgeIndex, float u) const
 {
 	assume(0 <= edgeIndex && edgeIndex <= 11);

src/Geometry/OBB.h

@@ -234,6 +234,15 @@ class OBB
 		@see CornerPoint(). */
 	float3 ExtremePoint(const float3 &direction) const;
 
+	/// Projects this OBB onto the given 1D axis direction vector.
+	/** This function collapses this OBB onto an 1D axis for the purposes of e.g. separate axis test computations.
+		The function returns a 1D range [outMin, outMax] denoting the interval of the projection.
+		@param direction The 1D axis to project to. This vector may be unnormalized, in which case the output
+			of this function gets scaled by the length of this vector.
+		@param outMin [out] Returns the minimum extent of this object along the projection axis.
+		@param outMax [out] Returns the maximum extent of this object along the projection axis. */
+	void ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const;
+
 	/// Returns a point on an edge of this OBB.
 	/** @param edgeIndex The index of the edge to generate a point to, in the range [0, 11]. @todo Document which index generates which one.
 		@param u A normalized value between [0,1]. This specifies the relative distance of the point along the edge.

src/Geometry/Polygon.cpp

@@ -566,6 +566,15 @@ float3 Polygon::ExtremePoint(const float3 &direction) const
 	return mostExtreme;
 }
 
+void Polygon::ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const
+{
+	///\todo Optimize!
+	float3 minPt = ExtremePoint(-direction);
+	float3 maxPt = ExtremePoint(direction);
+	outMin = Dot(minPt, direction);
+	outMax = Dot(maxPt, direction);
+}
+
 /*
 /// Returns true if the edges of this polygon self-intersect.
 bool IsSelfIntersecting() const;

src/Geometry/Polygon.h

@@ -97,6 +97,15 @@ class Polygon
 		@see Vertex(). */
 	float3 ExtremePoint(const float3 &direction) const;
 
+	/// Projects this Polygon onto the given 1D axis direction vector.
+	/** This function collapses this Polygon onto an 1D axis for the purposes of e.g. separate axis test computations.
+		The function returns a 1D range [outMin, outMax] denoting the interval of the projection.
+		@param direction The 1D axis to project to. This vector may be unnormalized, in which case the output
+			of this function gets scaled by the length of this vector.
+		@param outMin [out] Returns the minimum extent of this object along the projection axis.
+		@param outMax [out] Returns the maximum extent of this object along the projection axis. */
+	void ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const;
+
 	/// Tests if the given diagonal exists.
 	/** This function tests whether the diagonal that joins the two given vertices lies inside this polygon and is not intersected
 		by the edges of this polygon.

src/Geometry/Polyhedron.cpp

@@ -191,6 +191,15 @@ float3 Polyhedron::ExtremePoint(const float3 &direction) const
 	return Vertex(ExtremeVertex(direction));
 }
 
+void Polyhedron::ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const
+{
+	///\todo Optimize!
+	float3 minPt = ExtremePoint(-direction);
+	float3 maxPt = ExtremePoint(direction);
+	outMin = Dot(minPt, direction);
+	outMax = Dot(maxPt, direction);
+}
+
 float3 Polyhedron::Centroid() const
 {
 	float3 centroid = float3::zero;

src/Geometry/Polyhedron.h

@@ -144,6 +144,15 @@ class Polyhedron
 		@see CornerPoint(). */
 	float3 ExtremePoint(const float3 &direction) const;
 
+	/// Projects this Polyhedron onto the given 1D axis direction vector.
+	/** This function collapses this Polyhedron onto an 1D axis for the purposes of e.g. separate axis test computations.
+		The function returns a 1D range [outMin, outMax] denoting the interval of the projection.
+		@param direction The 1D axis to project to. This vector may be unnormalized, in which case the output
+			of this function gets scaled by the length of this vector.
+		@param outMin [out] Returns the minimum extent of this object along the projection axis.
+		@param outMax [out] Returns the maximum extent of this object along the projection axis. */
+	void ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const;
+
 	/// Returns the arithmetic mean of all the corner vertices.
 	/** @bug This is not the proper centroid of the polyhedron! */
 	/** @see SurfaceArea(), Volume(). */

src/Geometry/Ray.cpp

@@ -290,6 +290,18 @@ LineSegment Ray::ToLineSegment(float dStart, float dEnd) const
 	return LineSegment(GetPoint(dStart), GetPoint(dEnd));
 }
 
+void Ray::ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const
+{
+	outMin = outMax = Dot(direction, pos);
+	float d = Dot(direction, dir);
+
+	// Most of the time, the projection interval will be a half-infinite range, extending to either -inf or +inf.
+	if (d > 1e-4f)
+		outMax = FLOAT_INF;
+	else if (d < -1e4f)
+		outMin = -FLOAT_INF;
+}
+
 #ifdef MATH_ENABLE_STL_SUPPORT
 std::string Ray::ToString() const
 {

src/Geometry/Ray.h

@@ -183,6 +183,15 @@ class Ray
 		@see pos, dir, Ray::Ray, class LineSegment, ToLine(). */
 	LineSegment ToLineSegment(float d) const;
 
+	/// Projects this Ray onto the given 1D axis direction vector.
+	/** This function collapses this Ray onto an 1D axis for the purposes of e.g. separate axis test computations.
+		The function returns a 1D range [outMin, outMax] denoting the interval of the projection.
+		@param direction The 1D axis to project to. This vector may be unnormalized, in which case the output
+			of this function gets scaled by the length of this vector.
+		@param outMin [out] Returns the minimum extent of this object along the projection axis.
+		@param outMax [out] Returns the maximum extent of this object along the projection axis. */
+	void ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const;
+
 	/// Converts this Ray to a LineSegment.
 	/** @param dStart Specifies the position of the first endpoint along this Ray. This parameter may be negative,
 		in which case the starting point lies outside this Ray to the opposite direction of the Ray.

src/Geometry/Sphere.cpp

@@ -140,6 +140,13 @@ float3 Sphere::ExtremePoint(const float3 &direction) const
 	return pos + direction.ScaledToLength(r);
 }
 
+void Sphere::ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const
+{
+	float d = Dot(direction, pos);
+	outMin = d - r;
+	outMax = d + r;
+}
+
 bool Sphere::IsFinite() const
 {
 	return pos.IsFinite() && isfinite(r);

src/Geometry/Sphere.h

@@ -112,6 +112,15 @@ class Sphere
 		@return The extreme point of this Sphere in the given direction. */
 	float3 ExtremePoint(const float3 &direction) const;
 
+	/// Projects this Sphere onto the given 1D axis direction vector.
+	/** This function collapses this Sphere onto an 1D axis for the purposes of e.g. separate axis test computations.
+		The function returns a 1D range [outMin, outMax] denoting the interval of the projection.
+		@param direction The 1D axis to project to. This vector may be unnormalized, in which case the output
+			of this function gets scaled by the length of this vector.
+		@param outMin [out] Returns the minimum extent of this object along the projection axis.
+		@param outMax [out] Returns the maximum extent of this object along the projection axis. */
+	void ProjectToAxis(const float3 &direction, float &outMin, float &outMax) const;
+
 	/// Tests if this Sphere is finite.
 	/** A sphere is <b><i>finite</i></b> if its members pos and r do not contain floating-point NaNs or +/-infs
 		in them.