Fixed bugs in Plane and Quad mesh generation.

Renamed Quad point members to match their positons in space for easier debugging.
Fixed get_intersection(Plane, Plane, Plane) function with missing brackets. Ouch.
Added Constants file for Geometry lib to use as the Tolerance source across Intersect and individual primitive classes.

Author: MStachowicz

CMakeLists.txt

@@ -188,6 +188,7 @@ source/Geometry/Cylinder.hpp
 source/Geometry/Cylinder.cpp
 source/Geometry/Cone.hpp
 source/Geometry/Cone.cpp
+source/Geometry/Constants.hpp
 source/Geometry/Cuboid.hpp
 source/Geometry/Cuboid.cpp
 source/Geometry/Geometry.hpp

source/Geometry/Constants.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace Geometry
+{
+	// Constants
+	constexpr float TOLERANCE  = 0.0001f; // The tolerance to use when comparing floating point numbers.
+	constexpr float INF_SCALER = 1000.f;  // Scale the geometry that extends infinitely by this to give it an infinite appearance.
+}

source/Geometry/Intersect.cpp

@@ -433,7 +433,7 @@ namespace Geometry
 		if (std::abs(denom) < Epsilon)
 			return std::nullopt;
 		else
-			return plane_1.m_distance * u + glm::cross(plane_1.m_normal, plane_3.m_distance * plane_2.m_normal - plane_2.m_distance * plane_3.m_normal) / denom;
+			return (plane_1.m_distance * u + glm::cross(plane_1.m_normal, plane_3.m_distance * plane_2.m_normal - plane_2.m_distance * plane_3.m_normal)) / denom;
 	}
 	std::optional<glm::vec3> get_intersection(const Sphere& sphere_1, const Sphere& sphere_2)
 	{
@@ -584,6 +584,13 @@ namespace Geometry
 		// If sphere center within +/-radius from plane, plane intersects sphere
 		return std::abs(dist) <= sphere.m_radius;
 	}
+	bool intersecting(const Plane& plane, const glm::vec3& point, float tolerance)
+	{
+		// The point is on the plane if the dot product of the normal and the point is equal to the distance of the plane.
+		// The dot product of the normal and the point is the projection of the point onto the normal.
+		// If the projection is equal to the distance of the plane, then the point is on the plane.
+		return glm::abs(glm::dot(plane.m_normal, point) - plane.m_distance) < tolerance;
+	}
 	bool intersecting(const Sphere& sphere_1, const Sphere& sphere_2)
 	{
 		// Returns true if the spheres are intersecting.

source/Geometry/Intersect.hpp

@@ -2,6 +2,7 @@
 
 #include "Geometry/Line.hpp"
 #include "Geometry/LineSegment.hpp"
+#include "Geometry/Constants.hpp"
 #include "Utility/Logger.hpp"
 
 #include "glm/vec3.hpp"
@@ -100,12 +101,13 @@ namespace Geometry
 //==============================================================================================================================
 // intersecting functions: Return if the geometries are intersecting.
 //==============================================================================================================================
-	bool intersecting(const AABB& AABB_1, const AABB& AABB_2);
-	bool intersecting(const AABB& AABB,   const Ray& ray);
-	bool intersecting(const Line& line,   const Triangle& triangle);
-	bool intersecting(const Plane& plane_1, const Plane& plane_2);
-	bool intersecting(const Plane& plane,   const Sphere& sphere);
-	bool intersecting(const Sphere& sphere_1, const Sphere& sphere_2);
+	bool intersecting(const AABB& AABB_1,         const AABB& AABB_2);
+	bool intersecting(const AABB& AABB,           const Ray& ray);
+	bool intersecting(const Line& line,           const Triangle& triangle);
+	bool intersecting(const Plane& plane_1,       const Plane& plane_2);
+	bool intersecting(const Plane& plane,         const Sphere& sphere);
+	bool intersecting(const Plane& plane,         const glm::vec3& point, float tolerance = TOLERANCE);
+	bool intersecting(const Sphere& sphere_1,     const Sphere& sphere_2);
 	bool intersecting(const Triangle& triangle_1, const Triangle& triangle_2);
 
 } // namespace Geometry

source/Geometry/Plane.cpp

@@ -1,4 +1,5 @@
 #include "Plane.hpp"
+#include "Intersect.hpp"
 
 #include "glm/glm.hpp"
 
@@ -14,6 +15,8 @@ namespace Geometry
 		, m_distance{p_equation.w}
 	{}
 
