gtkradiant/tools/urt/libs/math/line.h

#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