#include <ray.h>

Public Member Functions
	RAYSEG2D (const SFVEC2F &s, const SFVEC2F &e)

bool	IntersectSegment (const SFVEC2F &aStart, const SFVEC2F &aEnd_minus_start, float *aOutT) const

bool	IntersectCircle (const SFVEC2F &aCenter, float aRadius, float aOutT0, float aOutT1, SFVEC2F aOutNormalT0, SFVEC2F aOutNormalT1) const

float	DistanceToPointSquared (const SFVEC2F &aPoint) const

SFVEC2F	atNormalized (float t) const
	Return the position at t. More...

SFVEC2F	at (float t) const

Public Attributes
SFVEC2F	m_Start

SFVEC2F	m_End

SFVEC2F	m_End_minus_start

SFVEC2F	m_Dir

SFVEC2F	m_InvDir

float	m_Length

float	m_DOT_End_minus_start
	dot( m_End_minus_start, m_End_minus_start) More...

Detailed Description

Definition at line 110 of file ray.h.

Constructor & Destructor Documentation

◆ RAYSEG2D()

RAYSEG2D::RAYSEG2D	(	const SFVEC2F &	s,
		const SFVEC2F &	e
	)

Definition at line 249 of file ray.cpp.

 {
     m_Start = s;
     m_End = e;
     m_End_minus_start = e - s;
     m_Length = glm::length( m_End_minus_start );
     m_Dir = glm::normalize( m_End_minus_start );
     m_InvDir = ( 1.0f / m_Dir );
 
     if( fabs( m_Dir.x ) < FLT_EPSILON )
         m_InvDir.x = NextFloatDown( FLT_MAX );
 
     if( fabs( m_Dir.y ) < FLT_EPSILON )
         m_InvDir.y = NextFloatDown( FLT_MAX );
 
     m_DOT_End_minus_start = glm::dot( m_End_minus_start, m_End_minus_start );
 }

References m_Dir, m_DOT_End_minus_start, m_End, m_End_minus_start, m_InvDir, m_Length, m_Start, and NextFloatDown().

Member Function Documentation

◆ at()

SFVEC2F RAYSEG2D::at ( float t ) const

inline

Definition at line 142 of file ray.h.

142 { return m_Start + m_Dir * t; }

RAYSEG2D::m_Dir

SFVEC2F m_Dir

Definition: ray.h:115

RAYSEG2D::m_Start

SFVEC2F m_Start

Definition: ray.h:112

References m_Dir, and m_Start.

Referenced by RING_2D::Intersect(), FILLED_CIRCLE_2D::Intersect(), and IntersectCircle().

◆ atNormalized()

SFVEC2F RAYSEG2D::atNormalized ( float t ) const

inline

Return the position at t.

t - value 0.0 ... 1.0

Definition at line 140 of file ray.h.

140 { return m_Start + m_End_minus_start * t; }

RAYSEG2D::m_Start

SFVEC2F m_Start

Definition: ray.h:112

RAYSEG2D::m_End_minus_start

SFVEC2F m_End_minus_start

Definition: ray.h:114

References m_End_minus_start, and m_Start.

Referenced by LAYER_ITEM_2D::Intersect().

◆ DistanceToPointSquared()

float RAYSEG2D::DistanceToPointSquared ( const SFVEC2F & aPoint ) const

Definition at line 300 of file ray.cpp.

 {
     SFVEC2F p = aPoint - m_Start;
 
     const float c1 = glm::dot( p, m_End_minus_start );
 
     if( c1 < FLT_EPSILON )
         return glm::dot( p, p );
 
     if( m_DOT_End_minus_start <= c1 )
     {
         p = aPoint - m_End;
     }
     else
     {
         const float b = c1 / m_DOT_End_minus_start;
         const SFVEC2F pb = m_Start + m_End_minus_start * b;
 
         p = aPoint - pb;
     }
 
     return glm::dot( p, p );
 }

References m_DOT_End_minus_start, m_End, m_End_minus_start, and m_Start.

Referenced by ROUND_SEGMENT::Intersect(), ROUND_SEGMENT::IntersectP(), and ROUND_SEGMENT_2D::IsPointInside().

◆ IntersectCircle()

bool RAYSEG2D::IntersectCircle	(	const SFVEC2F &	aCenter,
		float	aRadius,
		float *	aOutT0,
		float *	aOutT1,
		SFVEC2F *	aOutNormalT0,
		SFVEC2F *	aOutNormalT1
	)		const

Definition at line 325 of file ray.cpp.

 {
     // This code used directly from Steve Marschner's CS667 framework
     // http://cs665pd.googlecode.com/svn/trunk/photon/sphere.cpp
 
     // Compute some factors used in computation
     const float qx = m_Start.x - aCenter.x;
     const float qy = m_Start.y - aCenter.y;
 
     const float qd = qx * m_Dir.x + qy * m_Dir.y;
     const float qq = qx * qx + qy * qy;
 
     // solving the quadratic equation for t at the pts of intersection
     // dd*t^2 + (2*qd)*t + (qq-r^2) = 0
     const float discriminantsqr = (qd * qd - (qq - aRadius * aRadius));
 
     // If the discriminant is less than zero, there is no intersection
     if( discriminantsqr < FLT_EPSILON )
         return false;
 
     // Otherwise check and make sure that the intersections occur on the ray (t
     // > 0) and return the closer one
     const float discriminant = std::sqrt( discriminantsqr );
     const float t1           = ( -qd - discriminant );
     const float t2           = ( -qd + discriminant );
 
     if( ( ( t1 < 0.0f ) || ( t1 > m_Length ) ) && ( ( t2 < 0.0f ) || ( t2 > m_Length ) ) )
         return false; // Neither intersection was in the ray's half line.
 
     // Convert the intersection to a normalized
     *aOutT0 = t1 / m_Length;
     *aOutT1 = t2 / m_Length;
 
     SFVEC2F hitPointT1 = at( t1 );
     SFVEC2F hitPointT2 = at( t2 );
 
     *aOutNormalT0 = ( hitPointT1 - aCenter ) / aRadius;
     *aOutNormalT1 = ( hitPointT2 - aCenter ) / aRadius;
 
     return true;
 }

References at(), m_Dir, m_Length, and m_Start.

Referenced by ROUND_SEGMENT_2D::Intersect().

◆ IntersectSegment()

bool RAYSEG2D::IntersectSegment	(	const SFVEC2F &	aStart,
		const SFVEC2F &	aEnd_minus_start,
		float *	aOutT
	)		const

Definition at line 268 of file ray.cpp.

 {
     float rxs = m_End_minus_start.x * aEnd_minus_start.y - m_End_minus_start.y *
             aEnd_minus_start.x;
 
     if( std::abs( rxs ) >  glm::epsilon<float>() )
     {
         const float inv_rxs = 1.0f / rxs;
 
         const SFVEC2F pq = aStart - m_Start;
 
         const float t = ( pq.x * aEnd_minus_start.y - pq.y * aEnd_minus_start.x ) * inv_rxs;
 
         if( ( t < 0.0f ) || ( t > 1.0f ) )
             return false;
 
         float u = ( pq.x * m_End_minus_start.y - pq.y * m_End_minus_start.x ) * inv_rxs;
 
         if( ( u < 0.0f ) || ( u > 1.0f ) )
             return false;
 
         *aOutT = t;
 
         return true;
     }
 
     return false;
 }