tesseract_collision::FLOAT_MATH Namespace Reference

Namespaces
namespace	VERTEX_INDEX

Classes
class	CTriangulator
class	Eigen
class	fm_Tesselate
class	fm_Triangulate
class	fm_VertexIndex
class	Myfm_Tesselate
class	MyVertexIndex
class	plane
class	point
class	polygon
class	Rect3d
class	Triangulate
class	TVec
class	Vec3

Typedefs
typedef std::vector< uint32_t >	UintVector
typedef uint32_t	TU32
typedef std::vector< TVec >	TVecVector
typedef std::vector< TU32 >	TU32Vector

Enumerations
enum	FM_ClipState {   FMCS_XMIN = (1 << 0) , FMCS_XMAX = (1 << 1) , FMCS_YMIN = (1 << 2) , FMCS_YMAX = (1 << 3) ,   FMCS_ZMIN = (1 << 4) , FMCS_ZMAX = (1 << 5) }
enum	FM_Axis { FM_XAXIS = (1 << 0) , FM_YAXIS = (1 << 1) , FM_ZAXIS = (1 << 2) }
enum	LineSegmentType { LS_START , LS_MIDDLE , LS_END }
enum	IntersectResult { IR_DONT_INTERSECT , IR_DO_INTERSECT , IR_COINCIDENT , IR_PARALLEL }
enum	PlaneTriResult { PTR_ON_PLANE , PTR_FRONT , PTR_BACK , PTR_SPLIT }

