irr::core::triangle3d< T > Class Template Reference

3d triangle template class for doing collision detection and other things. More...

#include <triangle3d.h>

Public Member Functions
	triangle3d ()
	Constructor for an all 0 triangle. More...
	triangle3d (const vector3d< T > &v1, const vector3d< T > &v2, const vector3d< T > &v3)
	Constructor for triangle with given three vertices. More...
bool	operator== (const triangle3d< T > &other) const
	Equality operator. More...
bool	operator!= (const triangle3d< T > &other) const
	Inequality operator. More...
bool	isTotalInsideBox (const aabbox3d< T > &box) const
	Determines if the triangle is totally inside a bounding box. More...
bool	isTotalOutsideBox (const aabbox3d< T > &box) const
	Determines if the triangle is totally outside a bounding box. More...
core::vector3d< T >	closestPointOnTriangle (const core::vector3d< T > &p) const
	Get the closest point on a triangle to a point on the same plane. More...
bool	isPointInside (const vector3d< T > &p) const
	Check if a point is inside the triangle (border-points count also as inside) More...
bool	isPointInsideFast (const vector3d< T > &p) const
	Check if a point is inside the triangle (border-points count also as inside) More...
bool	getIntersectionWithLimitedLine (const line3d< T > &line, vector3d< T > &outIntersection) const
	Get an intersection with a 3d line. More...
bool	getIntersectionWithLine (const vector3d< T > &linePoint, const vector3d< T > &lineVect, vector3d< T > &outIntersection) const
	Get an intersection with a 3d line. More...
bool	getIntersectionOfPlaneWithLine (const vector3d< T > &linePoint, const vector3d< T > &lineVect, vector3d< T > &outIntersection) const
	Calculates the intersection between a 3d line and the plane the triangle is on. More...
vector3d< T >	getNormal () const
	Get the normal of the triangle. More...
bool	isFrontFacing (const vector3d< T > &lookDirection) const
	Test if the triangle would be front or backfacing from any point. More...
plane3d< T >	getPlane () const
	Get the plane of this triangle. More...
T	getArea () const
	Get the area of the triangle. More...
void	set (const core::vector3d< T > &a, const core::vector3d< T > &b, const core::vector3d< T > &c)
	sets the triangle's points More...

Public Attributes
vector3d< T >	pointA
	the three points of the triangle More...
vector3d< T >	pointB
vector3d< T >	pointC

Detailed Description

template<class T>
class irr::core::triangle3d< T >

3d triangle template class for doing collision detection and other things.

Definition at line 20 of file triangle3d.h.

Constructor & Destructor Documentation

triangle3d() [1/2]

template<class T>

irr::core::triangle3d< T >::triangle3d ( )

inline

Constructor for an all 0 triangle.

Definition at line 25 of file triangle3d.h.

{}

triangle3d() [2/2]

template<class T>

irr::core::triangle3d< T >::triangle3d ( const vector3d< T > &  v1, const vector3d< T > &  v2, const vector3d< T > &  v3  )

inline

Constructor for triangle with given three vertices.

Definition at line 27 of file triangle3d.h.

: pointA(v1), pointB(v2), pointC(v3) {}

Member Function Documentation

closestPointOnTriangle()

template<class T>

core::vector3d<T> irr::core::triangle3d< T >::closestPointOnTriangle ( const core::vector3d< T > &  p ) const

inline

Get the closest point on a triangle to a point on the same plane.

Parameters

p	Point which must be on the same plane as the triangle.

Returns

The closest point of the triangle

Definition at line 68 of file triangle3d.h.

                {
                        const core::vector3d<T> rab = line3d<T>(pointA, pointB).getClosestPoint(p);
                        const core::vector3d<T> rbc = line3d<T>(pointB, pointC).getClosestPoint(p);
                        const core::vector3d<T> rca = line3d<T>(pointC, pointA).getClosestPoint(p);

                        const T d1 = rab.getDistanceFrom(p);
                        const T d2 = rbc.getDistanceFrom(p);
                        const T d3 = rca.getDistanceFrom(p);

                        if (d1 < d2)
                                return d1 < d3 ? rab : rca;

                        return d2 < d3 ? rbc : rca;
                }

getArea()

template<class T>

T irr::core::triangle3d< T >::getArea ( ) const

inline

Get the area of the triangle.

Definition at line 224 of file triangle3d.h.

                {
                        return (pointB - pointA).crossProduct(pointC - pointA).getLength() * 0.5f;

                }

getIntersectionOfPlaneWithLine()

template<class T>

bool irr::core::triangle3d< T >::getIntersectionOfPlaneWithLine ( const vector3d< T > &  linePoint, const vector3d< T > &  lineVect, vector3d< T > &  outIntersection  ) const

inline

Calculates the intersection between a 3d line and the plane the triangle is on.

Parameters

lineVect	Vector of the line to intersect with.
linePoint	Point of the line to intersect with.
outIntersection	Place to store the intersection point, if there is one.

