#include <tesseract_common/macros.h>

Include dependency graph for FloatMath.inl:

This graph shows which files directly or indirectly include this file:

Classes
class	tesseract_collision::FLOAT_MATH::Eigen< Type >

class	tesseract_collision::FLOAT_MATH::point< Type >

class	tesseract_collision::FLOAT_MATH::plane< Type >

class	tesseract_collision::FLOAT_MATH::polygon< Type >

class	tesseract_collision::FLOAT_MATH::VERTEX_INDEX::KdTreeFindNode

class	tesseract_collision::FLOAT_MATH::VERTEX_INDEX::KdTreeInterface

class	tesseract_collision::FLOAT_MATH::VERTEX_INDEX::KdTreeNode

class	tesseract_collision::FLOAT_MATH::VERTEX_INDEX::KdTreeNodeBundle

class	tesseract_collision::FLOAT_MATH::VERTEX_INDEX::KdTree

class	tesseract_collision::FLOAT_MATH::MyVertexIndex

class	tesseract_collision::FLOAT_MATH::Rect3d< T >

class	tesseract_collision::FLOAT_MATH::Myfm_Tesselate

class	tesseract_collision::FLOAT_MATH::TVec

class	tesseract_collision::FLOAT_MATH::CTriangulator

class	tesseract_collision::FLOAT_MATH::Triangulate

class	tesseract_collision::FLOAT_MATH::Vec3< Type >

Namespaces
namespace	tesseract_collision

namespace	tesseract_collision::FLOAT_MATH

namespace	tesseract_collision::FLOAT_MATH::VERTEX_INDEX

Macros
#define	DOT(p1, p2) (p1[0]p2[0]+p1[1]p2[1]+p1[2]*p2[2])

#define	BEST_FIT_PLANE_H

#define	PLANE_TRIANGLE_INTERSECTION_H

#define	MAXPTS 256

#define	VERTEX_INDEX_H

#define	MAX_BUNDLE_SIZE 1024

#define	vector(a, b, c)

#define	innerProduct(v, q)

#define	crossProduct(a, b, c)

#define	RECT3D_TEMPLATE

#define	TESSELATE_H

#define	RAY_ABB_INTERSECT

#define	IR(x) ((uint32_t&)x)
	Integer representation of a floating-point value. More...

#define	RAYAABB_EPSILON 0.00001f

#define	OBB_TO_AABB

#define	BIGNUMBER 100000000.0 /* hundred million */

#define	TRIANGULATE_H

#define	TEMPLATE_VEC3

Typedefs
typedef std::vector< KdTreeNode * >	tesseract_collision::FLOAT_MATH::VERTEX_INDEX::KdTreeNodeVector

typedef std::vector< double >	tesseract_collision::FLOAT_MATH::VERTEX_INDEX::DoubleVector

typedef std::vector< float >	tesseract_collision::FLOAT_MATH::VERTEX_INDEX::FloatVector

typedef std::vector< uint32_t >	tesseract_collision::FLOAT_MATH::UintVector

typedef uint32_t	tesseract_collision::FLOAT_MATH::TU32

typedef std::vector< TVec >	tesseract_collision::FLOAT_MATH::TVecVector

typedef std::vector< TU32 >	tesseract_collision::FLOAT_MATH::TU32Vector

Enumerations
enum	tesseract_collision::FLOAT_MATH::VERTEX_INDEX::Axes { tesseract_collision::FLOAT_MATH::VERTEX_INDEX::X_AXIS = 0 , tesseract_collision::FLOAT_MATH::VERTEX_INDEX::Y_AXIS = 1 , tesseract_collision::FLOAT_MATH::VERTEX_INDEX::Z_AXIS = 2 }

Functions
void	tesseract_collision::FLOAT_MATH::fm_inverseRT (const REAL matrix[16], const REAL pos[3], REAL t[3])

REAL	tesseract_collision::FLOAT_MATH::fm_getDeterminant (const REAL matrix[16])

REAL	tesseract_collision::FLOAT_MATH::fm_squared (REAL x)

void	tesseract_collision::FLOAT_MATH::fm_decomposeTransform (const REAL local_transform[16], REAL trans[3], REAL rot[4], REAL scale[3])

void	tesseract_collision::FLOAT_MATH::fm_getSubMatrix (int32_t ki, int32_t kj, REAL pDst[16], const REAL matrix[16])