Functions
FM_Axis	fm_getDominantAxis (const float normal[3])
FM_Axis	fm_getDominantAxis (const double normal[3])
void	fm_decomposeTransform (const float local_transform[16], float trans[3], float rot[4], float scale[3])
void	fm_decomposeTransform (const double local_transform[16], double trans[3], double rot[4], double scale[3])
void	fm_multiplyTransform (const float *pA, const float *pB, float *pM)
void	fm_multiplyTransform (const double *pA, const double *pB, double *pM)
void	fm_inverseTransform (const float matrix[16], float inverse_matrix[16])
void	fm_inverseTransform (const double matrix[16], double inverse_matrix[16])
void	fm_identity (float matrix[16])
void	fm_identity (double matrix[16])
void	fm_inverseRT (const float matrix[16], const float pos[3], float t[3])
void	fm_inverseRT (const double matrix[16], const double pos[3], double t[3])
void	fm_transform (const float matrix[16], const float pos[3], float t[3])
void	fm_transform (const double matrix[16], const double pos[3], double t[3])
float	fm_getDeterminant (const float matrix[16])
double	fm_getDeterminant (const double matrix[16])
void	fm_getSubMatrix (int32_t ki, int32_t kj, float pDst[16], const float matrix[16])
void	fm_getSubMatrix (int32_t ki, int32_t kj, double pDst[16], const float matrix[16])
void	fm_rotate (const float matrix[16], const float pos[3], float t[3])
void	fm_rotate (const double matri[16], const double pos[3], double t[3])
void	fm_eulerToMatrix (float ax, float ay, float az, float matrix[16])
void	fm_eulerToMatrix (double ax, double ay, double az, double matrix[16])
void	fm_getAABB (uint32_t vcount, const float *points, uint32_t pstride, float bmin[3], float bmax[3])
void	fm_getAABB (uint32_t vcount, const double *points, uint32_t pstride, double bmin[3], double bmax[3])
void	fm_getAABBCenter (const float bmin[3], const float bmax[3], float center[3])
void	fm_getAABBCenter (const double bmin[3], const double bmax[3], double center[3])
void	fm_transformAABB (const float bmin[3], const float bmax[3], const float matrix[16], float tbmin[3], float tbmax[3])
void	fm_transformAABB (const double bmin[3], const double bmax[3], const double matrix[16], double tbmin[3], double tbmax[3])
void	fm_eulerToQuat (float x, float y, float z, float quat[4])
void	fm_eulerToQuat (double x, double y, double z, double quat[4])
void	fm_quatToEuler (const float quat[4], float &ax, float &ay, float &az)
void	fm_quatToEuler (const double quat[4], double &ax, double &ay, double &az)
void	fm_eulerToQuat (const float euler[3], float quat[4])
void	fm_eulerToQuat (const double euler[3], double quat[4])
void	fm_scale (float x, float y, float z, float matrix[16])
void	fm_scale (double x, double y, double z, double matrix[16])
void	fm_eulerToQuatDX (float x, float y, float z, float quat[4])
void	fm_eulerToQuatDX (double x, double y, double z, double quat[4])
void	fm_eulerToMatrixDX (float x, float y, float z, float matrix[16])
void	fm_eulerToMatrixDX (double x, double y, double z, double matrix[16])
void	fm_quatToMatrix (const float quat[4], float matrix[16])
void	fm_quatToMatrix (const double quat[4], double matrix[16])
void	fm_quatRotate (const float quat[4], const float v[3], float r[3])
void	fm_quatRotate (const double quat[4], const double v[3], double r[3])
void	fm_getTranslation (const float matrix[16], float t[3])
void	fm_getTranslation (const double matrix[16], double t[3])
void	fm_setTranslation (const float *translation, float matrix[16])
void	fm_setTranslation (const double *translation, double matrix[16])
void	fm_multiplyQuat (const float *qa, const float *qb, float *quat)
void	fm_multiplyQuat (const double *qa, const double *qb, double *quat)
void	fm_matrixToQuat (const float matrix[16], float quat[4])
void	fm_matrixToQuat (const double matrix[16], double quat[4])
float	fm_sphereVolume (float radius)
double	fm_sphereVolume (double radius)
float	fm_cylinderVolume (float radius, float h)
double	fm_cylinderVolume (double radius, double h)
float	fm_capsuleVolume (float radius, float h)
double	fm_capsuleVolume (double radius, double h)
float	fm_distance (const float p1[3], const float p2[3])
double	fm_distance (const double p1[3], const double p2[3])
float	fm_distanceSquared (const float p1[3], const float p2[3])
double	fm_distanceSquared (const double p1[3], const double p2[3])
float	fm_distanceSquaredXZ (const float p1[3], const float p2[3])
double	fm_distanceSquaredXZ (const double p1[3], const double p2[3])
float	fm_computePlane (const float p1[3], const float p2[3], const float p3[3], float *n)
double	fm_computePlane (const double p1[3], const double p2[3], const double p3[3], double *n)
float	fm_distToPlane (const float plane[4], const float pos[3])
double	fm_distToPlane (const double plane[4], const double pos[3])
float	fm_dot (const float p1[3], const float p2[3])
double	fm_dot (const double p1[3], const double p2[3])
void	fm_cross (float cross[3], const float a[3], const float b[3])
void	fm_cross (double cross[3], const double a[3], const double b[3])
float	fm_computeNormalVector (float n[3], const float p1[3], const float p2[3])
double	fm_computeNormalVector (double n[3], const double p1[3], const double p2[3])
bool	fm_computeWindingOrder (const float p1[3], const float p2[3], const float p3[3])
bool	fm_computeWindingOrder (const double p1[3], const double p2[3], const double p3[3])
float	fm_normalize (float n[3])
double	fm_normalize (double n[3])
float	fm_normalizeQuat (float n[4])
double	fm_normalizeQuat (double n[4])
void	fm_matrixMultiply (const float A[16], const float B[16], float dest[16])
void	fm_matrixMultiply (const double A[16], const double B[16], double dest[16])
void	fm_composeTransform (const float position[3], const float quat[4], const float scale[3], float matrix[16])
void	fm_composeTransform (const double position[3], const double quat[4], const double scale[3], double matrix[16])
float	fm_computeArea (const float p1[3], const float p2[3], const float p3[3])
double	fm_computeArea (const double p1[3], const double p2[3], const double p3[3])
void	fm_lerp (const float p1[3], const float p2[3], float dest[3], float lerpValue)
void	fm_lerp (const double p1[3], const double p2[3], double dest[3], double lerpValue)
bool	fm_insideTriangleXZ (const float test[3], const float p1[3], const float p2[3], const float p3[3])
bool	fm_insideTriangleXZ (const double test[3], const double p1[3], const double p2[3], const double p3[3])
bool	fm_insideAABB (const float pos[3], const float bmin[3], const float bmax[3])
bool	fm_insideAABB (const double pos[3], const double bmin[3], const double bmax[3])
bool	fm_insideAABB (const float obmin[3], const float obmax[3], const float tbmin[3], const float tbmax[3])
bool	fm_insideAABB (const double obmin[3], const double obmax[3], const double tbmin[3], const double tbmax[3])
uint32_t	fm_clipTestPoint (const float bmin[3], const float bmax[3], const float pos[3])
uint32_t	fm_clipTestPoint (const double bmin[3], const double bmax[3], const double pos[3])
uint32_t	fm_clipTestPointXZ (const float bmin[3], const float bmax[3], const float pos[3])
uint32_t	fm_clipTestPointXZ (const double bmin[3], const double bmax[3], const double pos[3])
uint32_t	fm_clipTestAABB (const float bmin[3], const float bmax[3], const float p1[3], const float p2[3], const float p3[3], uint32_t &andCode)
uint32_t	fm_clipTestAABB (const double bmin[3], const double bmax[3], const double p1[3], const double p2[3], const double p3[3], uint32_t &andCode)
bool	fm_lineTestAABBXZ (const float p1[3], const float p2[3], const float bmin[3], const float bmax[3], float &time)
bool	fm_lineTestAABBXZ (const double p1[3], const double p2[3], const double bmin[3], const double bmax[3], double &time)
bool	fm_lineTestAABB (const float p1[3], const float p2[3], const float bmin[3], const float bmax[3], float &time)
bool	fm_lineTestAABB (const double p1[3], const double p2[3], const double bmin[3], const double bmax[3], double &time)
void	fm_initMinMax (const float p[3], float bmin[3], float bmax[3])
void	fm_initMinMax (const double p[3], double bmin[3], double bmax[3])
void	fm_initMinMax (float bmin[3], float bmax[3])
void	fm_initMinMax (double bmin[3], double bmax[3])
void	fm_minmax (const float p[3], float bmin[3], float bmax[3])
void	fm_minmax (const double p[3], double bmin[3], double bmax[3])
void	fm_inflateMinMax (float bmin[3], float bmax[3], float ratio)
void	fm_inflateMinMax (double bmin[3], double bmax[3], double ratio)
float	fm_solveX (const float plane[4], float y, float z)
double	fm_solveX (const double plane[4], double y, double z)
float	fm_solveY (const float plane[4], float x, float z)
double	fm_solveY (const double plane[4], double x, double z)
float	fm_solveZ (const float plane[4], float x, float y)
double	fm_solveZ (const double plane[4], double x, double y)
bool	fm_computeBestFitPlane (uint32_t vcount, const float *points, uint32_t vstride, const float *weights, uint32_t wstride, float plane[4], float center[3])
bool	fm_computeBestFitPlane (uint32_t vcount, const double *points, uint32_t vstride, const double *weights, uint32_t wstride, double plane[4], double center[3])
bool	fm_computeCentroid (uint32_t vcount, const float *points, float *center)
bool	fm_computeCentroid (uint32_t vcount, const double *points, double *center)
bool	fm_computeCentroid (uint32_t vcount, const float *points, uint32_t triangleCount, const uint32_t *indices, float *center)
bool	fm_computeCentroid (uint32_t vcount, const double *points, uint32_t triangleCount, const uint32_t *indices, double *center)
float	fm_computeBestFitAABB (uint32_t vcount, const float *points, uint32_t pstride, float bmin[3], float bmax[3])
double	fm_computeBestFitAABB (uint32_t vcount, const double *points, uint32_t pstride, double bmin[3], double bmax[3])
float	fm_computeBestFitSphere (uint32_t vcount, const float *points, uint32_t pstride, float center[3])
double	fm_computeBestFitSphere (uint32_t vcount, const double *points, uint32_t pstride, double center[3])
bool	fm_lineSphereIntersect (const float center[3], float radius, const float p1[3], const float p2[3], float intersect[3])
bool	fm_lineSphereIntersect (const double center[3], double radius, const double p1[3], const double p2[3], double intersect[3])
bool	fm_intersectRayAABB (const float bmin[3], const float bmax[3], const float pos[3], const float dir[3], float intersect[3])
bool	fm_intersectLineSegmentAABB (const float bmin[3], const float bmax[3], const float p1[3], const float p2[3], float intersect[3])
bool	fm_lineIntersectsTriangle (const float rayStart[3], const float rayEnd[3], const float p1[3], const float p2[3], const float p3[3], float sect[3])
bool	fm_lineIntersectsTriangle (const double rayStart[3], const double rayEnd[3], const double p1[3], const double p2[3], const double p3[3], double sect[3])
bool	fm_rayIntersectsTriangle (const float origin[3], const float dir[3], const float v0[3], const float v1[3], const float v2[3], float &t)
bool	fm_rayIntersectsTriangle (const double origin[3], const double dir[3], const double v0[3], const double v1[3], const double v2[3], double &t)
bool	fm_raySphereIntersect (const float center[3], float radius, const float pos[3], const float dir[3], float distance, float intersect[3])
bool	fm_raySphereIntersect (const double center[3], double radius, const double pos[3], const double dir[3], double distance, double intersect[3])
void	fm_catmullRom (float out_vector[3], const float p1[3], const float p2[3], const float p3[3], const float *p4, const float s)
void	fm_catmullRom (double out_vector[3], const double p1[3], const double p2[3], const double p3[3], const double *p4, const double s)
bool	fm_intersectAABB (const float bmin1[3], const float bmax1[3], const float bmin2[3], const float bmax2[3])
bool	fm_intersectAABB (const double bmin1[3], const double bmax1[3], const double bmin2[3], const double bmax2[3])
void	fm_rotationArc (const float v0[3], const float v1[3], float quat[4])
void	fm_rotationArc (const double v0[3], const double v1[3], double quat[4])
float	fm_distancePointLineSegment (const float Point[3], const float LineStart[3], const float LineEnd[3], float intersection[3], LineSegmentType &type, float epsilon)
double	fm_distancePointLineSegment (const double Point[3], const double LineStart[3], const double LineEnd[3], double intersection[3], LineSegmentType &type, double epsilon)
bool	fm_colinear (const double p1[3], const double p2[3], const double p3[3], double epsilon=0.999)
bool	fm_colinear (const float p1[3], const float p2[3], const float p3[3], float epsilon=0.999f)
bool	fm_colinear (const float a1[3], const float a2[3], const float b1[3], const float b2[3], float epsilon=0.999f)
bool	fm_colinear (const double a1[3], const double a2[3], const double b1[3], const double b2[3], double epsilon=0.999)
IntersectResult	fm_intersectLineSegments2d (const float a1[3], const float a2[3], const float b1[3], const float b2[3], float intersectionPoint[3])
IntersectResult	fm_intersectLineSegments2d (const double a1[3], const double a2[3], const double b1[3], const double b2[3], double intersectionPoint[3])
IntersectResult	fm_intersectLineSegments2dTime (const float a1[3], const float a2[3], const float b1[3], const float b2[3], float &t1, float &t2)
IntersectResult	fm_intersectLineSegments2dTime (const double a1[3], const double a2[3], const double b1[3], const double b2[3], double &t1, double &t2)
PlaneTriResult	fm_planeTriIntersection (const float plane[4], const float *triangle, uint32_t tstride, float epsilon, float *front, uint32_t &fcount, float *back, uint32_t &bcount)
PlaneTriResult	fm_planeTriIntersection (const double plane[4], const double *triangle, uint32_t tstride, double epsilon, double *front, uint32_t &fcount, double *back, uint32_t &bcount)
bool	fm_intersectPointPlane (const float p1[3], const float p2[3], float *split, const float plane[4])
bool	fm_intersectPointPlane (const double p1[3], const double p2[3], double *split, const double plane[4])
PlaneTriResult	fm_getSidePlane (const float p[3], const float plane[4], float epsilon)
PlaneTriResult	fm_getSidePlane (const double p[3], const double plane[4], double epsilon)
void	fm_computeBestFitOBB (uint32_t vcount, const float *points, uint32_t pstride, float *sides, float matrix[16], bool bruteForce=true)
void	fm_computeBestFitOBB (uint32_t vcount, const double *points, uint32_t pstride, double *sides, double matrix[16], bool bruteForce=true)
void	fm_computeBestFitOBB (uint32_t vcount, const float *points, uint32_t pstride, float *sides, float pos[3], float quat[4], bool bruteForce=true)
void	fm_computeBestFitOBB (uint32_t vcount, const double *points, uint32_t pstride, double *sides, double pos[3], double quat[4], bool bruteForce=true)
void	fm_computeBestFitABB (uint32_t vcount, const float *points, uint32_t pstride, float *sides, float pos[3])
void	fm_computeBestFitABB (uint32_t vcount, const double *points, uint32_t pstride, double *sides, double pos[3])
void	fm_computeBestFitCapsule (uint32_t vcount, const float *points, uint32_t pstride, float &radius, float &height, float matrix[16], bool bruteForce=true)
void	fm_computeBestFitCapsule (uint32_t vcount, const double *points, uint32_t pstride, float &radius, float &height, double matrix[16], bool bruteForce=true)
void	fm_planeToMatrix (const float plane[4], float matrix[16])
void	fm_planeToQuat (const float plane[4], float quat[4], float pos[3])
void	fm_planeToMatrix (const double plane[4], double matrix[16])
void	fm_planeToQuat (const double plane[4], double quat[4], double pos[3])
void	fm_doubleToFloat3 (const double p[3], float t[3])
void	fm_floatToDouble3 (const float p[3], double t[3])
void	fm_eulerMatrix (float ax, float ay, float az, float matrix[16])
void	fm_eulerMatrix (double ax, double ay, double az, double matrix[16])
float	fm_computeMeshVolume (const float *vertices, uint32_t tcount, const uint32_t *indices)
double	fm_computeMeshVolume (const double *vertices, uint32_t tcount, const uint32_t *indices)
fm_VertexIndex *	fm_createVertexIndex (double granularity, bool snapToGrid)
fm_VertexIndex *	fm_createVertexIndex (float granularity, bool snapToGrid)
void	fm_releaseVertexIndex (fm_VertexIndex *vindex)
fm_Triangulate *	fm_createTriangulate (void)
void	fm_releaseTriangulate (fm_Triangulate *t)
const float *	fm_getPoint (const float *points, uint32_t pstride, uint32_t index)
const double *	fm_getPoint (const double *points, uint32_t pstride, uint32_t index)
bool	fm_insideTriangle (float Ax, float Ay, float Bx, float By, float Cx, float Cy, float Px, float Py)
bool	fm_insideTriangle (double Ax, double Ay, double Bx, double By, double Cx, double Cy, double Px, double Py)
float	fm_areaPolygon2d (uint32_t pcount, const float *points, uint32_t pstride)
double	fm_areaPolygon2d (uint32_t pcount, const double *points, uint32_t pstride)
bool	fm_pointInsidePolygon2d (uint32_t pcount, const float *points, uint32_t pstride, const float *point, uint32_t xindex=0, uint32_t yindex=1)
bool	fm_pointInsidePolygon2d (uint32_t pcount, const double *points, uint32_t pstride, const double *point, uint32_t xindex=0, uint32_t yindex=1)
uint32_t	fm_consolidatePolygon (uint32_t pcount, const float *points, uint32_t pstride, float *dest, float epsilon=0.999999f)
uint32_t	fm_consolidatePolygon (uint32_t pcount, const double *points, uint32_t pstride, double *dest, double epsilon=0.999999)
bool	fm_computeSplitPlane (uint32_t vcount, const double *vertices, uint32_t tcount, const uint32_t *indices, double *plane)
bool	fm_computeSplitPlane (uint32_t vcount, const float *vertices, uint32_t tcount, const uint32_t *indices, float *plane)
void	fm_nearestPointInTriangle (const float *pos, const float *p1, const float *p2, const float *p3, float *nearest)
void	fm_nearestPointInTriangle (const double *pos, const double *p1, const double *p2, const double *p3, double *nearest)
float	fm_areaTriangle (const float *p1, const float *p2, const float *p3)
double	fm_areaTriangle (const double *p1, const double *p2, const double *p3)
void	fm_subtract (const float *A, const float *B, float *diff)
void	fm_subtract (const double *A, const double *B, double *diff)
void	fm_multiply (float *A, float scaler)
void	fm_multiply (double *A, double scaler)
void	fm_add (const float *A, const float *B, float *sum)
void	fm_add (const double *A, const double *B, double *sum)
void	fm_copy3 (const float *source, float *dest)
void	fm_copy3 (const double *source, double *dest)
uint32_t	fm_copyUniqueVertices (uint32_t vcount, const float *input_vertices, float *output_vertices, uint32_t tcount, const uint32_t *input_indices, uint32_t *output_indices)
uint32_t	fm_copyUniqueVertices (uint32_t vcount, const double *input_vertices, double *output_vertices, uint32_t tcount, const uint32_t *input_indices, uint32_t *output_indices)
bool	fm_isMeshCoplanar (uint32_t tcount, const uint32_t *indices, const float *vertices, bool doubleSided)
bool	fm_isMeshCoplanar (uint32_t tcount, const uint32_t *indices, const double *vertices, bool doubleSided)
bool	fm_samePlane (const float p1[4], const float p2[4], float normalEpsilon=0.01f, float dEpsilon=0.001f, bool doubleSided=false)
bool	fm_samePlane (const double p1[4], const double p2[4], double normalEpsilon=0.01, double dEpsilon=0.001, bool doubleSided=false)
void	fm_OBBtoAABB (const float obmin[3], const float obmax[3], const float matrix[16], float abmin[3], float abmax[3])
fm_Tesselate *	fm_createTesselate (void)
void	fm_releaseTesselate (fm_Tesselate *t)
void	fm_computeMeanNormals (uint32_t vcount, const float *vertices, uint32_t vstride, float *normals, uint32_t nstride, uint32_t tcount, const uint32_t *indices)
void	fm_computeMeanNormals (uint32_t vcount, const double *vertices, uint32_t vstride, double *normals, uint32_t nstride, uint32_t tcount, const uint32_t *indices)
bool	fm_isValidTriangle (const float *p1, const float *p2, const float *p3, float epsilon=0.00001f)
bool	fm_isValidTriangle (const double *p1, const double *p2, const double *p3, double epsilon=0.00001)
void	fm_inverseRT (const REAL matrix[16], const REAL pos[3], REAL t[3])
REAL	fm_getDeterminant (const REAL matrix[16])
REAL	fm_squared (REAL x)
void	fm_decomposeTransform (const REAL local_transform[16], REAL trans[3], REAL rot[4], REAL scale[3])
void	fm_getSubMatrix (int32_t ki, int32_t kj, REAL pDst[16], const REAL matrix[16])
void	fm_inverseTransform (const REAL matrix[16], REAL inverse_matrix[16])
void	fm_identity (REAL matrix[16])
void	fm_quatToEuler (const REAL quat[4], REAL &ax, REAL &ay, REAL &az)
void	fm_eulerToMatrix (REAL ax, REAL ay, REAL az, REAL *matrix)
void	fm_getAABB (uint32_t vcount, const REAL *points, uint32_t pstride, REAL *bmin, REAL *bmax)
void	fm_eulerToQuat (const REAL *euler, REAL *quat)
void	fm_eulerToQuat (REAL roll, REAL pitch, REAL yaw, REAL *quat)
void	fm_quatToMatrix (const REAL *quat, REAL *matrix)
void	fm_quatRotate (const REAL *quat, const REAL *v, REAL *r)
void	fm_getTranslation (const REAL *matrix, REAL *t)
void	fm_matrixToQuat (const REAL *matrix, REAL *quat)
REAL	fm_sphereVolume (REAL radius)
REAL	fm_cylinderVolume (REAL radius, REAL h)
REAL	fm_capsuleVolume (REAL radius, REAL h)
void	fm_transform (const REAL matrix[16], const REAL v[3], REAL t[3])
void	fm_rotate (const REAL matrix[16], const REAL v[3], REAL t[3])
REAL	fm_distance (const REAL *p1, const REAL *p2)
REAL	fm_distanceSquared (const REAL *p1, const REAL *p2)
REAL	fm_distanceSquaredXZ (const REAL *p1, const REAL *p2)
REAL	fm_computePlane (const REAL *A, const REAL *B, const REAL *C, REAL *n)
REAL	fm_distToPlane (const REAL *plane, const REAL *p)
REAL	fm_dot (const REAL *p1, const REAL *p2)
void	fm_cross (REAL *cross, const REAL *a, const REAL *b)
REAL	fm_computeNormalVector (REAL *n, const REAL *p1, const REAL *p2)
bool	fm_computeWindingOrder (const REAL *p1, const REAL *p2, const REAL *p3)
REAL	fm_normalize (REAL *n)
void	fm_matrixMultiply (const REAL *pA, const REAL *pB, REAL *pM)
void	fm_eulerToQuatDX (REAL x, REAL y, REAL z, REAL *quat)
void	fm_eulerToMatrixDX (REAL x, REAL y, REAL z, REAL *matrix)
void	fm_scale (REAL x, REAL y, REAL z, REAL *fscale)
void	fm_composeTransform (const REAL *position, const REAL *quat, const REAL *scale, REAL *matrix)
void	fm_setTranslation (const REAL *translation, REAL *matrix)
static REAL	enorm0_3d (REAL x0, REAL y0, REAL z0, REAL x1, REAL y1, REAL z1)
static REAL	triangle_area_3d (REAL x1, REAL y1, REAL z1, REAL x2, REAL y2, REAL z2, REAL x3, REAL y3, REAL z3)
REAL	fm_computeArea (const REAL *p1, const REAL *p2, const REAL *p3)
void	fm_lerp (const REAL *p1, const REAL *p2, REAL *dest, REAL lerpValue)
bool	fm_pointTestXZ (const REAL *p, const REAL *i, const REAL *j)
bool	fm_insideTriangleXZ (const REAL *p, const REAL *p1, const REAL *p2, const REAL *p3)
bool	fm_insideAABB (const REAL *pos, const REAL *bmin, const REAL *bmax)
uint32_t	fm_clipTestPoint (const REAL *bmin, const REAL *bmax, const REAL *pos)
uint32_t	fm_clipTestPointXZ (const REAL *bmin, const REAL *bmax, const REAL *pos)
uint32_t	fm_clipTestAABB (const REAL *bmin, const REAL *bmax, const REAL *p1, const REAL *p2, const REAL *p3, uint32_t &andCode)
bool	intersect (const REAL *si, const REAL *ei, const REAL *bmin, const REAL *bmax, REAL *time)
bool	fm_lineTestAABB (const REAL *p1, const REAL *p2, const REAL *bmin, const REAL *bmax, REAL &time)
bool	fm_lineTestAABBXZ (const REAL *p1, const REAL *p2, const REAL *bmin, const REAL *bmax, REAL &time)
void	fm_minmax (const REAL *p, REAL *bmin, REAL *bmax)
REAL	fm_solveX (const REAL *plane, REAL y, REAL z)
REAL	fm_solveY (const REAL *plane, REAL x, REAL z)
REAL	fm_solveZ (const REAL *plane, REAL x, REAL y)
void	fm_getAABBCenter (const REAL *bmin, const REAL *bmax, REAL *center)
FM_Axis	fm_getDominantAxis (const REAL normal[3])
bool	fm_lineSphereIntersect (const REAL *center, REAL radius, const REAL *p1, const REAL *p2, REAL *intersect)
bool	fm_raySphereIntersect (const REAL *center, REAL radius, const REAL *pos, const REAL *dir, REAL distance, REAL *intersect)
void	fm_catmullRom (REAL *out_vector, const REAL *p1, const REAL *p2, const REAL *p3, const REAL *p4, const REAL s)
bool	fm_intersectAABB (const REAL *bmin1, const REAL *bmax1, const REAL *bmin2, const REAL *bmax2)
bool	fm_insideAABB (const REAL *obmin, const REAL *obmax, const REAL *tbmin, const REAL *tbmax)
void	fm_rotationArc (const REAL *v0, const REAL *v1, REAL *quat)
REAL	fm_distancePointLineSegment (const REAL *Point, const REAL *LineStart, const REAL *LineEnd, REAL *intersection, LineSegmentType &type, REAL epsilon)
bool	fm_computeBestFitPlane (uint32_t vcount, const REAL *points, uint32_t vstride, const REAL *weights, uint32_t wstride, REAL *plane, REAL *center)
bool	fm_colinear (const REAL a1[3], const REAL a2[3], const REAL b1[3], const REAL b2[3], REAL epsilon)
bool	fm_colinear (const REAL *p1, const REAL *p2, const REAL *p3, REAL epsilon)
void	fm_initMinMax (const REAL *p, REAL *bmin, REAL *bmax)
IntersectResult	fm_intersectLineSegments2d (const REAL *a1, const REAL *a2, const REAL *b1, const REAL *b2, REAL *intersection)
IntersectResult	fm_intersectLineSegments2dTime (const REAL *a1, const REAL *a2, const REAL *b1, const REAL *b2, REAL &t1, REAL &t2)
bool	fm_intersectPointPlane (const REAL *p1, const REAL *p2, REAL *split, const REAL *plane)
PlaneTriResult	fm_getSidePlane (const REAL *p, const REAL *plane, REAL epsilon)
static void	add (const REAL *p, REAL *dest, uint32_t tstride, uint32_t &pcount)
PlaneTriResult	fm_planeTriIntersection (const REAL *_plane, const REAL *triangle, uint32_t tstride, REAL epsilon, REAL *front, uint32_t &fcount, REAL *back, uint32_t &bcount)
void	computeOBB (uint32_t vcount, const REAL *points, uint32_t pstride, REAL *sides, REAL *matrix)
void	fm_computeBestFitOBB (uint32_t vcount, const REAL *points, uint32_t pstride, REAL *sides, REAL *matrix, bool bruteForce)
void	fm_computeBestFitOBB (uint32_t vcount, const REAL *points, uint32_t pstride, REAL *sides, REAL *pos, REAL *quat, bool bruteForce)
void	fm_computeBestFitABB (uint32_t vcount, const REAL *points, uint32_t pstride, REAL *sides, REAL *pos)
void	fm_planeToMatrix (const REAL *plane, REAL *matrix)
void	fm_planeToQuat (const REAL *plane, REAL *quat, REAL *pos)
void	fm_eulerMatrix (REAL ax, REAL ay, REAL az, REAL *matrix)
REAL	fm_computeBestFitAABB (uint32_t vcount, const REAL *points, uint32_t pstride, REAL *bmin, REAL *bmax)
bool	fm_lineIntersectsTriangle (const REAL *rayStart, const REAL *rayEnd, const REAL *p1, const REAL *p2, const REAL *p3, REAL *sect)
bool	fm_rayIntersectsTriangle (const REAL *p, const REAL *d, const REAL *v0, const REAL *v1, const REAL *v2, REAL &t)
REAL	det (const REAL *p1, const REAL *p2, const REAL *p3)
REAL	fm_computeMeshVolume (const REAL *vertices, uint32_t tcount, const uint32_t *indices)
const REAL *	fm_getPoint (const REAL *points, uint32_t pstride, uint32_t index)
bool	fm_insideTriangle (REAL Ax, REAL Ay, REAL Bx, REAL By, REAL Cx, REAL Cy, REAL Px, REAL Py)
REAL	fm_areaPolygon2d (uint32_t pcount, const REAL *points, uint32_t pstride)
bool	fm_pointInsidePolygon2d (uint32_t pcount, const REAL *points, uint32_t pstride, const REAL *point, uint32_t xindex, uint32_t yindex)
uint32_t	fm_consolidatePolygon (uint32_t pcount, const REAL *points, uint32_t pstride, REAL *_dest, REAL epsilon)
void	splitRect (uint32_t axis, const Rect3d< REAL > &source, Rect3d< REAL > &b1, Rect3d< REAL > &b2, const REAL *midpoint)
bool	fm_computeSplitPlane (uint32_t vcount, const REAL *vertices, uint32_t, const uint32_t *, REAL *plane)
void	fm_nearestPointInTriangle (const REAL *, const REAL *, const REAL *, const REAL *, REAL *)
static REAL	Partial (const REAL *a, const REAL *p)
REAL	fm_areaTriangle (const REAL *p0, const REAL *p1, const REAL *p2)
void	fm_subtract (const REAL *A, const REAL *B, REAL *diff)
void	fm_multiplyTransform (const REAL *pA, const REAL *pB, REAL *pM)
void	fm_multiply (REAL *A, REAL scaler)
void	fm_add (const REAL *A, const REAL *B, REAL *sum)
void	fm_copy3 (const REAL *source, REAL *dest)
uint32_t	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	fm_isMeshCoplanar (uint32_t tcount, const uint32_t *indices, const REAL *vertices, bool doubleSided)
bool	fm_samePlane (const REAL p1[4], const REAL p2[4], REAL normalEpsilon, REAL dEpsilon, bool doubleSided)
void	fm_initMinMax (REAL bmin[3], REAL bmax[3])
void	fm_inflateMinMax (REAL bmin[3], REAL bmax[3], REAL ratio)
const REAL *	computePos (uint32_t index, const REAL *vertices, uint32_t vstride)
void	computeNormal (uint32_t index, REAL *normals, uint32_t nstride, const REAL *normal)
void	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	Set (REAL *n, REAL x, REAL y, REAL z)
static void	Copy (REAL *dest, const REAL *source)
REAL	fm_computeBestFitSphere (uint32_t vcount, const REAL *points, uint32_t pstride, REAL *center)
void	fm_computeBestFitCapsule (uint32_t vcount, const REAL *points, uint32_t pstride, REAL &radius, REAL &height, REAL matrix[16], bool bruteForce)
bool	validDistance (const REAL *p1, const REAL *p2, REAL epsilon)
bool	fm_isValidTriangle (const REAL *p1, const REAL *p2, const REAL *p3, REAL epsilon)
void	fm_multiplyQuat (const REAL *left, const REAL *right, REAL *quat)
bool	fm_computeCentroid (uint32_t vcount, const REAL *points, REAL *center)
bool	fm_computeCentroid (uint32_t vcount, const REAL *points, uint32_t triCount, const uint32_t *indices, REAL *center)
void	fm_transformAABB (const REAL bmin[3], const REAL bmax[3], const REAL matrix[16], REAL tbmin[3], REAL tbmax[3])
REAL	fm_normalizeQuat (REAL n[4])

