G3D::Ray Class Reference

#include <Ray.h>

Public Member Functions
void	set (const Point3 &origin, const Vector3 &direction)
const Point3 &	origin () const
const Vector3 &	direction () const
const Vector3 &	invDirection () const
	Ray ()
	Ray (const Point3 &origin, const Vector3 &direction)
	Ray (class BinaryInput &b)
void	serialize (class BinaryOutput &b) const
void	deserialize (class BinaryInput &b)
Ray	bumpedRay (float distance) const
Ray	bumpedRay (float distance, const Vector3 &bumpDirection) const
Point3	closestPoint (const Point3 &point) const
	Returns the closest point on the Ray to point. More...
float	distance (const Point3 &point) const
Point3	intersection (const class Plane &plane) const
float	intersectionTime (const class Sphere &sphere, bool solid=false) const
float	intersectionTime (const class Plane &plane) const
float	intersectionTime (const class Box &box) const
float	intersectionTime (const class AABox &box) const
float	intersectionTime (const Vector3 &v0, const Vector3 &v1, const Vector3 &v2, const Vector3 &edge01, const Vector3 &edge02, float &w0, float &w1, float &w2) const
float	intersectionTime (const Point3 &vert0, const Point3 &vert1, const Point3 &vert2, const Vector3 &edge01, const Vector3 &edge02) const
float	intersectionTime (const Point3 &vert0, const Point3 &vert1, const Point3 &vert2) const
float	intersectionTime (const Point3 &vert0, const Point3 &vert1, const Point3 &vert2, float &w0, float &w1, float &w2) const
float	intersectionTime (const Triangle &triangle) const
float	intersectionTime (const Triangle &triangle, float &w0, float &w1, float &w2) const
Ray	refract (const Vector3 &newOrigin, const Vector3 &normal, float iInside, float iOutside) const
Ray	reflect (const Vector3 &newOrigin, const Vector3 &normal) const

Static Public Member Functions
static Ray	fromOriginAndDirection (const Point3 &point, const Vector3 &direction)

Private Types
enum	Classification {   MMM, MMP, MPM, MPP,   PMM, PMP, PPM, PPP,   POO, MOO, OPO, OMO,   OOP, OOM, OMM, OMP,   OPM, OPP, MOM, MOP,   POM, POP, MMO, MPO,   PMO, PPO }

Private Attributes
Point3	m_origin
Vector3	m_direction
Vector3	m_invDirection
Classification	classification
float	ibyj
float	jbyi
float	kbyj
float	jbyk
float	ibyk
float	kbyi
float	c_xy
float	c_xz
float	c_yx
float	c_yz
float	c_zx
float	c_zy

Friends
class	Intersect

Detailed Description

A 3D Ray.

Member Enumeration Documentation

enum G3D::Ray::Classification

private

The following are for the "ray slope" optimization from "Fast Ray / Axis-Aligned Bounding Box Overlap Tests using Ray Slopes" by Martin Eisemann, Thorsten Grosch, Stefan M��ller and Marcus Magnor Computer Graphics Lab, TU Braunschweig, Germany and University of Koblenz-Landau, Germany

Enumerator
MMM
MMP
MPM
MPP
PMM
PMP
PPM
PPP
POO
MOO
OPO
OMO
OOP
OOM
OMM
OMP
OPM
OPP
MOM
MOP
POM
POP
MMO
MPO
PMO
PPO

{MMM, MMP, MPM, MPP, PMM, PMP, PPM, PPP, POO, MOO, OPO, OMO, OOP, OOM, OMM, OMP, OPM, OPP, MOM, MOP, POM, POP, MMO, MPO, PMO, PPO}; 

Constructor & Destructor Documentation

G3D::Ray::Ray ( )