void	tesseract_collision::FLOAT_MATH::fm_inverseTransform (const REAL matrix[16], REAL inverse_matrix[16])

void	tesseract_collision::FLOAT_MATH::fm_identity (REAL matrix[16])

void	tesseract_collision::FLOAT_MATH::fm_quatToEuler (const REAL quat[4], REAL &ax, REAL &ay, REAL &az)

void	tesseract_collision::FLOAT_MATH::fm_eulerToMatrix (REAL ax, REAL ay, REAL az, REAL *matrix)

void	tesseract_collision::FLOAT_MATH::fm_getAABB (uint32_t vcount, const REAL points, uint32_t pstride, REAL bmin, REAL *bmax)

void	tesseract_collision::FLOAT_MATH::fm_eulerToQuat (const REAL euler, REAL quat)

void	tesseract_collision::FLOAT_MATH::fm_eulerToQuat (REAL roll, REAL pitch, REAL yaw, REAL *quat)

void	tesseract_collision::FLOAT_MATH::fm_quatToMatrix (const REAL quat, REAL matrix)

void	tesseract_collision::FLOAT_MATH::fm_quatRotate (const REAL quat, const REAL v, REAL *r)

void	tesseract_collision::FLOAT_MATH::fm_getTranslation (const REAL matrix, REAL t)

void	tesseract_collision::FLOAT_MATH::fm_matrixToQuat (const REAL matrix, REAL quat)

REAL	tesseract_collision::FLOAT_MATH::fm_sphereVolume (REAL radius)

REAL	tesseract_collision::FLOAT_MATH::fm_cylinderVolume (REAL radius, REAL h)

REAL	tesseract_collision::FLOAT_MATH::fm_capsuleVolume (REAL radius, REAL h)

void	tesseract_collision::FLOAT_MATH::fm_transform (const REAL matrix[16], const REAL v[3], REAL t[3])

void	tesseract_collision::FLOAT_MATH::fm_rotate (const REAL matrix[16], const REAL v[3], REAL t[3])

REAL	tesseract_collision::FLOAT_MATH::fm_distance (const REAL p1, const REAL p2)

REAL	tesseract_collision::FLOAT_MATH::fm_distanceSquared (const REAL p1, const REAL p2)

REAL	tesseract_collision::FLOAT_MATH::fm_distanceSquaredXZ (const REAL p1, const REAL p2)

REAL	tesseract_collision::FLOAT_MATH::fm_computePlane (const REAL A, const REAL B, const REAL C, REAL n)

REAL	tesseract_collision::FLOAT_MATH::fm_distToPlane (const REAL plane, const REAL p)

REAL	tesseract_collision::FLOAT_MATH::fm_dot (const REAL p1, const REAL p2)

void	tesseract_collision::FLOAT_MATH::fm_cross (REAL cross, const REAL a, const REAL *b)

REAL	tesseract_collision::FLOAT_MATH::fm_computeNormalVector (REAL n, const REAL p1, const REAL *p2)

bool	tesseract_collision::FLOAT_MATH::fm_computeWindingOrder (const REAL p1, const REAL p2, const REAL *p3)

REAL	tesseract_collision::FLOAT_MATH::fm_normalize (REAL *n)

void	tesseract_collision::FLOAT_MATH::fm_matrixMultiply (const REAL pA, const REAL pB, REAL *pM)

void	tesseract_collision::FLOAT_MATH::fm_eulerToQuatDX (REAL x, REAL y, REAL z, REAL *quat)

void	tesseract_collision::FLOAT_MATH::fm_eulerToMatrixDX (REAL x, REAL y, REAL z, REAL *matrix)

void	tesseract_collision::FLOAT_MATH::fm_scale (REAL x, REAL y, REAL z, REAL *fscale)

void	tesseract_collision::FLOAT_MATH::fm_composeTransform (const REAL position, const REAL quat, const REAL scale, REAL matrix)

void	tesseract_collision::FLOAT_MATH::fm_setTranslation (const REAL translation, REAL matrix)

static REAL	tesseract_collision::FLOAT_MATH::enorm0_3d (REAL x0, REAL y0, REAL z0, REAL x1, REAL y1, REAL z1)

static REAL	tesseract_collision::FLOAT_MATH::triangle_area_3d (REAL x1, REAL y1, REAL z1, REAL x2, REAL y2, REAL z2, REAL x3, REAL y3, REAL z3)