Variables
const float	FM_PI = 3.1415926535897932384626433832795028841971693993751f
const float	FM_DEG_TO_RAD = ((2.0f * FM_PI) / 360.0f)
const float	FM_RAD_TO_DEG = (360.0f / (2.0f * FM_PI))

Typedef Documentation

TU32

typedef uint32_t tesseract_collision::FLOAT_MATH::TU32

TU32Vector

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

TVecVector

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

UintVector

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

Enumeration Type Documentation

FM_Axis

enum tesseract_collision::FLOAT_MATH::FM_Axis

Enumerator
FM_XAXIS
FM_YAXIS
FM_ZAXIS

FM_ClipState

enum tesseract_collision::FLOAT_MATH::FM_ClipState

Enumerator
FMCS_XMIN
FMCS_XMAX
FMCS_YMIN
FMCS_YMAX
FMCS_ZMIN
FMCS_ZMAX

IntersectResult

enum tesseract_collision::FLOAT_MATH::IntersectResult

Enumerator
IR_DONT_INTERSECT
IR_DO_INTERSECT
IR_COINCIDENT
IR_PARALLEL

LineSegmentType

enum tesseract_collision::FLOAT_MATH::LineSegmentType

Enumerator
LS_START
LS_MIDDLE
LS_END

PlaneTriResult