Returns

True if there was an intersection, else false.

Definition at line 169 of file triangle3d.h.

                {
                        // Work with f64 to get more precise results (makes enough difference to be worth the casts).
                        const vector3d<f64> linePointf64(linePoint.X, linePoint.Y, linePoint.Z);
                        const vector3d<f64> lineVectf64(lineVect.X, lineVect.Y, lineVect.Z);
                        vector3d<f64> outIntersectionf64;

                        core::triangle3d<irr::f64> trianglef64(vector3d<f64>((f64)pointA.X, (f64)pointA.Y, (f64)pointA.Z)
                                                                                ,vector3d<f64>((f64)pointB.X, (f64)pointB.Y, (f64)pointB.Z)
                                                                                , vector3d<f64>((f64)pointC.X, (f64)pointC.Y, (f64)pointC.Z));
                        const vector3d<irr::f64> normalf64 = trianglef64.getNormal().normalize();
                        f64 t2;

                        if ( core::iszero ( t2 = normalf64.dotProduct(lineVectf64) ) )
                                return false;

                        f64 d = trianglef64.pointA.dotProduct(normalf64);
                        f64 t = -(normalf64.dotProduct(linePointf64) - d) / t2;
                        outIntersectionf64 = linePointf64 + (lineVectf64 * t);

                        outIntersection.X = (T)outIntersectionf64.X;
                        outIntersection.Y = (T)outIntersectionf64.Y;
                        outIntersection.Z = (T)outIntersectionf64.Z;
                        return true;
                }

getIntersectionWithLimitedLine()

template<class T>

bool irr::core::triangle3d< T >::getIntersectionWithLimitedLine ( const line3d< T > &  line, vector3d< T > &  outIntersection  ) const

inline

Get an intersection with a 3d line.

Parameters

line	Line to intersect with.
outIntersection	Place to store the intersection point, if there is one.

Returns

True if there was an intersection, false if not.

Definition at line 136 of file triangle3d.h.

                {
                        return getIntersectionWithLine(line.start,
                                line.getVector(), outIntersection) &&
                                outIntersection.isBetweenPoints(line.start, line.end);
                }

getIntersectionWithLine()

template<class T>

bool irr::core::triangle3d< T >::getIntersectionWithLine ( const vector3d< T > &  linePoint, const vector3d< T > &  lineVect, vector3d< T > &  outIntersection  ) const

inline

Get an intersection with a 3d line.

Please note that also points are returned as intersection which are on the line, but not between the start and end point of the line. If you want the returned point be between start and end use getIntersectionWithLimitedLine().

Parameters

linePoint	Point of the line to intersect with.
lineVect	Vector of the line to intersect with.
outIntersection	Place to store the intersection point, if there is one.

Returns

True if there was an intersection, false if there was not.

Definition at line 154 of file triangle3d.h.

                {
                        if (getIntersectionOfPlaneWithLine(linePoint, lineVect, outIntersection))
                                return isPointInside(outIntersection);

                        return false;
                }

getNormal()

template<class T>

vector3d<T> irr::core::triangle3d< T >::getNormal ( ) const

inline

Get the normal of the triangle.

Please note: The normal is not always normalized.

Definition at line 199 of file triangle3d.h.

                {
                        return (pointB - pointA).crossProduct(pointC - pointA);
                }

getPlane()

template<class T>

plane3d<T> irr::core::triangle3d< T >::getPlane ( ) const

inline

Get the plane of this triangle.

Definition at line 218 of file triangle3d.h.

                {
                        return plane3d<T>(pointA, pointB, pointC);
                }

isFrontFacing()

template<class T>

bool irr::core::triangle3d< T >::isFrontFacing ( const vector3d< T > &  lookDirection ) const

inline

Test if the triangle would be front or backfacing from any point.

Thus, this method assumes a camera position from which the triangle is definitely visible when looking at the given direction. Do not use this method with points as it will give wrong results!

Parameters

lookDirection

Look direction.

Returns

True if the plane is front facing and false if it is backfacing.

Definition at line 210 of file triangle3d.h.

                {
                        const vector3d<T> n = getNormal().normalize();
                        const f32 d = (f32)n.dotProduct(lookDirection);
                        return F32_LOWER_EQUAL_0(d);
                }

isPointInside()

template<class T>

bool irr::core::triangle3d< T >::isPointInside ( const vector3d< T > &  p ) const

inline

Check if a point is inside the triangle (border-points count also as inside)

Definition at line 89 of file triangle3d.h.

                {
                        vector3d<f64> af64((f64)pointA.X, (f64)pointA.Y, (f64)pointA.Z);
                        vector3d<f64> bf64((f64)pointB.X, (f64)pointB.Y, (f64)pointB.Z);
                        vector3d<f64> cf64((f64)pointC.X, (f64)pointC.Y, (f64)pointC.Z);
                        vector3d<f64> pf64((f64)p.X, (f64)p.Y, (f64)p.Z);
                        return (isOnSameSide(pf64, af64, bf64, cf64) &&
                                isOnSameSide(pf64, bf64, af64, cf64) &&
                                isOnSameSide(pf64, cf64, af64, bf64));
                }

