G3D::Triangle Class Reference

#include <Triangle.h>

Public Member Functions
	Triangle (class BinaryInput &b)
void	serialize (class BinaryOutput &b)
void	deserialize (class BinaryInput &b)
	Triangle ()
	Triangle (const Point3 &v0, const Point3 &v1, const Point3 &v2)
	~Triangle ()
const Point3 &	vertex (int n) const
const Vector3 &	edge01 () const
const Vector3 &	edge02 () const
float	area () const
Vector3::Axis	primaryAxis () const
const Vector3 &	normal () const
Point3	center () const
const Plane &	plane () const
Point3	randomPoint () const
void	getRandomSurfacePoint (Point3 &P, Vector3 &N=Vector3::ignore()) const
bool	operator== (const Triangle &other) const
size_t	hashCode () const
void	getBounds (class AABox &) const
bool	intersect (const class Ray &ray, float &distance, float baryCoord[3]) const
	Intersect the ray at distance less than distance. More...

Private Member Functions
void	init (const Vector3 &v0, const Vector3 &v1, const Vector3 &v2)

Private Attributes
Vector3	_vertex [3]
Vector3	edgeDirection [3]
float	edgeMagnitude [3]
Plane	_plane
Vector3::Axis	_primaryAxis
Vector3	_edge01
Vector3	_edge02
float	_area

Friends
class	CollisionDetection
class	Ray

Detailed Description

A generic triangle representation. This should not be used as the underlying triangle for creating models; it is intended for providing fast property queries but requires a lot of storage and is mostly immutable.

Constructor & Destructor Documentation

G3D::Triangle::Triangle

(

class BinaryInput &

b

)

 {
 deserialize(b);
}

Here is the call graph for this function:

G3D::Triangle::Triangle

(

)

 {
 init(Vector3::zero(), Vector3::zero(), Vector3::zero());
}

Here is the call graph for this function:

G3D::Triangle::Triangle	(	const Point3 &	v0,
		const Point3 &	v1,
		const Point3 &	v2
	)

 {
 init(v0, v1, v2);
}

Here is the call graph for this function:

G3D::Triangle::~Triangle

(

)

 {
}

Member Function Documentation

float G3D::Triangle::area

(

)

const

 {
 return _area;
}

Vector3 G3D::Triangle::center

(

)

const

Barycenter

 {
 return (_vertex[0] + _vertex[1] + _vertex[2]) / 3.0;
}

void G3D::Triangle::deserialize