enum tesseract_collision::FLOAT_MATH::PlaneTriResult

Enumerator
PTR_ON_PLANE
PTR_FRONT
PTR_BACK
PTR_SPLIT

Function Documentation

add()

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

inlinestatic

computeNormal()

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

computeOBB()

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

computePos()

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

Copy()

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

inlinestatic

det()

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

inline

enorm0_3d()

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

static

fm_add() [1/3]

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

fm_add() [2/3]

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

fm_add() [3/3]

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

fm_areaPolygon2d() [1/3]

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

fm_areaPolygon2d() [2/3]

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

fm_areaPolygon2d() [3/3]

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

fm_areaTriangle() [1/3]

double tesseract_collision::FLOAT_MATH::fm_areaTriangle	(	const double *	p1,
		const double *	p2,
		const double *	p3
	)

fm_areaTriangle() [2/3]

float tesseract_collision::FLOAT_MATH::fm_areaTriangle	(	const float *	p1,
		const float *	p2,
		const float *	p3
	)

fm_areaTriangle() [3/3]

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

fm_capsuleVolume() [1/3]

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

fm_capsuleVolume() [2/3]

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

fm_capsuleVolume() [3/3]

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

fm_catmullRom() [1/3]

void tesseract_collision::FLOAT_MATH::fm_catmullRom	(	double	out_vector[3],
		const double	p1[3],
		const double	p2[3],
		const double	p3[3],
		const double *	p4,
		const double	s
	)

fm_catmullRom() [2/3]

void tesseract_collision::FLOAT_MATH::fm_catmullRom	(	float	out_vector[3],
		const float	p1[3],
		const float	p2[3],
		const float	p3[3],
		const float *	p4,
		const float	s
	)

fm_catmullRom() [3/3]

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
	)

fm_clipTestAABB() [1/3]

uint32_t tesseract_collision::FLOAT_MATH::fm_clipTestAABB	(	const double	bmin[3],
		const double	bmax[3],
		const double	p1[3],
		const double	p2[3],
		const double	p3[3],
		uint32_t &	andCode
	)

fm_clipTestAABB() [2/3]

uint32_t tesseract_collision::FLOAT_MATH::fm_clipTestAABB	(	const float	bmin[3],
		const float	bmax[3],
		const float	p1[3],
		const float	p2[3],
		const float	p3[3],
		uint32_t &	andCode
	)

fm_clipTestAABB() [3/3]

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
	)

fm_clipTestPoint() [1/3]

uint32_t tesseract_collision::FLOAT_MATH::fm_clipTestPoint	(	const double	bmin[3],
		const double	bmax[3],
		const double	pos[3]
	)

fm_clipTestPoint() [2/3]

uint32_t tesseract_collision::FLOAT_MATH::fm_clipTestPoint	(	const float	bmin[3],
		const float	bmax[3],
		const float	pos[3]
	)

fm_clipTestPoint() [3/3]

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

fm_clipTestPointXZ() [1/3]

uint32_t tesseract_collision::FLOAT_MATH::fm_clipTestPointXZ	(	const double	bmin[3],
		const double	bmax[3],
		const double	pos[3]
	)

fm_clipTestPointXZ() [2/3]