REAL	tesseract_collision::FLOAT_MATH::fm_computeArea (const REAL p1, const REAL p2, const REAL *p3)

void	tesseract_collision::FLOAT_MATH::fm_lerp (const REAL p1, const REAL p2, REAL *dest, REAL lerpValue)

bool	tesseract_collision::FLOAT_MATH::fm_pointTestXZ (const REAL p, const REAL i, const REAL *j)

bool	tesseract_collision::FLOAT_MATH::fm_insideTriangleXZ (const REAL p, const REAL p1, const REAL p2, const REAL p3)

bool	tesseract_collision::FLOAT_MATH::fm_insideAABB (const REAL pos, const REAL bmin, const REAL *bmax)

uint32_t	tesseract_collision::FLOAT_MATH::fm_clipTestPoint (const REAL bmin, const REAL bmax, const REAL *pos)

uint32_t	tesseract_collision::FLOAT_MATH::fm_clipTestPointXZ (const REAL bmin, const REAL bmax, const REAL *pos)

uint32_t	tesseract_collision::FLOAT_MATH::fm_clipTestAABB (const REAL bmin, const REAL bmax, const REAL p1, const REAL p2, const REAL *p3, uint32_t &andCode)

bool	tesseract_collision::FLOAT_MATH::intersect (const REAL si, const REAL ei, const REAL bmin, const REAL bmax, REAL *time)

bool	tesseract_collision::FLOAT_MATH::fm_lineTestAABB (const REAL p1, const REAL p2, const REAL bmin, const REAL bmax, REAL &time)

bool	tesseract_collision::FLOAT_MATH::fm_lineTestAABBXZ (const REAL p1, const REAL p2, const REAL bmin, const REAL bmax, REAL &time)

void	tesseract_collision::FLOAT_MATH::fm_minmax (const REAL p, REAL bmin, REAL *bmax)

REAL	tesseract_collision::FLOAT_MATH::fm_solveX (const REAL *plane, REAL y, REAL z)

REAL	tesseract_collision::FLOAT_MATH::fm_solveY (const REAL *plane, REAL x, REAL z)

REAL	tesseract_collision::FLOAT_MATH::fm_solveZ (const REAL *plane, REAL x, REAL y)

void	tesseract_collision::FLOAT_MATH::fm_getAABBCenter (const REAL bmin, const REAL bmax, REAL *center)

FM_Axis	tesseract_collision::FLOAT_MATH::fm_getDominantAxis (const REAL normal[3])

bool	tesseract_collision::FLOAT_MATH::fm_lineSphereIntersect (const REAL center, REAL radius, const REAL p1, const REAL p2, REAL intersect)

bool	tesseract_collision::FLOAT_MATH::fm_raySphereIntersect (const REAL center, REAL radius, const REAL pos, const REAL dir, REAL distance, REAL intersect)

void	tesseract_collision::FLOAT_MATH::fm_catmullRom (REAL out_vector, const REAL p1, const REAL p2, const REAL p3, const REAL *p4, const REAL s)

bool	tesseract_collision::FLOAT_MATH::fm_intersectAABB (const REAL bmin1, const REAL bmax1, const REAL bmin2, const REAL bmax2)

bool	tesseract_collision::FLOAT_MATH::fm_insideAABB (const REAL obmin, const REAL obmax, const REAL tbmin, const REAL tbmax)

void	tesseract_collision::FLOAT_MATH::fm_rotationArc (const REAL v0, const REAL v1, REAL *quat)

REAL	tesseract_collision::FLOAT_MATH::fm_distancePointLineSegment (const REAL Point, const REAL LineStart, const REAL LineEnd, REAL intersection, LineSegmentType &type, REAL epsilon)

bool	tesseract_collision::FLOAT_MATH::fm_computeBestFitPlane (uint32_t vcount, const REAL points, uint32_t vstride, const REAL weights, uint32_t wstride, REAL plane, REAL center)

bool	tesseract_collision::FLOAT_MATH::fm_colinear (const REAL a1[3], const REAL a2[3], const REAL b1[3], const REAL b2[3], REAL epsilon)

bool	tesseract_collision::FLOAT_MATH::fm_colinear (const REAL p1, const REAL p2, const REAL *p3, REAL epsilon)

void	tesseract_collision::FLOAT_MATH::fm_initMinMax (const REAL p, REAL bmin, REAL *bmax)

IntersectResult	tesseract_collision::FLOAT_MATH::fm_intersectLineSegments2d (const REAL a1, const REAL a2, const REAL b1, const REAL b2, REAL *intersection)