+	bool Plane::point_on_plane(const glm::vec3 & p_point, float tolerance) const { return intersecting(*this, p_point, tolerance); }
+
 	void Plane::normalise()
 	{
 		// Normalise the plane p_equation

source/Geometry/Plane.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "Constants.hpp"
+
 #include "glm/vec3.hpp"
 #include "glm/vec4.hpp"
 
@@ -20,6 +22,10 @@ namespace Geometry
 		// Construct a plane from a plane equation.
 		//@param p_equation Equation of a plane in the form 'x + y + z + w = 0'
 		Plane(const glm::vec4& p_equation) noexcept;
+		// @param p_point The point to check if it lies on the plane.
+		// @param tolerance The tolerance to use when comparing the point to the plane.
+		// @return True if the point lies on the plane, false otherwise.
+		bool point_on_plane(const glm::vec3& p_point, const float tolerance = TOLERANCE) const;
 
 		void normalise();
 	};

source/Geometry/Quad.cpp

@@ -15,38 +15,38 @@ namespace Geometry
 		else
 			right = glm::normalize(glm::vec3(p_normal.y, -p_normal.x, 0.f));
 
-		const glm::vec3 up = glm::normalize(glm::cross(right, p_normal));
+		glm::vec3 up = -glm::cross(right, p_normal);
 
-		m_point_1 = glm::vec3(p_point + right + up);
-		m_point_2 = glm::vec3(p_point - right + up);
-		m_point_3 = glm::vec3(p_point - right - up);
-		m_point_4 = glm::vec3(p_point + right - up);
+		m_top_left     = glm::vec3(p_point - right + up);
+		m_top_right    = glm::vec3(p_point + right + up);
+		m_bottom_left  = glm::vec3(p_point - right - up);
+		m_bottom_right = glm::vec3(p_point + right - up);
 	}
 	Quad::Quad(const Plane& p_plane) noexcept
 	{
 		// Since Plane has no real position, we construct the quad at the arbitrary center-point represented by the closest point
 		// on the plane to the origin.
 		const glm::vec3 p = p_plane.m_normal * p_plane.m_distance;
-		auto quad = Quad(p, p_plane.m_normal);
-		m_point_1 = quad.m_point_1;
-		m_point_2 = quad.m_point_2;
-		m_point_3 = quad.m_point_3;
-		m_point_4 = quad.m_point_4;
+		auto quad         = Quad(p, p_plane.m_normal);
+		m_top_left        = quad.m_top_left;
+		m_top_right       = quad.m_top_right;
+		m_bottom_left     = quad.m_bottom_left;
+		m_bottom_right    = quad.m_bottom_right;
 	}
 	void Quad::transform(const glm::mat4& p_transform)
 	{
-		m_point_1 = glm::vec3(p_transform * glm::vec4(m_point_1, 1.f));
-		m_point_2 = glm::vec3(p_transform * glm::vec4(m_point_2, 1.f));
-		m_point_3 = glm::vec3(p_transform * glm::vec4(m_point_3, 1.f));
-		m_point_4 = glm::vec3(p_transform * glm::vec4(m_point_4, 1.f));
+		m_top_left     = glm::vec3(p_transform * glm::vec4(m_top_left, 1.f));
+		m_top_right    = glm::vec3(p_transform * glm::vec4(m_top_right, 1.f));
+		m_bottom_left  = glm::vec3(p_transform * glm::vec4(m_bottom_left, 1.f));
+		m_bottom_right = glm::vec3(p_transform * glm::vec4(m_bottom_right, 1.f));
 	}
 	void Quad::draw_UI() const
 	{
 		ImGui::SeparatorText("Quad");
-		ImGui::Text("Point 1", m_point_1);
-		ImGui::Text("Point 2", m_point_2);
-		ImGui::Text("Point 3", m_point_3);
-		ImGui::Text("Point 4", m_point_4);
+		ImGui::Text("Point 1", m_top_left);
+		ImGui::Text("Point 2", m_top_right);
+		ImGui::Text("Point 3", m_bottom_left);
+		ImGui::Text("Point 4", m_bottom_right);
 		ImGui::Text("Center", center());
 	}
 	Quad::Quad(const Triangle& p_triangle) noexcept
@@ -85,27 +85,27 @@ namespace Geometry
 				most_left_value = dot_left;
 		}
 