uint32_t tesseract_collision::FLOAT_MATH::fm_clipTestPointXZ	(	const float	bmin[3],
		const float	bmax[3],
		const float	pos[3]
	)

fm_clipTestPointXZ() [3/3]

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

fm_colinear() [1/6]

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

fm_colinear() [2/6]

bool tesseract_collision::FLOAT_MATH::fm_colinear	(	const double	p1[3],
		const double	p2[3],
		const double	p3[3],
		double	epsilon = 0.999
	)

fm_colinear() [3/6]

bool tesseract_collision::FLOAT_MATH::fm_colinear	(	const float	a1[3],
		const float	a2[3],
		const float	b1[3],
		const float	b2[3],
		float	epsilon = 0.999f
	)

fm_colinear() [4/6]

bool tesseract_collision::FLOAT_MATH::fm_colinear	(	const float	p1[3],
		const float	p2[3],
		const float	p3[3],
		float	epsilon = 0.999f
	)

fm_colinear() [5/6]

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

fm_colinear() [6/6]

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
	)

fm_composeTransform() [1/3]

void tesseract_collision::FLOAT_MATH::fm_composeTransform	(	const double	position[3],
		const double	quat[4],
		const double	scale[3],
		double	matrix[16]
	)

fm_composeTransform() [2/3]

void tesseract_collision::FLOAT_MATH::fm_composeTransform	(	const float	position[3],
		const float	quat[4],
		const float	scale[3],
		float	matrix[16]
	)

fm_composeTransform() [3/3]

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

fm_computeArea() [1/3]

double tesseract_collision::FLOAT_MATH::fm_computeArea	(	const double	p1[3],
		const double	p2[3],
		const double	p3[3]
	)

fm_computeArea() [2/3]

float tesseract_collision::FLOAT_MATH::fm_computeArea	(	const float	p1[3],
		const float	p2[3],
		const float	p3[3]
	)

fm_computeArea() [3/3]

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

fm_computeBestFitAABB() [1/3]

double tesseract_collision::FLOAT_MATH::fm_computeBestFitAABB	(	uint32_t	vcount,
		const double *	points,
		uint32_t	pstride,
		double	bmin[3],
		double	bmax[3]
	)

fm_computeBestFitAABB() [2/3]

float tesseract_collision::FLOAT_MATH::fm_computeBestFitAABB	(	uint32_t	vcount,
		const float *	points,
		uint32_t	pstride,
		float	bmin[3],
		float	bmax[3]
	)

fm_computeBestFitAABB() [3/3]

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

fm_computeBestFitABB() [1/3]

void tesseract_collision::FLOAT_MATH::fm_computeBestFitABB	(	uint32_t	vcount,
		const double *	points,
		uint32_t	pstride,
		double *	sides,
		double	pos[3]
	)

fm_computeBestFitABB() [2/3]

void tesseract_collision::FLOAT_MATH::fm_computeBestFitABB	(	uint32_t	vcount,
		const float *	points,
		uint32_t	pstride,
		float *	sides,
		float	pos[3]
	)

fm_computeBestFitABB() [3/3]

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

fm_computeBestFitCapsule() [1/3]

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

fm_computeBestFitCapsule() [2/3]

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

fm_computeBestFitCapsule() [3/3]

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_computeBestFitOBB() [1/6]

void tesseract_collision::FLOAT_MATH::fm_computeBestFitOBB	(	uint32_t	vcount,
		const double *	points,
		uint32_t	pstride,
		double *	sides,
		double	matrix[16],
		bool	bruteForce = true
	)

fm_computeBestFitOBB() [2/6]

void tesseract_collision::FLOAT_MATH::fm_computeBestFitOBB	(	uint32_t	vcount,
		const double *	points,
		uint32_t	pstride,
		double *	sides,
		double	pos[3],
		double	quat[4],
		bool	bruteForce = true
	)

fm_computeBestFitOBB() [3/6]

void tesseract_collision::FLOAT_MATH::fm_computeBestFitOBB	(	uint32_t	vcount,
		const float *	points,
		uint32_t	pstride,
		float *	sides,
		float	matrix[16],
		bool	bruteForce = true
	)

fm_computeBestFitOBB() [4/6]

void tesseract_collision::FLOAT_MATH::fm_computeBestFitOBB	(	uint32_t	vcount,
		const float *	points,
		uint32_t	pstride,
		float *	sides,
		float	pos[3],
		float	quat[4],
		bool	bruteForce = true
	)

fm_computeBestFitOBB() [5/6]

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

fm_computeBestFitOBB() [6/6]

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

fm_computeBestFitPlane() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_computeBestFitPlane	(	uint32_t	vcount,
		const double *	points,
		uint32_t	vstride,
		const double *	weights,
		uint32_t	wstride,
		double	plane[4],
		double	center[3]
	)

fm_computeBestFitPlane() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_computeBestFitPlane	(	uint32_t	vcount,
		const float *	points,
		uint32_t	vstride,
		const float *	weights,
		uint32_t	wstride,
		float	plane[4],
		float	center[3]
	)

fm_computeBestFitPlane() [3/3]

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
	)

fm_computeBestFitSphere() [1/3]

double tesseract_collision::FLOAT_MATH::fm_computeBestFitSphere	(	uint32_t	vcount,
		const double *	points,
		uint32_t	pstride,
		double	center[3]
	)

fm_computeBestFitSphere() [2/3]

float tesseract_collision::FLOAT_MATH::fm_computeBestFitSphere	(	uint32_t	vcount,
		const float *	points,
		uint32_t	pstride,
		float	center[3]
	)

fm_computeBestFitSphere() [3/3]

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

fm_computeCentroid() [1/6]

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

fm_computeCentroid() [2/6]

bool tesseract_collision::FLOAT_MATH::fm_computeCentroid	(	uint32_t	vcount,
		const double *	points,
		uint32_t	triangleCount,
		const uint32_t *	indices,
		double *	center
	)

fm_computeCentroid() [3/6]

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

fm_computeCentroid() [4/6]

bool tesseract_collision::FLOAT_MATH::fm_computeCentroid	(	uint32_t	vcount,
		const float *	points,
		uint32_t	triangleCount,
		const uint32_t *	indices,
		float *	center
	)

fm_computeCentroid() [5/6]

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

fm_computeCentroid() [6/6]

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

fm_computeMeanNormals() [1/3]

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

fm_computeMeanNormals() [2/3]

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

fm_computeMeanNormals() [3/3]

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
	)

fm_computeMeshVolume() [1/3]

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

fm_computeMeshVolume() [2/3]

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

fm_computeMeshVolume() [3/3]

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

fm_computeNormalVector() [1/3]

double tesseract_collision::FLOAT_MATH::fm_computeNormalVector	(	double	n[3],
		const double	p1[3],
		const double	p2[3]
	)

fm_computeNormalVector() [2/3]

float tesseract_collision::FLOAT_MATH::fm_computeNormalVector	(	float	n[3],
		const float	p1[3],
		const float	p2[3]
	)

fm_computeNormalVector() [3/3]

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

fm_computePlane() [1/3]

double tesseract_collision::FLOAT_MATH::fm_computePlane	(	const double	p1[3],
		const double	p2[3],
		const double	p3[3],
		double *	n
	)

fm_computePlane() [2/3]

float tesseract_collision::FLOAT_MATH::fm_computePlane	(	const float	p1[3],
		const float	p2[3],
		const float	p3[3],
		float *	n
	)

fm_computePlane() [3/3]

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

fm_computeSplitPlane() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_computeSplitPlane	(	uint32_t	vcount,
		const double *	vertices,
		uint32_t	tcount,
		const uint32_t *	indices,
		double *	plane
	)

fm_computeSplitPlane() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_computeSplitPlane	(	uint32_t	vcount,
		const float *	vertices,
		uint32_t	tcount,
		const uint32_t *	indices,
		float *	plane
	)

fm_computeSplitPlane() [3/3]

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

fm_computeWindingOrder() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_computeWindingOrder	(	const double	p1[3],
		const double	p2[3],
		const double	p3[3]
	)

fm_computeWindingOrder() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_computeWindingOrder	(	const float	p1[3],
		const float	p2[3],
		const float	p3[3]
	)

fm_computeWindingOrder() [3/3]

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

fm_consolidatePolygon() [1/3]

uint32_t tesseract_collision::FLOAT_MATH::fm_consolidatePolygon	(	uint32_t	pcount,
		const double *	points,
		uint32_t	pstride,
		double *	dest,
		double	epsilon = 0.999999
	)

fm_consolidatePolygon() [2/3]

uint32_t tesseract_collision::FLOAT_MATH::fm_consolidatePolygon	(	uint32_t	pcount,
		const float *	points,
		uint32_t	pstride,
		float *	dest,
		float	epsilon = 0.999999f
	)

fm_consolidatePolygon() [3/3]

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

fm_copy3() [1/3]

void tesseract_collision::FLOAT_MATH::fm_copy3	(	const double *	source,
		double *	dest
	)

fm_copy3() [2/3]

void tesseract_collision::FLOAT_MATH::fm_copy3	(	const float *	source,
		float *	dest
	)

fm_copy3() [3/3]

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

fm_copyUniqueVertices() [1/3]

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

fm_copyUniqueVertices() [2/3]

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

fm_copyUniqueVertices() [3/3]

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
	)

fm_createTesselate()

fm_Tesselate * tesseract_collision::FLOAT_MATH::fm_createTesselate

(

void

)

fm_createTriangulate()

fm_Triangulate * tesseract_collision::FLOAT_MATH::fm_createTriangulate

(

void

)

fm_createVertexIndex() [1/2]

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

fm_createVertexIndex() [2/2]

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

fm_cross() [1/3]

void tesseract_collision::FLOAT_MATH::fm_cross	(	double	cross[3],
		const double	a[3],
		const double	b[3]
	)