IntersectResult	tesseract_collision::FLOAT_MATH::fm_intersectLineSegments2dTime (const REAL a1, const REAL a2, const REAL b1, const REAL b2, REAL &t1, REAL &t2)

bool	tesseract_collision::FLOAT_MATH::fm_intersectPointPlane (const REAL p1, const REAL p2, REAL split, const REAL plane)

PlaneTriResult	tesseract_collision::FLOAT_MATH::fm_getSidePlane (const REAL p, const REAL plane, REAL epsilon)

static void	tesseract_collision::FLOAT_MATH::add (const REAL p, REAL dest, uint32_t tstride, uint32_t &pcount)

PlaneTriResult	tesseract_collision::FLOAT_MATH::fm_planeTriIntersection (const REAL _plane, const REAL triangle, uint32_t tstride, REAL epsilon, REAL front, uint32_t &fcount, REAL back, uint32_t &bcount)

void	tesseract_collision::FLOAT_MATH::computeOBB (uint32_t vcount, const REAL points, uint32_t pstride, REAL sides, REAL *matrix)

void	tesseract_collision::FLOAT_MATH::fm_computeBestFitOBB (uint32_t vcount, const REAL points, uint32_t pstride, REAL sides, REAL *matrix, bool bruteForce)

void	tesseract_collision::FLOAT_MATH::fm_computeBestFitOBB (uint32_t vcount, const REAL points, uint32_t pstride, REAL sides, REAL pos, REAL quat, bool bruteForce)

void	tesseract_collision::FLOAT_MATH::fm_computeBestFitABB (uint32_t vcount, const REAL points, uint32_t pstride, REAL sides, REAL *pos)

void	tesseract_collision::FLOAT_MATH::fm_planeToMatrix (const REAL plane, REAL matrix)

void	tesseract_collision::FLOAT_MATH::fm_planeToQuat (const REAL plane, REAL quat, REAL *pos)

void	tesseract_collision::FLOAT_MATH::fm_eulerMatrix (REAL ax, REAL ay, REAL az, REAL *matrix)

fm_VertexIndex *	tesseract_collision::FLOAT_MATH::fm_createVertexIndex (double granularity, bool snapToGrid)

fm_VertexIndex *	tesseract_collision::FLOAT_MATH::fm_createVertexIndex (float granularity, bool snapToGrid)

void	tesseract_collision::FLOAT_MATH::fm_releaseVertexIndex (fm_VertexIndex *vindex)

REAL	tesseract_collision::FLOAT_MATH::fm_computeBestFitAABB (uint32_t vcount, const REAL points, uint32_t pstride, REAL bmin, REAL *bmax)

bool	tesseract_collision::FLOAT_MATH::fm_lineIntersectsTriangle (const REAL rayStart, const REAL rayEnd, const REAL p1, const REAL p2, const REAL p3, REAL sect)

bool	tesseract_collision::FLOAT_MATH::fm_rayIntersectsTriangle (const REAL p, const REAL d, const REAL v0, const REAL v1, const REAL *v2, REAL &t)

REAL	tesseract_collision::FLOAT_MATH::det (const REAL p1, const REAL p2, const REAL *p3)

REAL	tesseract_collision::FLOAT_MATH::fm_computeMeshVolume (const REAL vertices, uint32_t tcount, const uint32_t indices)

const REAL *	tesseract_collision::FLOAT_MATH::fm_getPoint (const REAL *points, uint32_t pstride, uint32_t index)

bool	tesseract_collision::FLOAT_MATH::fm_insideTriangle (REAL Ax, REAL Ay, REAL Bx, REAL By, REAL Cx, REAL Cy, REAL Px, REAL Py)

REAL	tesseract_collision::FLOAT_MATH::fm_areaPolygon2d (uint32_t pcount, const REAL *points, uint32_t pstride)

bool	tesseract_collision::FLOAT_MATH::fm_pointInsidePolygon2d (uint32_t pcount, const REAL points, uint32_t pstride, const REAL point, uint32_t xindex, uint32_t yindex)

uint32_t	tesseract_collision::FLOAT_MATH::fm_consolidatePolygon (uint32_t pcount, const REAL points, uint32_t pstride, REAL _dest, REAL epsilon)