isPointInsideFast()

template<class T>

bool irr::core::triangle3d< T >::isPointInsideFast ( const vector3d< T > &  p ) const

inline

Check if a point is inside the triangle (border-points count also as inside)

This method uses a barycentric coordinate system. It is faster than isPointInside but is more susceptible to floating point rounding errors. This will especially be noticeable when the FPU is in single precision mode (which is for example set on default by Direct3D).

Parameters

p	Point to test. Assumes that this point is already on the plane of the triangle.

Returns

True if point is inside the triangle, otherwise false.

Definition at line 108 of file triangle3d.h.

                {
                        const vector3d<T> a = pointC - pointA;
                        const vector3d<T> b = pointB - pointA;
                        const vector3d<T> c = p - pointA;

                        const f64 dotAA = a.dotProduct( a);
                        const f64 dotAB = a.dotProduct( b);
                        const f64 dotAC = a.dotProduct( c);
                        const f64 dotBB = b.dotProduct( b);
                        const f64 dotBC = b.dotProduct( c);

                        // get coordinates in barycentric coordinate system
                        const f64 invDenom =  1/(dotAA * dotBB - dotAB * dotAB);
                        const f64 u = (dotBB * dotAC - dotAB * dotBC) * invDenom;
                        const f64 v = (dotAA * dotBC - dotAB * dotAC ) * invDenom;

                        // We count border-points as inside to keep downward compatibility.
                        // Rounding-error also needed for some test-cases.
                        return (u > -ROUNDING_ERROR_f32) && (v >= 0) && (u + v < 1+ROUNDING_ERROR_f32);

                }

isTotalInsideBox()

template<class T>

bool irr::core::triangle3d< T >::isTotalInsideBox ( const aabbox3d< T > &  box ) const

inline

Determines if the triangle is totally inside a bounding box.

Parameters

box	Box to check.

Returns

True if triangle is within the box, otherwise false.

Definition at line 44 of file triangle3d.h.

                {
                        return (box.isPointInside(pointA) &&
                                box.isPointInside(pointB) &&
                                box.isPointInside(pointC));
                }

isTotalOutsideBox()

template<class T>

bool irr::core::triangle3d< T >::isTotalOutsideBox ( const aabbox3d< T > &  box ) const

inline

Determines if the triangle is totally outside a bounding box.

Parameters

box	Box to check.

Returns

True if triangle is outside the box, otherwise false.

Definition at line 54 of file triangle3d.h.

                {
                        return ((pointA.X > box.MaxEdge.X && pointB.X > box.MaxEdge.X && pointC.X > box.MaxEdge.X) ||

                                (pointA.Y > box.MaxEdge.Y && pointB.Y > box.MaxEdge.Y && pointC.Y > box.MaxEdge.Y) ||
                                (pointA.Z > box.MaxEdge.Z && pointB.Z > box.MaxEdge.Z && pointC.Z > box.MaxEdge.Z) ||
                                (pointA.X < box.MinEdge.X && pointB.X < box.MinEdge.X && pointC.X < box.MinEdge.X) ||
                                (pointA.Y < box.MinEdge.Y && pointB.Y < box.MinEdge.Y && pointC.Y < box.MinEdge.Y) ||
                                (pointA.Z < box.MinEdge.Z && pointB.Z < box.MinEdge.Z && pointC.Z < box.MinEdge.Z));
                }

operator!=()

template<class T>

bool irr::core::triangle3d< T >::operator!= ( const triangle3d< T > &  other ) const

inline

Inequality operator.

Definition at line 36 of file triangle3d.h.

                {
                        return !(*this==other);
                }

operator==()

template<class T>

bool irr::core::triangle3d< T >::operator== ( const triangle3d< T > &  other ) const

inline

Equality operator.

Definition at line 30 of file triangle3d.h.

                {
                        return other.pointA==pointA && other.pointB==pointB && other.pointC==pointC;
                }

set()

template<class T>

void irr::core::triangle3d< T >::set ( const core::vector3d< T > &  a, const core::vector3d< T > &  b, const core::vector3d< T > &  c  )

inline

sets the triangle's points

Definition at line 231 of file triangle3d.h.

                {
                        pointA = a;
                        pointB = b;
                        pointC = c;
                }

Member Data Documentation

pointA

template<class T>

vector3d<T> irr::core::triangle3d< T >::pointA

the three points of the triangle

Definition at line 239 of file triangle3d.h.

pointB

template<class T>

vector3d<T> irr::core::triangle3d< T >::pointB

Definition at line 240 of file triangle3d.h.

pointC

template<class T>

vector3d<T> irr::core::triangle3d< T >::pointC

Definition at line 241 of file triangle3d.h.

---

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

• include/irrlicht/triangle3d.h