fm_cross() [2/3]

void tesseract_collision::FLOAT_MATH::fm_cross	(	float	cross[3],
		const float	a[3],
		const float	b[3]
	)

fm_cross() [3/3]

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

fm_cylinderVolume() [1/3]

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

fm_cylinderVolume() [2/3]

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

fm_cylinderVolume() [3/3]

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

fm_decomposeTransform() [1/3]

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

fm_decomposeTransform() [2/3]

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

fm_decomposeTransform() [3/3]

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

fm_distance() [1/3]

double tesseract_collision::FLOAT_MATH::fm_distance	(	const double	p1[3],
		const double	p2[3]
	)

fm_distance() [2/3]

float tesseract_collision::FLOAT_MATH::fm_distance	(	const float	p1[3],
		const float	p2[3]
	)

fm_distance() [3/3]

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

fm_distancePointLineSegment() [1/3]

double tesseract_collision::FLOAT_MATH::fm_distancePointLineSegment	(	const double	Point[3],
		const double	LineStart[3],
		const double	LineEnd[3],
		double	intersection[3],
		LineSegmentType &	type,
		double	epsilon
	)

fm_distancePointLineSegment() [2/3]

float tesseract_collision::FLOAT_MATH::fm_distancePointLineSegment	(	const float	Point[3],
		const float	LineStart[3],
		const float	LineEnd[3],
		float	intersection[3],
		LineSegmentType &	type,
		float	epsilon
	)

fm_distancePointLineSegment() [3/3]

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

fm_distanceSquared() [1/3]

double tesseract_collision::FLOAT_MATH::fm_distanceSquared	(	const double	p1[3],
		const double	p2[3]
	)

fm_distanceSquared() [2/3]

float tesseract_collision::FLOAT_MATH::fm_distanceSquared	(	const float	p1[3],
		const float	p2[3]
	)

fm_distanceSquared() [3/3]

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

fm_distanceSquaredXZ() [1/3]

double tesseract_collision::FLOAT_MATH::fm_distanceSquaredXZ	(	const double	p1[3],
		const double	p2[3]
	)

fm_distanceSquaredXZ() [2/3]

float tesseract_collision::FLOAT_MATH::fm_distanceSquaredXZ	(	const float	p1[3],
		const float	p2[3]
	)

fm_distanceSquaredXZ() [3/3]

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

fm_distToPlane() [1/3]

double tesseract_collision::FLOAT_MATH::fm_distToPlane	(	const double	plane[4],
		const double	pos[3]
	)

fm_distToPlane() [2/3]

float tesseract_collision::FLOAT_MATH::fm_distToPlane	(	const float	plane[4],
		const float	pos[3]
	)

fm_distToPlane() [3/3]

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

fm_dot() [1/3]

double tesseract_collision::FLOAT_MATH::fm_dot	(	const double	p1[3],
		const double	p2[3]
	)

fm_dot() [2/3]

float tesseract_collision::FLOAT_MATH::fm_dot	(	const float	p1[3],
		const float	p2[3]
	)

fm_dot() [3/3]

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

fm_doubleToFloat3()

void tesseract_collision::FLOAT_MATH::fm_doubleToFloat3 ( const double  p[3], float  t[3]  )

inline

fm_eulerMatrix() [1/3]

void tesseract_collision::FLOAT_MATH::fm_eulerMatrix	(	double	ax,
		double	ay,
		double	az,
		double	matrix[16]
	)

fm_eulerMatrix() [2/3]

void tesseract_collision::FLOAT_MATH::fm_eulerMatrix	(	float	ax,
		float	ay,
		float	az,
		float	matrix[16]
	)

fm_eulerMatrix() [3/3]

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

fm_eulerToMatrix() [1/3]

void tesseract_collision::FLOAT_MATH::fm_eulerToMatrix	(	double	ax,
		double	ay,
		double	az,
		double	matrix[16]
	)

fm_eulerToMatrix() [2/3]

void tesseract_collision::FLOAT_MATH::fm_eulerToMatrix	(	float	ax,
		float	ay,
		float	az,
		float	matrix[16]
	)

fm_eulerToMatrix() [3/3]

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

fm_eulerToMatrixDX() [1/3]

void tesseract_collision::FLOAT_MATH::fm_eulerToMatrixDX	(	double	x,
		double	y,
		double	z,
		double	matrix[16]
	)

fm_eulerToMatrixDX() [2/3]

void tesseract_collision::FLOAT_MATH::fm_eulerToMatrixDX	(	float	x,
		float	y,
		float	z,
		float	matrix[16]
	)

fm_eulerToMatrixDX() [3/3]

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

fm_eulerToQuat() [1/6]

void tesseract_collision::FLOAT_MATH::fm_eulerToQuat	(	const double	euler[3],
		double	quat[4]
	)

fm_eulerToQuat() [2/6]

void tesseract_collision::FLOAT_MATH::fm_eulerToQuat	(	const float	euler[3],
		float	quat[4]
	)

fm_eulerToQuat() [3/6]

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

fm_eulerToQuat() [4/6]

void tesseract_collision::FLOAT_MATH::fm_eulerToQuat	(	double	x,
		double	y,
		double	z,
		double	quat[4]
	)

fm_eulerToQuat() [5/6]

void tesseract_collision::FLOAT_MATH::fm_eulerToQuat	(	float	x,
		float	y,
		float	z,
		float	quat[4]
	)

fm_eulerToQuat() [6/6]

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

fm_eulerToQuatDX() [1/3]

void tesseract_collision::FLOAT_MATH::fm_eulerToQuatDX	(	double	x,
		double	y,
		double	z,
		double	quat[4]
	)

fm_eulerToQuatDX() [2/3]

void tesseract_collision::FLOAT_MATH::fm_eulerToQuatDX	(	float	x,
		float	y,
		float	z,
		float	quat[4]
	)

fm_eulerToQuatDX() [3/3]

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

fm_floatToDouble3()

void tesseract_collision::FLOAT_MATH::fm_floatToDouble3 ( const float  p[3], double  t[3]  )

inline

fm_getAABB() [1/3]

void tesseract_collision::FLOAT_MATH::fm_getAABB	(	uint32_t	vcount,
		const double *	points,
		uint32_t	pstride,
		double	bmin[3],
		double	bmax[3]
	)

fm_getAABB() [2/3]

void tesseract_collision::FLOAT_MATH::fm_getAABB	(	uint32_t	vcount,
		const float *	points,
		uint32_t	pstride,
		float	bmin[3],
		float	bmax[3]
	)

fm_getAABB() [3/3]

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

fm_getAABBCenter() [1/3]

void tesseract_collision::FLOAT_MATH::fm_getAABBCenter	(	const double	bmin[3],
		const double	bmax[3],
		double	center[3]
	)

fm_getAABBCenter() [2/3]

void tesseract_collision::FLOAT_MATH::fm_getAABBCenter	(	const float	bmin[3],
		const float	bmax[3],
		float	center[3]
	)

fm_getAABBCenter() [3/3]

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

fm_getDeterminant() [1/3]

double tesseract_collision::FLOAT_MATH::fm_getDeterminant

(

const double

matrix[16]

)

fm_getDeterminant() [2/3]

float tesseract_collision::FLOAT_MATH::fm_getDeterminant

(

const float

matrix[16]

)

fm_getDeterminant() [3/3]

REAL tesseract_collision::FLOAT_MATH::fm_getDeterminant

(

const REAL

matrix[16]

)

fm_getDominantAxis() [1/3]

FM_Axis tesseract_collision::FLOAT_MATH::fm_getDominantAxis

(

const double

normal[3]

)

fm_getDominantAxis() [2/3]

FM_Axis tesseract_collision::FLOAT_MATH::fm_getDominantAxis

(

const float

normal[3]

)

fm_getDominantAxis() [3/3]

FM_Axis tesseract_collision::FLOAT_MATH::fm_getDominantAxis

(

const REAL

normal[3]

)

fm_getPoint() [1/3]

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

fm_getPoint() [2/3]

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

fm_getPoint() [3/3]

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

fm_getSidePlane() [1/3]

PlaneTriResult tesseract_collision::FLOAT_MATH::fm_getSidePlane	(	const double	p[3],
		const double	plane[4],
		double	epsilon
	)

fm_getSidePlane() [2/3]

PlaneTriResult tesseract_collision::FLOAT_MATH::fm_getSidePlane	(	const float	p[3],
		const float	plane[4],
		float	epsilon
	)

fm_getSidePlane() [3/3]

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

fm_getSubMatrix() [1/3]

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

fm_getSubMatrix() [2/3]

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

fm_getSubMatrix() [3/3]

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

fm_getTranslation() [1/3]

void tesseract_collision::FLOAT_MATH::fm_getTranslation	(	const double	matrix[16],
		double	t[3]
	)

fm_getTranslation() [2/3]

void tesseract_collision::FLOAT_MATH::fm_getTranslation	(	const float	matrix[16],
		float	t[3]
	)

fm_getTranslation() [3/3]

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

fm_identity() [1/3]

void tesseract_collision::FLOAT_MATH::fm_identity

(

double

matrix[16]

)

fm_identity() [2/3]

void tesseract_collision::FLOAT_MATH::fm_identity

(

float

matrix[16]

)

fm_identity() [3/3]

void tesseract_collision::FLOAT_MATH::fm_identity

(

REAL

matrix[16]

)

fm_inflateMinMax() [1/3]

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

fm_inflateMinMax() [2/3]

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

fm_inflateMinMax() [3/3]

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

fm_initMinMax() [1/6]

void tesseract_collision::FLOAT_MATH::fm_initMinMax	(	const double	p[3],
		double	bmin[3],
		double	bmax[3]
	)

fm_initMinMax() [2/6]

void tesseract_collision::FLOAT_MATH::fm_initMinMax	(	const float	p[3],
		float	bmin[3],
		float	bmax[3]
	)