void	tesseract_collision::FLOAT_MATH::splitRect (uint32_t axis, const Rect3d< REAL > &source, Rect3d< REAL > &b1, Rect3d< REAL > &b2, const REAL *midpoint)

bool	tesseract_collision::FLOAT_MATH::fm_computeSplitPlane (uint32_t vcount, const REAL vertices, uint32_t, const uint32_t , REAL *plane)

void	tesseract_collision::FLOAT_MATH::fm_nearestPointInTriangle (const REAL , const REAL , const REAL , const REAL , REAL *)

static REAL	tesseract_collision::FLOAT_MATH::Partial (const REAL a, const REAL p)

REAL	tesseract_collision::FLOAT_MATH::fm_areaTriangle (const REAL p0, const REAL p1, const REAL *p2)

void	tesseract_collision::FLOAT_MATH::fm_subtract (const REAL A, const REAL B, REAL *diff)

void	tesseract_collision::FLOAT_MATH::fm_multiplyTransform (const REAL pA, const REAL pB, REAL *pM)

void	tesseract_collision::FLOAT_MATH::fm_multiply (REAL *A, REAL scaler)

void	tesseract_collision::FLOAT_MATH::fm_add (const REAL A, const REAL B, REAL *sum)

void	tesseract_collision::FLOAT_MATH::fm_copy3 (const REAL source, REAL dest)

uint32_t	tesseract_collision::FLOAT_MATH::fm_copyUniqueVertices (uint32_t vcount, const REAL input_vertices, REAL output_vertices, uint32_t tcount, const uint32_t input_indices, uint32_t output_indices)

bool	tesseract_collision::FLOAT_MATH::fm_isMeshCoplanar (uint32_t tcount, const uint32_t indices, const REAL vertices, bool doubleSided)

bool	tesseract_collision::FLOAT_MATH::fm_samePlane (const REAL p1[4], const REAL p2[4], REAL normalEpsilon, REAL dEpsilon, bool doubleSided)

void	tesseract_collision::FLOAT_MATH::fm_initMinMax (REAL bmin[3], REAL bmax[3])

void	tesseract_collision::FLOAT_MATH::fm_inflateMinMax (REAL bmin[3], REAL bmax[3], REAL ratio)

fm_Tesselate *	tesseract_collision::FLOAT_MATH::fm_createTesselate (void)

void	tesseract_collision::FLOAT_MATH::fm_releaseTesselate (fm_Tesselate *t)

bool	tesseract_collision::FLOAT_MATH::fm_intersectRayAABB (const float bmin[3], const float bmax[3], const float pos[3], const float dir[3], float intersect[3])

bool	tesseract_collision::FLOAT_MATH::fm_intersectLineSegmentAABB (const float bmin[3], const float bmax[3], const float p1[3], const float p2[3], float intersect[3])

void	tesseract_collision::FLOAT_MATH::fm_OBBtoAABB (const float obmin[3], const float obmax[3], const float matrix[16], float abmin[3], float abmax[3])

const REAL *	tesseract_collision::FLOAT_MATH::computePos (uint32_t index, const REAL *vertices, uint32_t vstride)

void	tesseract_collision::FLOAT_MATH::computeNormal (uint32_t index, REAL normals, uint32_t nstride, const REAL normal)

void	tesseract_collision::FLOAT_MATH::fm_computeMeanNormals (uint32_t vcount, const REAL vertices, uint32_t vstride, REAL normals, uint32_t nstride, uint32_t tcount, const uint32_t *indices)

static void	tesseract_collision::FLOAT_MATH::Set (REAL *n, REAL x, REAL y, REAL z)

static void	tesseract_collision::FLOAT_MATH::Copy (REAL dest, const REAL source)

REAL	tesseract_collision::FLOAT_MATH::fm_computeBestFitSphere (uint32_t vcount, const REAL points, uint32_t pstride, REAL center)

void	tesseract_collision::FLOAT_MATH::fm_computeBestFitCapsule (uint32_t vcount, const REAL *points, uint32_t pstride, REAL &radius, REAL &height, REAL matrix[16], bool bruteForce)

fm_Triangulate *	tesseract_collision::FLOAT_MATH::fm_createTriangulate (void)

void	tesseract_collision::FLOAT_MATH::fm_releaseTriangulate (fm_Triangulate *t)

bool	tesseract_collision::FLOAT_MATH::validDistance (const REAL p1, const REAL p2, REAL epsilon)

bool	tesseract_collision::FLOAT_MATH::fm_isValidTriangle (const REAL p1, const REAL p2, const REAL *p3, REAL epsilon)