(

class BinaryInput &

b

)

 {
 _vertex[0].deserialize(b);
 _vertex[1].deserialize(b);
 _vertex[2].deserialize(b);
 init(_vertex[0], _vertex[1], _vertex[2]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Vector3& G3D::Triangle::edge01 ( ) const

inline

vertex[1] - vertex[0]

 {
 return _edge01;
 }

Here is the caller graph for this function:

const Vector3& G3D::Triangle::edge02 ( ) const

inline

vertex[2] - vertex[0]

 {
 return _edge02;
 }

Here is the caller graph for this function:

void G3D::Triangle::getBounds

(

class AABox &

out

)

const

 {
 Vector3 lo = _vertex[0];
 Vector3 hi = lo;

 for (int i = 1; i < 3; ++i) {
 lo = lo.min(_vertex[i]);
 hi = hi.max(_vertex[i]);
 }

 out = AABox(lo, hi);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Triangle::getRandomSurfacePoint ( Point3 &  P, Vector3 &  N = Vector3::ignore()  ) const

inline

 {
 P = randomPoint();
 N = normal();
 }

Here is the call graph for this function:

size_t G3D::Triangle::hashCode ( ) const

inline

 {
 return
 _vertex[0].hashCode() +
 (_vertex[1].hashCode() >> 2) +
 (_vertex[2].hashCode() >> 3);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Triangle::init ( const Vector3 &  v0, const Vector3 &  v1, const Vector3 &  v2  )

private

 {

 _plane = Plane(v0, v1, v2);
 _vertex[0] = v0;
 _vertex[1] = v1;
 _vertex[2] = v2;

 static int next[] = {1,2,0};

 for (int i = 0; i < 3; ++i) {
 const Vector3& e = _vertex[next[i]] - _vertex[i];
 edgeMagnitude[i] = e.magnitude();

 if (edgeMagnitude[i] == 0) {
 edgeDirection[i] = Vector3::zero();
 } else {
 edgeDirection[i] = e / (float)edgeMagnitude[i];
 }
 }

 _edge01 = _vertex[1] - _vertex[0];
 _edge02 = _vertex[2] - _vertex[0];

 _primaryAxis = _plane.normal().primaryAxis();
 _area = 0.5f * edgeDirection[0].cross(edgeDirection[2]).magnitude() * (edgeMagnitude[0] * edgeMagnitude[2]);
 //0.5f * (_vertex[1] - _vertex[0]).cross(_vertex[2] - _vertex[0]).dot(_plane.normal());
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Triangle::intersect	(	const class Ray &	ray,
		float &	distance,
		float	baryCoord[3]
	)		const

Intersect the ray at distance less than distance.

Parameters

distance	Set to the maximum distance (can be G3D::inf()) to search for an intersection. On return, this is the smaller of the distance to the intersection, if one exists, and the original value.
baryCoord	If a triangle is hit before distance, a the barycentric coordinates of the hit location on the triangle. Otherwise, unmodified.

Returns

True if there was an intersection before the original distance.

 {
 static const float EPS = 1e-5f;

 // See RTR2 ch. 13.7 for the algorithm.

 const Vector3& e1 = edge01();
 const Vector3& e2 = edge02();
 const Vector3 p(ray.direction().cross(e2));
 const float a = e1.dot(p);

 if (abs(a) < EPS) {
 // Determinant is ill-conditioned; abort early
 return false;
 }

 const float f = 1.0f / a;
 const Vector3 s(ray.origin() - vertex(0));
 const float u = f * s.dot(p);

 if ((u < 0.0f) || (u > 1.0f)) {
 // We hit the plane of the m_geometry, but outside the m_geometry
 return false;
 }

 const Vector3 q(s.cross(e1));
 const float v = f * ray.direction().dot(q);

 if ((v < 0.0f) || ((u + v) > 1.0f)) {
 // We hit the plane of the triangle, but outside the triangle
 return false;
 }

 const float t = f * e2.dot(q);

 if ((t > 0.0f) && (t < distance)) {
 // This is a new hit, closer than the previous one
 distance = t;

 baryCoord[0] = 1.0f - u - v;
 baryCoord[1] = u;
 baryCoord[2] = v;

 return true;
 } else {
 // This hit is after the previous hit, so ignore it
 return false;
 }
}

Here is the call graph for this function:

const Vector3 & G3D::Triangle::normal

(

)

const

 {
 return _plane.normal();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Triangle::operator== ( const Triangle &  other ) const

inline

For two triangles to be equal they must have the same vertices in the same order. That is, vertex[0] == vertex[0], etc.

 {
 for (int i = 0; i < 3; ++i) {
 if (_vertex[i] != other._vertex[i]) {
 return false;
 }
 }

 return true;
 }

const Plane & G3D::Triangle::plane

(

)

const

 {
 return _plane;
}

Here is the caller graph for this function:

Vector3::Axis G3D::Triangle::primaryAxis ( ) const

inline

 {
 return _primaryAxis;
 }

Here is the caller graph for this function:

Vector3 G3D::Triangle::randomPoint

(

)

const

Returns a random point in the triangle.

 {
 // Choose a random point in the parallelogram

 float s = uniformRandom();
 float t = uniformRandom();

 if (t > 1.0f - s) {
 // Outside the triangle; reflect about the
 // diagonal of the parallelogram
 t = 1.0f - t;
 s = 1.0f - s;
 }

 return _edge01 * s + _edge02 * t + _vertex[0];
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Triangle::serialize

(

class BinaryOutput &

b

)

 {
 _vertex[0].serialize(b);
 _vertex[1].serialize(b);
 _vertex[2].serialize(b);
}

Here is the call graph for this function:

const Point3& G3D::Triangle::vertex ( int  n ) const

inline

0, 1, or 2

 {
 debugAssert((n >= 0) && (n < 3));
 return _vertex[n];
 }

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class CollisionDetection

friend

friend class Ray

friend

Member Data Documentation

float G3D::Triangle::_area

private

Vector3 G3D::Triangle::_edge01

private

vertex[1] - vertex[0]

Vector3 G3D::Triangle::_edge02

private

vertex[2] - vertex[0]

Plane G3D::Triangle::_plane

private

Vector3::Axis G3D::Triangle::_primaryAxis

private

Vector3 G3D::Triangle::_vertex[3]

private

Vector3 G3D::Triangle::edgeDirection[3]

private

edgeDirection[i] is the normalized vector v[i+1] - v[i]

float G3D::Triangle::edgeMagnitude[3]

private

---

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

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