fm_initMinMax() [3/6]

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

fm_initMinMax() [4/6]

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

fm_initMinMax() [5/6]

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

fm_initMinMax() [6/6]

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

fm_insideAABB() [1/6]

bool tesseract_collision::FLOAT_MATH::fm_insideAABB	(	const double	obmin[3],
		const double	obmax[3],
		const double	tbmin[3],
		const double	tbmax[3]
	)

fm_insideAABB() [2/6]

bool tesseract_collision::FLOAT_MATH::fm_insideAABB	(	const double	pos[3],
		const double	bmin[3],
		const double	bmax[3]
	)

fm_insideAABB() [3/6]

bool tesseract_collision::FLOAT_MATH::fm_insideAABB	(	const float	obmin[3],
		const float	obmax[3],
		const float	tbmin[3],
		const float	tbmax[3]
	)

fm_insideAABB() [4/6]

bool tesseract_collision::FLOAT_MATH::fm_insideAABB	(	const float	pos[3],
		const float	bmin[3],
		const float	bmax[3]
	)

fm_insideAABB() [5/6]

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

fm_insideAABB() [6/6]

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

fm_insideTriangle() [1/3]

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

fm_insideTriangle() [2/3]

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

fm_insideTriangle() [3/3]

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

fm_insideTriangleXZ() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_insideTriangleXZ	(	const double	test[3],
		const double	p1[3],
		const double	p2[3],
		const double	p3[3]
	)

fm_insideTriangleXZ() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_insideTriangleXZ	(	const float	test[3],
		const float	p1[3],
		const float	p2[3],
		const float	p3[3]
	)

fm_insideTriangleXZ() [3/3]

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

fm_intersectAABB() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_intersectAABB	(	const double	bmin1[3],
		const double	bmax1[3],
		const double	bmin2[3],
		const double	bmax2[3]
	)

fm_intersectAABB() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_intersectAABB	(	const float	bmin1[3],
		const float	bmax1[3],
		const float	bmin2[3],
		const float	bmax2[3]
	)

fm_intersectAABB() [3/3]

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

fm_intersectLineSegmentAABB()

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]
	)

fm_intersectLineSegments2d() [1/3]

IntersectResult tesseract_collision::FLOAT_MATH::fm_intersectLineSegments2d	(	const double	a1[3],
		const double	a2[3],
		const double	b1[3],
		const double	b2[3],
		double	intersectionPoint[3]
	)

fm_intersectLineSegments2d() [2/3]

IntersectResult tesseract_collision::FLOAT_MATH::fm_intersectLineSegments2d	(	const float	a1[3],
		const float	a2[3],
		const float	b1[3],
		const float	b2[3],
		float	intersectionPoint[3]
	)

fm_intersectLineSegments2d() [3/3]

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

fm_intersectLineSegments2dTime() [1/3]

IntersectResult tesseract_collision::FLOAT_MATH::fm_intersectLineSegments2dTime	(	const double	a1[3],
		const double	a2[3],
		const double	b1[3],
		const double	b2[3],
		double &	t1,
		double &	t2
	)

fm_intersectLineSegments2dTime() [2/3]

IntersectResult tesseract_collision::FLOAT_MATH::fm_intersectLineSegments2dTime	(	const float	a1[3],
		const float	a2[3],
		const float	b1[3],
		const float	b2[3],
		float &	t1,
		float &	t2
	)

fm_intersectLineSegments2dTime() [3/3]

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

fm_intersectPointPlane() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_intersectPointPlane	(	const double	p1[3],
		const double	p2[3],
		double *	split,
		const double	plane[4]
	)

fm_intersectPointPlane() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_intersectPointPlane	(	const float	p1[3],
		const float	p2[3],
		float *	split,
		const float	plane[4]
	)

fm_intersectPointPlane() [3/3]

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

fm_intersectRayAABB()

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]
	)

fm_inverseRT() [1/3]

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

fm_inverseRT() [2/3]

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

fm_inverseRT() [3/3]

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

fm_inverseTransform() [1/3]

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

fm_inverseTransform() [2/3]

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

fm_inverseTransform() [3/3]

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

fm_isMeshCoplanar() [1/3]

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

fm_isMeshCoplanar() [2/3]

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

fm_isMeshCoplanar() [3/3]

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

fm_isValidTriangle() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_isValidTriangle	(	const double *	p1,
		const double *	p2,
		const double *	p3,
		double	epsilon = 0.00001
	)

fm_isValidTriangle() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_isValidTriangle	(	const float *	p1,
		const float *	p2,
		const float *	p3,
		float	epsilon = 0.00001f
	)

fm_isValidTriangle() [3/3]

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

fm_lerp() [1/3]

void tesseract_collision::FLOAT_MATH::fm_lerp	(	const double	p1[3],
		const double	p2[3],
		double	dest[3],
		double	lerpValue
	)

fm_lerp() [2/3]

void tesseract_collision::FLOAT_MATH::fm_lerp	(	const float	p1[3],
		const float	p2[3],
		float	dest[3],
		float	lerpValue
	)

fm_lerp() [3/3]

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

fm_lineIntersectsTriangle() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_lineIntersectsTriangle	(	const double	rayStart[3],
		const double	rayEnd[3],
		const double	p1[3],
		const double	p2[3],
		const double	p3[3],
		double	sect[3]
	)

fm_lineIntersectsTriangle() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_lineIntersectsTriangle	(	const float	rayStart[3],
		const float	rayEnd[3],
		const float	p1[3],
		const float	p2[3],
		const float	p3[3],
		float	sect[3]
	)

fm_lineIntersectsTriangle() [3/3]

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

fm_lineSphereIntersect() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_lineSphereIntersect	(	const double	center[3],
		double	radius,
		const double	p1[3],
		const double	p2[3],
		double	intersect[3]
	)

fm_lineSphereIntersect() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_lineSphereIntersect	(	const float	center[3],
		float	radius,
		const float	p1[3],
		const float	p2[3],
		float	intersect[3]
	)

fm_lineSphereIntersect() [3/3]

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

fm_lineTestAABB() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_lineTestAABB	(	const double	p1[3],
		const double	p2[3],
		const double	bmin[3],
		const double	bmax[3],
		double &	time
	)

fm_lineTestAABB() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_lineTestAABB	(	const float	p1[3],
		const float	p2[3],
		const float	bmin[3],
		const float	bmax[3],
		float &	time
	)

fm_lineTestAABB() [3/3]

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

fm_lineTestAABBXZ() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_lineTestAABBXZ	(	const double	p1[3],
		const double	p2[3],
		const double	bmin[3],
		const double	bmax[3],
		double &	time
	)

fm_lineTestAABBXZ() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_lineTestAABBXZ	(	const float	p1[3],
		const float	p2[3],
		const float	bmin[3],
		const float	bmax[3],
		float &	time
	)

fm_lineTestAABBXZ() [3/3]

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

fm_matrixMultiply() [1/3]

void tesseract_collision::FLOAT_MATH::fm_matrixMultiply	(	const double	A[16],
		const double	B[16],
		double	dest[16]
	)

fm_matrixMultiply() [2/3]

void tesseract_collision::FLOAT_MATH::fm_matrixMultiply	(	const float	A[16],
		const float	B[16],
		float	dest[16]
	)

fm_matrixMultiply() [3/3]

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

fm_matrixToQuat() [1/3]

void tesseract_collision::FLOAT_MATH::fm_matrixToQuat	(	const double	matrix[16],
		double	quat[4]
	)

fm_matrixToQuat() [2/3]

void tesseract_collision::FLOAT_MATH::fm_matrixToQuat	(	const float	matrix[16],
		float	quat[4]
	)

fm_matrixToQuat() [3/3]

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

fm_minmax() [1/3]

void tesseract_collision::FLOAT_MATH::fm_minmax	(	const double	p[3],
		double	bmin[3],
		double	bmax[3]
	)

fm_minmax() [2/3]

void tesseract_collision::FLOAT_MATH::fm_minmax	(	const float	p[3],
		float	bmin[3],
		float	bmax[3]
	)

fm_minmax() [3/3]

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

fm_multiply() [1/3]

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

fm_multiply() [2/3]

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

fm_multiply() [3/3]

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

fm_multiplyQuat() [1/3]

void tesseract_collision::FLOAT_MATH::fm_multiplyQuat	(	const double *	qa,
		const double *	qb,
		double *	quat
	)

fm_multiplyQuat() [2/3]

void tesseract_collision::FLOAT_MATH::fm_multiplyQuat	(	const float *	qa,
		const float *	qb,
		float *	quat
	)

fm_multiplyQuat() [3/3]

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

fm_multiplyTransform() [1/3]

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

fm_multiplyTransform() [2/3]

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

fm_multiplyTransform() [3/3]

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

fm_nearestPointInTriangle() [1/3]

void tesseract_collision::FLOAT_MATH::fm_nearestPointInTriangle	(	const double *	pos,
		const double *	p1,
		const double *	p2,
		const double *	p3,
		double *	nearest
	)

fm_nearestPointInTriangle() [2/3]

void tesseract_collision::FLOAT_MATH::fm_nearestPointInTriangle	(	const float *	pos,
		const float *	p1,
		const float *	p2,
		const float *	p3,
		float *	nearest
	)

fm_nearestPointInTriangle() [3/3]

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

fm_normalize() [1/3]

double tesseract_collision::FLOAT_MATH::fm_normalize

(

double

n[3]

)

fm_normalize() [2/3]

float tesseract_collision::FLOAT_MATH::fm_normalize

(

float

n[3]

)

fm_normalize() [3/3]

REAL tesseract_collision::FLOAT_MATH::fm_normalize

(

REAL *

n

)

fm_normalizeQuat() [1/3]

double tesseract_collision::FLOAT_MATH::fm_normalizeQuat

(

double

n[4]

)