void	tesseract_collision::FLOAT_MATH::fm_multiplyQuat (const REAL left, const REAL right, REAL *quat)

bool	tesseract_collision::FLOAT_MATH::fm_computeCentroid (uint32_t vcount, const REAL points, REAL center)

bool	tesseract_collision::FLOAT_MATH::fm_computeCentroid (uint32_t vcount, const REAL points, uint32_t triCount, const uint32_t indices, REAL *center)

void	tesseract_collision::FLOAT_MATH::fm_transformAABB (const REAL bmin[3], const REAL bmax[3], const REAL matrix[16], REAL tbmin[3], REAL tbmax[3])

REAL	tesseract_collision::FLOAT_MATH::fm_normalizeQuat (REAL n[4])

Macro Definition Documentation

◆ BEST_FIT_PLANE_H

#define BEST_FIT_PLANE_H

◆ BIGNUMBER

#define BIGNUMBER 100000000.0 /* hundred million */

◆ crossProduct

#define crossProduct	(	a,
		b,
		c
	)

Value:

    (a)[0] = (b)[1] * (c)[2] - (c)[1] * (b)[2]; \
    (a)[1] = (b)[2] * (c)[0] - (c)[2] * (b)[0]; \
    (a)[2] = (b)[0] * (c)[1] - (c)[0] * (b)[1];

◆ DOT

#define DOT	(	p1,
		p2
	)	(p1[0]p2[0]+p1[1]p2[1]+p1[2]*p2[2])

◆ innerProduct

#define innerProduct	(	v,
		q
	)

Value:

        ((v)[0] * (q)[0] + \
        (v)[1] * (q)[1] + \
        (v)[2] * (q)[2])

◆ IR

#define IR ( x ) ((uint32_t&)x)

Integer representation of a floating-point value.

◆ MAX_BUNDLE_SIZE

#define MAX_BUNDLE_SIZE 1024

◆ MAXPTS

#define MAXPTS 256

◆ OBB_TO_AABB

#define OBB_TO_AABB

◆ PLANE_TRIANGLE_INTERSECTION_H

#define PLANE_TRIANGLE_INTERSECTION_H

◆ RAY_ABB_INTERSECT

#define RAY_ABB_INTERSECT

◆ RAYAABB_EPSILON

#define RAYAABB_EPSILON 0.00001f

A method to compute a ray-AABB intersection. Original code by Andrew Woo, from "Graphics Gems", Academic Press, 1990 Optimized code by Pierre Terdiman, 2000 (~20-30% faster on my Celeron 500) Epsilon value added by Klaus Hartmann. (discarding it saves a few cycles only)

Hence this version is faster as well as more robust than the original one.

Should work provided: 1) the integer representation of 0.0f is 0x00000000 2) the sign bit of the float is the most significant one

Report bugs: p.ter.nosp@m.dima.nosp@m.n@cod.nosp@m.erco.nosp@m.rner..nosp@m.com

Parameters

aabb	[in] the axis-aligned bounding box
origin	[in] ray origin
dir	[in] ray direction
coord	[out] impact coordinates

Returns: true if ray intersects AABB

◆ RECT3D_TEMPLATE

#define RECT3D_TEMPLATE

◆ TEMPLATE_VEC3

#define TEMPLATE_VEC3

◆ TESSELATE_H

#define TESSELATE_H

◆ TRIANGULATE_H

#define TRIANGULATE_H

◆ vector

#define vector	(	a,
		b,
		c
	)

Value:

    (a)[0] = (b)[0] - (c)[0];   \
    (a)[1] = (b)[1] - (c)[1];   \
    (a)[2] = (b)[2] - (c)[2];

◆ VERTEX_INDEX_H

#define VERTEX_INDEX_H

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ BEST_FIT_PLANE_H

◆ BIGNUMBER

◆ crossProduct

◆ DOT

◆ innerProduct

◆ IR

◆ MAX_BUNDLE_SIZE

◆ MAXPTS

◆ OBB_TO_AABB

◆ PLANE_TRIANGLE_INTERSECTION_H

◆ RAY_ABB_INTERSECT

◆ RAYAABB_EPSILON

◆ RECT3D_TEMPLATE

◆ TEMPLATE_VEC3

◆ TESSELATE_H

◆ TRIANGULATE_H

◆ vector

◆ VERTEX_INDEX_H