The GtkRadiant sources as originally released under the GPL license.

libs/math/line.h

@@ -0,0 +1,151 @@
+/*
+Copyright (C) 2001-2006, William Joseph.
+All Rights Reserved.
+
+This file is part of GtkRadiant.
+
+GtkRadiant is free software; you can redistribute it and/or modify
+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.
+
+GtkRadiant 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 GtkRadiant; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#if !defined(INCLUDED_MATH_LINE_H)
+#define INCLUDED_MATH_LINE_H
+
+/// \file
+/// \brief Line data types and related operations.
+
+#include "math/vector.h"
+#include "math/plane.h"
+
+/// \brief A line segment defined by a start point and and end point.
+class Line
+{
+public:
+  Vector3 start, end;
+
+  Line()
+  {
+  }
+  Line(const Vector3& start_, const Vector3& end_) : start(start_), end(end_)
+  {
+  }
+};
+
+inline Vector3 line_closest_point(const Line& line, const Vector3& point)
+{
+  Vector3 v = line.end - line.start;
+  Vector3 w = point - line.start;
+
+  double c1 = vector3_dot(w,v);
+  if ( c1 <= 0 )
+    return line.start;
+
+  double c2 = vector3_dot(v,v);
+  if ( c2 <= c1 )
+    return line.end;
+
+  return Vector3(line.start + v * (c1 / c2));
+}
+
+
+class Segment
+{
+public:
+  Vector3 origin, extents;
+
+  Segment()
+  {
+  }
+  Segment(const Vector3& origin_, const Vector3& extents_) :
+    origin(origin_), extents(extents_)
+  {
+  }
+};
+
+
+inline Segment segment_for_startend(const Vector3& start, const Vector3& end)
+{
+  Segment segment;
+  segment.origin = vector3_mid(start, end);
+  segment.extents = vector3_subtracted(end, segment.origin);
+  return segment;
+}
+
+inline unsigned int segment_classify_plane(const Segment& segment, const Plane3& plane)
+{
+  double distance_origin = vector3_dot(plane.normal(), segment.origin) + plane.dist();
+  
+  if (fabs(distance_origin) < fabs(vector3_dot(plane.normal(), segment.extents)))
+  {
+    return 1; // partially inside
+  }
+  else if (distance_origin < 0)
+  {
+    return 2; // totally inside
+  }
+  return 0; // totally outside
+}
+
+
+class Ray
+{
+public:
+  Vector3 origin, direction;
+
+  Ray()
+  {
+  }
+  Ray(const Vector3& origin_, const Vector3& direction_) :
+    origin(origin_), direction(direction_)
+  {
+  }
+};
+
+inline Ray ray_for_points(const Vector3& origin, const Vector3& p2)
+{
+  return Ray(origin, vector3_normalised(vector3_subtracted(p2, origin)));
+}
+
+inline void ray_transform(Ray& ray, const Matrix4& matrix)
+{
+  matrix4_transform_point(matrix, ray.origin);
+  matrix4_transform_direction(matrix, ray.direction);
+}
+
+// closest-point-on-line
+inline double ray_squared_distance_to_point(const Ray& ray, const Vector3& point)
+{
+  return vector3_length_squared(
+    vector3_subtracted(
+      point,
+      vector3_added(
+        ray.origin,
+        vector3_scaled(
+          ray.direction,
+          vector3_dot(
+            vector3_subtracted(point, ray.origin),
+            ray.direction
+          )
+        )
+      )
+    )
+  );
+}
+
+inline double ray_distance_to_plane(const Ray& ray, const Plane3& plane)
+{
+  return -(vector3_dot(plane.normal(), ray.origin) - plane.dist()) / vector3_dot(ray.direction, plane.normal());
+}
+
+#endif