fm_normalizeQuat() [2/3]

float tesseract_collision::FLOAT_MATH::fm_normalizeQuat

(

float

n[4]

)

fm_normalizeQuat() [3/3]

REAL tesseract_collision::FLOAT_MATH::fm_normalizeQuat

(

REAL

n[4]

)

fm_OBBtoAABB()

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]
	)

fm_planeToMatrix() [1/3]

void tesseract_collision::FLOAT_MATH::fm_planeToMatrix	(	const double	plane[4],
		double	matrix[16]
	)

fm_planeToMatrix() [2/3]

void tesseract_collision::FLOAT_MATH::fm_planeToMatrix	(	const float	plane[4],
		float	matrix[16]
	)

fm_planeToMatrix() [3/3]

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

fm_planeToQuat() [1/3]

void tesseract_collision::FLOAT_MATH::fm_planeToQuat	(	const double	plane[4],
		double	quat[4],
		double	pos[3]
	)

fm_planeToQuat() [2/3]

void tesseract_collision::FLOAT_MATH::fm_planeToQuat	(	const float	plane[4],
		float	quat[4],
		float	pos[3]
	)

fm_planeToQuat() [3/3]

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

fm_planeTriIntersection() [1/3]

PlaneTriResult tesseract_collision::FLOAT_MATH::fm_planeTriIntersection	(	const double	plane[4],
		const double *	triangle,
		uint32_t	tstride,
		double	epsilon,
		double *	front,
		uint32_t &	fcount,
		double *	back,
		uint32_t &	bcount
	)

fm_planeTriIntersection() [2/3]

PlaneTriResult tesseract_collision::FLOAT_MATH::fm_planeTriIntersection	(	const float	plane[4],
		const float *	triangle,
		uint32_t	tstride,
		float	epsilon,
		float *	front,
		uint32_t &	fcount,
		float *	back,
		uint32_t &	bcount
	)

fm_planeTriIntersection() [3/3]

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
	)

fm_pointInsidePolygon2d() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_pointInsidePolygon2d	(	uint32_t	pcount,
		const double *	points,
		uint32_t	pstride,
		const double *	point,
		uint32_t	xindex = 0,
		uint32_t	yindex = 1
	)

fm_pointInsidePolygon2d() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_pointInsidePolygon2d	(	uint32_t	pcount,
		const float *	points,
		uint32_t	pstride,
		const float *	point,
		uint32_t	xindex = 0,
		uint32_t	yindex = 1
	)

fm_pointInsidePolygon2d() [3/3]

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
	)

fm_pointTestXZ()

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

fm_quatRotate() [1/3]

void tesseract_collision::FLOAT_MATH::fm_quatRotate	(	const double	quat[4],
		const double	v[3],
		double	r[3]
	)

fm_quatRotate() [2/3]

void tesseract_collision::FLOAT_MATH::fm_quatRotate	(	const float	quat[4],
		const float	v[3],
		float	r[3]
	)

fm_quatRotate() [3/3]

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

fm_quatToEuler() [1/3]

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

fm_quatToEuler() [2/3]

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

fm_quatToEuler() [3/3]

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

fm_quatToMatrix() [1/3]

void tesseract_collision::FLOAT_MATH::fm_quatToMatrix	(	const double	quat[4],
		double	matrix[16]
	)

fm_quatToMatrix() [2/3]

void tesseract_collision::FLOAT_MATH::fm_quatToMatrix	(	const float	quat[4],
		float	matrix[16]
	)

fm_quatToMatrix() [3/3]

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

fm_rayIntersectsTriangle() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_rayIntersectsTriangle	(	const double	origin[3],
		const double	dir[3],
		const double	v0[3],
		const double	v1[3],
		const double	v2[3],
		double &	t
	)

fm_rayIntersectsTriangle() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_rayIntersectsTriangle	(	const float	origin[3],
		const float	dir[3],
		const float	v0[3],
		const float	v1[3],
		const float	v2[3],
		float &	t
	)

fm_rayIntersectsTriangle() [3/3]

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

fm_raySphereIntersect() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_raySphereIntersect	(	const double	center[3],
		double	radius,
		const double	pos[3],
		const double	dir[3],
		double	distance,
		double	intersect[3]
	)

fm_raySphereIntersect() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_raySphereIntersect	(	const float	center[3],
		float	radius,
		const float	pos[3],
		const float	dir[3],
		float	distance,
		float	intersect[3]
	)

fm_raySphereIntersect() [3/3]

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

fm_releaseTesselate()

void tesseract_collision::FLOAT_MATH::fm_releaseTesselate

(

fm_Tesselate *

t

)

fm_releaseTriangulate()

void tesseract_collision::FLOAT_MATH::fm_releaseTriangulate

(

fm_Triangulate *

t

)

fm_releaseVertexIndex()

void tesseract_collision::FLOAT_MATH::fm_releaseVertexIndex

(

fm_VertexIndex *

vindex

)

fm_rotate() [1/3]

void tesseract_collision::FLOAT_MATH::fm_rotate	(	const double	matri[16],
		const double	pos[3],
		double	t[3]
	)

fm_rotate() [2/3]

void tesseract_collision::FLOAT_MATH::fm_rotate	(	const float	matrix[16],
		const float	pos[3],
		float	t[3]
	)

fm_rotate() [3/3]

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

fm_rotationArc() [1/3]

void tesseract_collision::FLOAT_MATH::fm_rotationArc	(	const double	v0[3],
		const double	v1[3],
		double	quat[4]
	)

fm_rotationArc() [2/3]

void tesseract_collision::FLOAT_MATH::fm_rotationArc	(	const float	v0[3],
		const float	v1[3],
		float	quat[4]
	)

fm_rotationArc() [3/3]

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

fm_samePlane() [1/3]

bool tesseract_collision::FLOAT_MATH::fm_samePlane	(	const double	p1[4],
		const double	p2[4],
		double	normalEpsilon = 0.01,
		double	dEpsilon = 0.001,
		bool	doubleSided = false
	)

fm_samePlane() [2/3]

bool tesseract_collision::FLOAT_MATH::fm_samePlane	(	const float	p1[4],
		const float	p2[4],
		float	normalEpsilon = 0.01f,
		float	dEpsilon = 0.001f,
		bool	doubleSided = false
	)

fm_samePlane() [3/3]

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

fm_scale() [1/3]

void tesseract_collision::FLOAT_MATH::fm_scale	(	double	x,
		double	y,
		double	z,
		double	matrix[16]
	)

fm_scale() [2/3]

void tesseract_collision::FLOAT_MATH::fm_scale	(	float	x,
		float	y,
		float	z,
		float	matrix[16]
	)

fm_scale() [3/3]

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

fm_setTranslation() [1/3]

void tesseract_collision::FLOAT_MATH::fm_setTranslation	(	const double *	translation,
		double	matrix[16]
	)

fm_setTranslation() [2/3]

void tesseract_collision::FLOAT_MATH::fm_setTranslation	(	const float *	translation,
		float	matrix[16]
	)

fm_setTranslation() [3/3]

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

fm_solveX() [1/3]

double tesseract_collision::FLOAT_MATH::fm_solveX	(	const double	plane[4],
		double	y,
		double	z
	)

fm_solveX() [2/3]

float tesseract_collision::FLOAT_MATH::fm_solveX	(	const float	plane[4],
		float	y,
		float	z
	)

fm_solveX() [3/3]

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

fm_solveY() [1/3]

double tesseract_collision::FLOAT_MATH::fm_solveY	(	const double	plane[4],
		double	x,
		double	z
	)

fm_solveY() [2/3]

float tesseract_collision::FLOAT_MATH::fm_solveY	(	const float	plane[4],
		float	x,
		float	z
	)

fm_solveY() [3/3]

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

fm_solveZ() [1/3]

double tesseract_collision::FLOAT_MATH::fm_solveZ	(	const double	plane[4],
		double	x,
		double	y
	)

fm_solveZ() [2/3]

float tesseract_collision::FLOAT_MATH::fm_solveZ	(	const float	plane[4],
		float	x,
		float	y
	)

fm_solveZ() [3/3]

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

fm_sphereVolume() [1/3]

double tesseract_collision::FLOAT_MATH::fm_sphereVolume

(

double

radius

)

fm_sphereVolume() [2/3]

float tesseract_collision::FLOAT_MATH::fm_sphereVolume

(

float

radius

)

fm_sphereVolume() [3/3]

REAL tesseract_collision::FLOAT_MATH::fm_sphereVolume

(

REAL

radius

)

fm_squared()

REAL tesseract_collision::FLOAT_MATH::fm_squared

(

REAL

x

)

fm_subtract() [1/3]

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

fm_subtract() [2/3]

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

fm_subtract() [3/3]

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

fm_transform() [1/3]

void tesseract_collision::FLOAT_MATH::fm_transform	(	const double	matrix[16],
		const double	pos[3],
		double	t[3]
	)

fm_transform() [2/3]

void tesseract_collision::FLOAT_MATH::fm_transform	(	const float	matrix[16],
		const float	pos[3],
		float	t[3]
	)

fm_transform() [3/3]

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

fm_transformAABB() [1/3]

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

fm_transformAABB() [2/3]

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

fm_transformAABB() [3/3]

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]
	)

intersect()

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

Partial()

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

static

Set()

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

inlinestatic

splitRect()

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

triangle_area_3d()

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  )

static

validDistance()

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

Variable Documentation

FM_DEG_TO_RAD

const float tesseract_collision::FLOAT_MATH::FM_DEG_TO_RAD = ((2.0f * FM_PI) / 360.0f)

FM_PI

const float tesseract_collision::FLOAT_MATH::FM_PI = 3.1415926535897932384626433832795028841971693993751f

FM_RAD_TO_DEG

const float tesseract_collision::FLOAT_MATH::FM_RAD_TO_DEG = (360.0f / (2.0f * FM_PI))