inline

 {
 set(Point3::zero(), Vector3::unitX());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G3D::Ray::Ray ( const Point3 &  origin, const Vector3 &  direction  )

inline

Parameters

direction

Assumed to have unit length

 {
 set(origin, direction);
 }

Here is the call graph for this function:

G3D::Ray::Ray

(

class BinaryInput &

b

)

 {
 deserialize(b);
}

Here is the call graph for this function:

Member Function Documentation

Ray G3D::Ray::bumpedRay ( float  distance ) const

inline

Returns a new ray which has the same direction but an origin advanced along direction by distance

 {
 return Ray(m_origin + m_direction * distance, m_direction);
 }

Here is the call graph for this function:

Ray G3D::Ray::bumpedRay ( float  distance, const Vector3 &  bumpDirection  ) const

inline

Returns a new ray which has the same direction but an origin advanced by distance * bumpDirection

 {
 return Ray(m_origin + bumpDirection * distance, m_direction);
 }

Here is the call graph for this function:

Point3 G3D::Ray::closestPoint ( const Point3 &  point ) const

inline

Returns the closest point on the Ray to point.

 {
 float t = m_direction.dot(point - m_origin);
 if (t < 0) {
 return m_origin;
 } else {
 return m_origin + m_direction * t;
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Ray::deserialize

(

class BinaryInput &

b

)

 {
 m_origin.deserialize(b);
 m_direction.deserialize(b);
 set(m_origin, m_direction);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Vector3& G3D::Ray::direction ( ) const

inline

Unit direction vector.

 {
 return m_direction;
 }

Here is the caller graph for this function:

float G3D::Ray::distance ( const Point3 &  point ) const

inline

Returns the closest distance between point and the Ray

 {
 return (closestPoint(point) - point).magnitude();
 }

Here is the call graph for this function:

static Ray G3D::Ray::fromOriginAndDirection ( const Point3 &  point, const Vector3 &  direction  )

inlinestatic

Creates a Ray from a origin and a (nonzero) unit direction.

 {
 return Ray(point, direction);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Ray::intersection

(

const class Plane &

plane

)

const

Returns the point where the Ray and plane intersect. If there is no intersection, returns a point at infinity.

Planes are considered one-sided, so the ray will not intersect a plane where the normal faces in the traveling direction.

 {
 float d;
 Vector3 normal = plane.normal();
 plane.getEquation(normal, d);
 float rate = m_direction.dot(normal);

 if (rate >= 0.0f) {
 return Vector3::inf();
 } else {
 float t = -(d + m_origin.dot(normal)) / rate;
 return m_origin + m_direction * t;
 }
}

Here is the call graph for this function:

float G3D::Ray::intersectionTime	(	const class Sphere &	sphere,
		bool	solid = false
	)		const

Returns the distance until intersection with the sphere or the (solid) ball bounded by the sphere. Will be 0 if inside the sphere, inf if there is no intersection.

The ray direction is not normalized. If the ray direction has unit length, the distance from the origin to intersection is equal to the time. If the direction does not have unit length, the distance = time * direction.length().

See also the G3D::CollisionDetection "movingPoint" methods, which give more information about the intersection.

Parameters

solid

If true, rays inside the sphere immediately intersect (good for collision detection). If false, they hit the opposite side of the sphere (good for ray tracing).

 {
 Vector3 dummy;
 return CollisionDetection::collisionTimeForMovingPointFixedSphere(
 m_origin, m_direction, sphere, dummy, dummy, solid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Ray::intersectionTime

(

const class Plane &

plane

)

const

 {
 Vector3 dummy;
 return CollisionDetection::collisionTimeForMovingPointFixedPlane(
 m_origin, m_direction, plane, dummy);
}

Here is the call graph for this function:

float G3D::Ray::intersectionTime

(

const class Box &

box

)

const

 {
 Vector3 dummy;
 float time = CollisionDetection::collisionTimeForMovingPointFixedBox(
 m_origin, m_direction, box, dummy);

 if ((time == finf()) && (box.contains(m_origin))) {
 return 0.0f;
 } else {
 return time;
 }
}

Here is the call graph for this function:

float G3D::Ray::intersectionTime

(

const class AABox &

box

)

const

 {
 Vector3 dummy;
 bool inside;
 float time = CollisionDetection::collisionTimeForMovingPointFixedAABox(
 m_origin, m_direction, box, dummy, inside);

 if ((time == finf()) && inside) {
 return 0.0f;
 } else {
 return time;
 }
}

Here is the call graph for this function:

float G3D::Ray::intersectionTime ( const Vector3 &  v0, const Vector3 &  v1, const Vector3 &  v2, const Vector3 &  edge01, const Vector3 &  edge02, float &  w0, float &  w1, float &  w2  ) const

inline

The three extra arguments are the weights of vertices 0, 1, and 2 at the intersection point; they are useful for texture mapping and interpolated normals.

 {

 (void)vert1;
 (void)vert2;

 // Barycenteric coords
 float u, v;

 float tvec[3], pvec[3], qvec[3];

 // begin calculating determinant - also used to calculate U parameter
 CROSS(pvec, m_direction, edge2);
 
 // if determinant is near zero, ray lies in plane of triangle
 const float det = DOT(edge1, pvec);
 
 if (det < EPSILON) {
 return finf();
 }
 
 // calculate distance from vert0 to ray origin
 SUB(tvec, m_origin, vert0);
 
 // calculate U parameter and test bounds
 u = DOT(tvec, pvec);
 if ((u < 0.0f) || (u > det)) {
 // Hit the plane outside the triangle
 return finf();
 }
 
 // prepare to test V parameter
 CROSS(qvec, tvec, edge1);
 
 // calculate V parameter and test bounds
 v = DOT(m_direction, qvec);
 if ((v < 0.0f) || (u + v > det)) {
 // Hit the plane outside the triangle
 return finf();
 }
 
 float t = DOT(edge2, qvec);
 
 if (t >= 0) {
 const float inv_det = 1.0f / det;
 t *= inv_det;
 u *= inv_det;
 v *= inv_det;

 w0 = (1.0f - u - v);
 w1 = u;
 w2 = v;

 return t;
 } else {
 // We had to travel backwards in time to intersect
 return finf();
 }
}

Here is the call graph for this function:

float G3D::Ray::intersectionTime ( const Point3 &  vert0, const Point3 &  vert1, const Point3 &  vert2, const Vector3 &  edge01, const Vector3 &  edge02  ) const

inline

Ray-triangle intersection for a 1-sided triangle. Fastest version. [http://www.acm.org/jgt/papers/MollerTrumbore97/] http://www.graphics.cornell.edu/pubs/1997/MT97.html

 {

 (void)vert1;
 (void)vert2;

 // Barycenteric coords
 float u, v;

 float tvec[3], pvec[3], qvec[3];
 
 // begin calculating determinant - also used to calculate U parameter
 CROSS(pvec, m_direction, edge2);
 
 // if determinant is near zero, ray lies in plane of triangle
 const float det = DOT(edge1, pvec);
 
 if (det < EPSILON) {
 return finf();
 }
 
 // calculate distance from vert0 to ray origin
 SUB(tvec, m_origin, vert0);
 
 // calculate U parameter and test bounds
 u = DOT(tvec, pvec);
 if ((u < 0.0f) || (u > det)) {
 // Hit the plane outside the triangle
 return finf();
 }
 
 // prepare to test V parameter
 CROSS(qvec, tvec, edge1);
 
 // calculate V parameter and test bounds
 v = DOT(m_direction, qvec);
 if ((v < 0.0f) || (u + v > det)) {
 // Hit the plane outside the triangle
 return finf();
 }
 

 // Case where we don't need correct (u, v):
 const float t = DOT(edge2, qvec);
 
 if (t >= 0.0f) {
 // Note that det must be positive
 return t / det;
 } else {
 // We had to travel backwards in time to intersect
 return finf();
 }
}

Here is the call graph for this function:

float G3D::Ray::intersectionTime ( const Point3 &  vert0, const Point3 &  vert1, const Point3 &  vert2  ) const

inline

 {

 return intersectionTime(vert0, vert1, vert2, vert1 - vert0, vert2 - vert0);
 }

Here is the call graph for this function:

float G3D::Ray::intersectionTime ( const Point3 &  vert0, const Point3 &  vert1, const Point3 &  vert2, float &  w0, float &  w1, float &  w2  ) const

inline

 {

 return intersectionTime(vert0, vert1, vert2, vert1 - vert0, vert2 - vert0, w0, w1, w2);
 }

Here is the call graph for this function:

float G3D::Ray::intersectionTime ( const Triangle &  triangle ) const

inline

 {
 return intersectionTime(
 triangle.vertex(0), triangle.vertex(1), triangle.vertex(2),
 triangle.edge01(), triangle.edge02());
 }

Here is the call graph for this function:

float G3D::Ray::intersectionTime ( const Triangle &  triangle, float &  w0, float &  w1, float &  w2  ) const

inline

 {
 return intersectionTime(triangle.vertex(0), triangle.vertex(1), triangle.vertex(2),
 triangle.edge01(), triangle.edge02(), w0, w1, w2);
 }

Here is the call graph for this function:

const Vector3& G3D::Ray::invDirection ( ) const

inline

Component-wise inverse of direction vector. May have inf() components

 {
 return m_invDirection;
 }

Here is the caller graph for this function:

const Point3& G3D::Ray::origin ( ) const

inline

 {
 return m_origin;
 }

Here is the caller graph for this function:

Ray G3D::Ray::reflect	(	const Vector3 &	newOrigin,
		const Vector3 &	normal
	)		const

Reflects about the normal using G3D::Vector3::reflectionDirection and bumps the ray slightly from the newOrigin.

 {

 Vector3 D = m_direction.reflectionDirection(normal);
 return Ray(newOrigin + (D + normal) * 0.001f, D);
}

Here is the call graph for this function:

Ray G3D::Ray::refract	(	const Vector3 &	newOrigin,
		const Vector3 &	normal,
		float	iInside,
		float	iOutside
	)		const

Refracts about the normal using G3D::Vector3::refractionDirection and bumps the ray slightly from the newOrigin.

 {

 Vector3 D = m_direction.refractionDirection(normal, iInside, iOutside);
 return Ray(newOrigin + (m_direction + normal * (float)sign(m_direction.dot(normal))) * 0.001f, D);
}

Here is the call graph for this function:

void G3D::Ray::serialize

(

class BinaryOutput &

b

)

const

 {
 m_origin.serialize(b);
 m_direction.serialize(b);
}

Here is the call graph for this function:

void G3D::Ray::set	(	const Point3 &	origin,
		const Vector3 &	direction
	)

Parameters

direction

Assumed to have unit length

 {
 m_origin = origin;
 m_direction = direction;
 debugAssert(direction.isUnit());
 
 m_invDirection = Vector3::one() / direction;
 
 // ray slope
 ibyj = m_direction.x * m_invDirection.y;
 jbyi = m_direction.y * m_invDirection.x;
 jbyk = m_direction.y * m_invDirection.z;
 kbyj = m_direction.z * m_invDirection.y;
 ibyk = m_direction.x * m_invDirection.z;
 kbyi = m_direction.z * m_invDirection.x;
 
 // precomputed terms
 c_xy = m_origin.y - jbyi * m_origin.x;
 c_xz = m_origin.z - kbyi * m_origin.x;
 c_yx = m_origin.x - ibyj * m_origin.y;
 c_yz = m_origin.z - kbyj * m_origin.y;
 c_zx = m_origin.x - ibyk * m_origin.z;
 c_zy = m_origin.y - jbyk * m_origin.z; 
 
 //ray slope classification
 if (m_direction.x < 0) {
 if (m_direction.y < 0) {
 if (m_direction.z < 0) {
 classification = MMM;
 } else if (m_direction.z > 0) {
 classification = MMP;
 } else { //(m_direction.z >= 0)
 classification = MMO;
 }
 } else { //(m_direction.y >= 0)
 if (m_direction.z < 0) {
 if (m_direction.y == 0) {
 classification = MOM;
 } else {
 classification = MPM;
 }
 } else { //(m_direction.z >= 0)
 if ((m_direction.y == 0) && (m_direction.z == 0)) {
 classification = MOO;
 } else if (m_direction.z == 0) {
 classification = MPO;
 } else if (m_direction.y == 0) {
 classification = MOP;
 } else {
 classification = MPP;
 }
 }
 }
 } else { //(m_direction.x >= 0)
 if (m_direction.y < 0) {
 if (m_direction.z < 0) {
 if (m_direction.x == 0) {
 classification = OMM;
 } else {
 classification = PMM;
 }
 } else { //(m_direction.z >= 0)
 if ((m_direction.x == 0) && (m_direction.z == 0)) {
 classification = OMO;
 } else if (m_direction.z == 0) {
 classification = PMO;
 } else if (m_direction.x == 0) {
 classification = OMP;
 } else {
 classification = PMP;
 }
 }
 } else { //(m_direction.y >= 0)
 if (m_direction.z < 0) {
 if ((m_direction.x == 0) && (m_direction.y == 0)) {
 classification = OOM;
 } else if (m_direction.x == 0) {
 classification = OPM;
 } else if (m_direction.y == 0) {
 classification = POM;
 } else {
 classification = PPM;
 }
 } else { //(m_direction.z > 0)
 if (m_direction.x == 0) {
 if (m_direction.y == 0) {
 classification = OOP;
 } else if (m_direction.z == 0) {
 classification = OPO;
 } else {
 classification = OPP;
 }
 } else {
 if ((m_direction.y == 0) && (m_direction.z == 0)) {
 classification = POO;
 } else if (m_direction.y == 0) {
 classification = POP;
 } else if (m_direction.z == 0) {
 classification = PPO;
 } else {
 classification = PPP;
 }
 }
 } 
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class Intersect

friend

Member Data Documentation

float G3D::Ray::c_xy

private

Precomputed components

float G3D::Ray::c_xz

private

float G3D::Ray::c_yx

private

float G3D::Ray::c_yz

private

float G3D::Ray::c_zx

private

float G3D::Ray::c_zy

private

Classification G3D::Ray::classification

private

float G3D::Ray::ibyj

private

ray slope

float G3D::Ray::ibyk

private

float G3D::Ray::jbyi

private

float G3D::Ray::jbyk

private

float G3D::Ray::kbyi

private

float G3D::Ray::kbyj

private

Vector3 G3D::Ray::m_direction

private

Unit length

Vector3 G3D::Ray::m_invDirection

private

1.0 / direction

Point3 G3D::Ray::m_origin

private

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/Ray.h
• dep/g3dlite/source/Ray.cpp