-		m_point_1 = glm::vec3(triangle_center + (right  * most_right_value) + (up  * most_up_value));
-		m_point_2 = glm::vec3(triangle_center + (-right * most_left_value)  + (up  * most_up_value));
-		m_point_3 = glm::vec3(triangle_center + (-right * most_left_value)  + (-up * most_down_value));
-		m_point_4 = glm::vec3(triangle_center + (right  * most_right_value) + (-up * most_down_value));
+		m_top_left     = glm::vec3(triangle_center + (right  * most_right_value) + (up  * most_up_value));
+		m_top_right    = glm::vec3(triangle_center + (-right * most_left_value)  + (up  * most_up_value));
+		m_bottom_left  = glm::vec3(triangle_center + (-right * most_left_value)  + (-up * most_down_value));
+		m_bottom_right = glm::vec3(triangle_center + (right  * most_right_value) + (-up * most_down_value));
 	}
 
 	glm::vec3 Quad::center() const
 	{
-		return (m_point_1 + m_point_2 + m_point_3 + m_point_4) / 4.0f;
+		return (m_top_left + m_top_right + m_bottom_left + m_bottom_right) / 4.0f;
 	}
 	void Quad::scale(const float p_scale)
 	{
 		const auto c = center();
-		m_point_1 = m_point_1 + (glm::normalize(m_point_1 - c) * p_scale);
-		m_point_2 = m_point_2 + (glm::normalize(m_point_2 - c) * p_scale);
-		m_point_3 = m_point_3 + (glm::normalize(m_point_3 - c) * p_scale);
-		m_point_4 = m_point_4 + (glm::normalize(m_point_4 - c) * p_scale);
+		m_top_left = m_top_left + (glm::normalize(m_top_left - c) * p_scale);
+		m_top_right = m_top_right + (glm::normalize(m_top_right - c) * p_scale);
+		m_bottom_left = m_bottom_left + (glm::normalize(m_bottom_left - c) * p_scale);
+		m_bottom_right = m_bottom_right + (glm::normalize(m_bottom_right - c) * p_scale);
 	}
 
 	std::array<Triangle, 2> Quad::get_triangles() const
 	{
-		return std::array<Triangle, 2>({Triangle{m_point_1, m_point_2, m_point_3}, Triangle{m_point_3, m_point_4, m_point_1}});
+		return std::array<Triangle, 2>({Triangle{m_top_left, m_top_right, m_bottom_left}, Triangle{m_bottom_left, m_bottom_right, m_top_left}});
 	}
 }

source/Geometry/Quad.hpp

@@ -14,21 +14,20 @@ namespace Geometry
 
 	// A quadrilateral. Four-sided polygon, having four edges (sides) and four corners (vertices).
 	// Quad is a 2-dimensional shape.
-	// Stored quad points are in CCW winding order.
 	class Quad
 	{
 	public:
-		glm::vec3 m_point_1;
-		glm::vec3 m_point_2;
-		glm::vec3 m_point_3;
-		glm::vec3 m_point_4;
-
-		// Construct a quad from its 4 corner points. Points expected in CCW order.
-		constexpr Quad(const glm::vec3& p_point_1, const glm::vec3& p_point_2, const glm::vec3& p_point_3, const glm::vec3& p_point_4) noexcept
-			: m_point_1{p_point_1}
-			, m_point_2{p_point_2}
-			, m_point_3{p_point_3}
-			, m_point_4{p_point_4}
+		glm::vec3 m_top_left;
+		glm::vec3 m_top_right;
+		glm::vec3 m_bottom_left;
+		glm::vec3 m_bottom_right;
+
+		// Construct a quad from its 4 corner points.
+		constexpr Quad(const glm::vec3& p_top_left, const glm::vec3& p_top_right, const glm::vec3& p_bottom_left, const glm::vec3& p_bottom_right) noexcept
+			: m_top_left{p_top_left}
+			, m_top_right{p_top_right}
+			, m_bottom_left{p_bottom_left}
+			, m_bottom_right{p_bottom_right}
 		{}
 		// Construct a unit quad at p_point facing p_normal (counter-clockwise winding).
 		Quad(const glm::vec3& p_point, const glm::vec3& p_normal) noexcept;

source/Utility/MeshBuilder.hpp

@@ -296,11 +296,10 @@ namespace Utility
 		void add_quad(const glm::vec3& top_left, const glm::vec3& top_right, const glm::vec3& bottom_left, const glm::vec3& bottom_right)
 		{
 			add_quad_impl(top_left, top_right, bottom_left, bottom_right);
-
 		}
 		void add_quad(const Geometry::Quad& quad)
 		{
-			add_quad(quad.m_point_1, quad.m_point_2, quad.m_point_3, quad.m_point_4);
+			add_quad(quad.m_top_left, quad.m_top_right, quad.m_bottom_left, quad.m_bottom_right);
 		}
 		void add_cone(const glm::vec3& base, const glm::vec3& top, float radius, size_t segments = 16)
 		{