Main Page Class List Class Members

# FLOAT_MATH Namespace Reference

## Classes
class | fm_Tesselate
class | fm_Triangulate
class | fm_VertexIndex
## Enumerations
enum | FM_Axis { FM_XAXIS = (1<<0), FM_YAXIS = (1<<1), FM_ZAXIS = (1<<2) }
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 | IntersectResult { IR_DONT_INTERSECT, IR_DO_INTERSECT, IR_COINCIDENT, IR_PARALLEL }
enum | LineSegmentType { LS_START, LS_MIDDLE, LS_END }
enum | PlaneTriResult { PTR_ON_PLANE, PTR_FRONT, PTR_BACK, PTR_SPLIT }
## Functions
void | fm_add (const double *A, const double *B, double *sum)
void | fm_add (const float *A, const float *B, float *sum)
double | fm_areaPolygon2d (uint32_t pcount, const double *points, uint32_t pstride)
float | fm_areaPolygon2d (uint32_t pcount, const float *points, uint32_t pstride)
double | fm_areaTriangle (const double *p1, const double *p2, const double *p3)
float | fm_areaTriangle (const float *p1, const float *p2, const float *p3)
double | fm_capsuleVolume (double radius, double h)
float | fm_capsuleVolume (float radius, float h)
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)
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)
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)
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_clipTestPoint (const double bmin[3], const double bmax[3], const double pos[3])
uint32_t | fm_clipTestPoint (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_clipTestPointXZ (const float bmin[3], const float bmax[3], const float pos[3])
bool | fm_colinear (const double a1[3], const double a2[3], const double b1[3], const double b2[3], double epsilon=0.999)
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 float p1[3], const float p2[3], const float p3[3], float epsilon=0.999f)
bool | fm_colinear (const double p1[3], const double p2[3], const double p3[3], double epsilon=0.999)
void | fm_composeTransform (const double position[3], const double quat[4], const double scale[3], double matrix[16])
void | fm_composeTransform (const float position[3], const float quat[4], const float scale[3], float matrix[16])
double | fm_computeArea (const double p1[3], const double p2[3], const double p3[3])
float | fm_computeArea (const float p1[3], const float p2[3], const float p3[3])
double | fm_computeBestFitAABB (uint32_t vcount, const double *points, uint32_t pstride, double bmin[3], double bmax[3])
float | fm_computeBestFitAABB (uint32_t vcount, const float *points, uint32_t pstride, float bmin[3], float bmax[3])
void | fm_computeBestFitABB (uint32_t vcount, const double *points, uint32_t pstride, double *sides, double pos[3])
void | fm_computeBestFitABB (uint32_t vcount, const float *points, uint32_t pstride, float *sides, float pos[3])
void | fm_computeBestFitCapsule (uint32_t vcount, const double *points, uint32_t pstride, float &radius, float &height, double matrix[16], bool bruteForce=true)
void | fm_computeBestFitCapsule (uint32_t vcount, const float *points, uint32_t pstride, float &radius, float &height, float matrix[16], 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_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 matrix[16], bool bruteForce=true)
void | fm_computeBestFitOBB (uint32_t vcount, const float *points, uint32_t pstride, float *sides, float matrix[16], bool bruteForce=true)
bool | fm_computeBestFitPlane (uint32_t vcount, const double *points, uint32_t vstride, const double *weights, uint32_t wstride, double plane[4])
bool | fm_computeBestFitPlane (uint32_t vcount, const float *points, uint32_t vstride, const float *weights, uint32_t wstride, float plane[4])
double | fm_computeBestFitSphere (uint32_t vcount, const double *points, uint32_t pstride, double center[3])
float | fm_computeBestFitSphere (uint32_t vcount, const float *points, uint32_t pstride, float center[3])
bool | fm_computeCentroid (uint32_t vcount, const double *points, uint32_t vstride, double *center)
bool | fm_computeCentroid (uint32_t vcount, const float *points, uint32_t vstride, float *center)
void | fm_computeMeanNormals (uint32_t vcount, const double *vertices, uint32_t vstride, double *normals, uint32_t nstride, uint32_t tcount, const uint32_t *indices)
void | fm_computeMeanNormals (uint32_t vcount, const float *vertices, uint32_t vstride, float *normals, uint32_t nstride, uint32_t tcount, const uint32_t *indices)
double | fm_computeMeshVolume (const double *vertices, uint32_t tcount, const uint32_t *indices)
float | fm_computeMeshVolume (const float *vertices, uint32_t tcount, const uint32_t *indices)
void | fm_computeNormalVector (double n[3], const double p1[3], const double p2[3])
void | fm_computeNormalVector (float n[3], const float p1[3], const float p2[3])
double | fm_computePlane (const double p1[3], const double p2[3], const double p3[3], double *n)
float | fm_computePlane (const float p1[3], const float p2[3], const float p3[3], float *n)
bool | fm_computeSplitPlane (uint32_t vcount, const float *vertices, uint32_t tcount, const uint32_t *indices, float *plane)
bool | fm_computeSplitPlane (uint32_t vcount, const double *vertices, uint32_t tcount, const uint32_t *indices, double *plane)
bool | fm_computeWindingOrder (const double p1[3], const double p2[3], const double p3[3])
bool | fm_computeWindingOrder (const float p1[3], const float p2[3], const float p3[3])
uint32_t | fm_consolidatePolygon (uint32_t pcount, const double *points, uint32_t pstride, double *dest, double epsilon=0.999999)
uint32_t | fm_consolidatePolygon (uint32_t pcount, const float *points, uint32_t pstride, float *dest, float epsilon=0.999999f)
void | fm_copy3 (const double *source, double *dest)
void | fm_copy3 (const float *source, float *dest)
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)
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)
fm_Tesselate * | fm_createTesselate (void)
fm_Triangulate * | fm_createTriangulate (void)
fm_VertexIndex * | fm_createVertexIndex (float granularity, bool snapToGrid)
fm_VertexIndex * | fm_createVertexIndex (double granularity, bool snapToGrid)
void | fm_cross (double cross[3], const double a[3], const double b[3])
void | fm_cross (float cross[3], const float a[3], const float b[3])
double | fm_cylinderVolume (double radius, double h)
float | fm_cylinderVolume (float radius, float h)
void | fm_decomposeTransform (const double local_transform[16], double trans[3], double rot[4], double scale[3])
void | fm_decomposeTransform (const float local_transform[16], float trans[3], float rot[4], float scale[3])
double | fm_distance (const double p1[3], const double p2[3])
float | fm_distance (const float p1[3], const float p2[3])
double | fm_distancePointLineSegment (const double Point[3], const double LineStart[3], const double LineEnd[3], double intersection[3], LineSegmentType &type, double epsilon)
float | fm_distancePointLineSegment (const float Point[3], const float LineStart[3], const float LineEnd[3], float intersection[3], LineSegmentType &type, float epsilon)
double | fm_distanceSquared (const double p1[3], const double p2[3])
float | fm_distanceSquared (const float p1[3], const float p2[3])
double | fm_distanceSquaredXZ (const double p1[3], const double p2[3])
float | fm_distanceSquaredXZ (const float p1[3], const float p2[3])
double | fm_distToPlane (const double plane[4], const double pos[3])
float | fm_distToPlane (const float plane[4], const float pos[3])
double | fm_dot (const double p1[3], const double p2[3])
float | fm_dot (const float p1[3], const float p2[3])
void | fm_doubleToFloat3 (const double p[3], float t[3])
void | fm_eulerMatrix (double ax, double ay, double az, double matrix[16])
void | fm_eulerMatrix (float ax, float ay, float az, float matrix[16])
void | fm_eulerToMatrix (double ax, double ay, double az, double matrix[16])
void | fm_eulerToMatrix (float ax, float ay, float az, float matrix[16])
void | fm_eulerToMatrixDX (double x, double y, double z, double matrix[16])
void | fm_eulerToMatrixDX (float x, float y, float z, float matrix[16])
void | fm_eulerToQuat (const double euler[3], double quat[4])
void | fm_eulerToQuat (const float euler[3], float quat[4])
void | fm_eulerToQuat (double x, double y, double z, double quat[4])
void | fm_eulerToQuat (float x, float y, float z, float quat[4])
void | fm_eulerToQuatDX (double x, double y, double z, double quat[4])
void | fm_eulerToQuatDX (float x, float y, float z, float quat[4])
void | fm_floatToDouble3 (const float p[3], double t[3])
void | fm_getAABB (uint32_t vcount, const double *points, uint32_t pstride, double bmin[3], double bmax[3])
void | fm_getAABB (uint32_t vcount, const float *points, uint32_t pstride, float bmin[3], float bmax[3])
void | fm_getAABBCenter (const double bmin[3], const double bmax[3], double center[3])
void | fm_getAABBCenter (const float bmin[3], const float bmax[3], float center[3])
double | fm_getDeterminant (const double matrix[16])
float | fm_getDeterminant (const float matrix[16])
FM_Axis | fm_getDominantAxis (const double normal[3])
FM_Axis | fm_getDominantAxis (const float normal[3])
const double * | fm_getPoint (const double *points, uint32_t pstride, uint32_t index)
const float * | fm_getPoint (const float *points, uint32_t pstride, uint32_t index)
PlaneTriResult | fm_getSidePlane (const double p[3], const double plane[4], double epsilon)
PlaneTriResult | fm_getSidePlane (const float p[3], const float plane[4], float epsilon)
void | fm_getSubMatrix (int32_t ki, int32_t kj, double pDst[16], const float matrix[16])
void | fm_getSubMatrix (int32_t ki, int32_t kj, float pDst[16], const float matrix[16])
void | fm_getTranslation (const double matrix[16], double t[3])
void | fm_getTranslation (const float matrix[16], float t[3])
void | fm_identity (double matrix[16])
void | fm_identity (float matrix[16])
void | fm_inflateMinMax (double bmin[3], double bmax[3], double ratio)
void | fm_inflateMinMax (float bmin[3], float bmax[3], float ratio)
void | fm_initMinMax (double bmin[3], double bmax[3])
void | fm_initMinMax (float bmin[3], float bmax[3])
void | fm_initMinMax (const double p[3], double bmin[3], double bmax[3])
void | fm_initMinMax (const float p[3], float bmin[3], float bmax[3])
bool | fm_insideAABB (const double obmin[3], const double obmax[3], const double tbmin[3], const double tbmax[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 pos[3], const double bmin[3], const double bmax[3])
bool | fm_insideAABB (const float pos[3], const float bmin[3], const float bmax[3])
bool | fm_insideTriangle (double Ax, double Ay, double Bx, double By, double Cx, double Cy, double Px, double Py)
bool | fm_insideTriangle (float Ax, float Ay, float Bx, float By, float Cx, float Cy, float Px, float Py)
bool | fm_insideTriangleXZ (const double test[3], const double p1[3], const double p2[3], const double p3[3])
bool | fm_insideTriangleXZ (const float test[3], const float p1[3], const float p2[3], const float p3[3])
bool | fm_intersectAABB (const double bmin1[3], const double bmax1[3], const double bmin2[3], const double bmax2[3])
bool | fm_intersectAABB (const float bmin1[3], const float bmax1[3], const float bmin2[3], const float bmax2[3])
bool | fm_intersectLineSegmentAABB (const float bmin[3], const float bmax[3], const float p1[3], const float p2[3], float intersect[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_intersectLineSegments2d (const float a1[3], const float a2[3], const float b1[3], const float b2[3], float intersectionPoint[3])
IntersectResult | fm_intersectLineSegments2dTime (const double a1[3], const double a2[3], const double b1[3], const double b2[3], double &t1, double &t2)
IntersectResult | fm_intersectLineSegments2dTime (const float a1[3], const float a2[3], const float b1[3], const float b2[3], float &t1, float &t2)
void | fm_intersectPointPlane (const double p1[3], const double p2[3], double *split, const double plane[4])
void | fm_intersectPointPlane (const float p1[3], const float p2[3], float *split, const float plane[4])
bool | fm_intersectRayAABB (const float bmin[3], const float bmax[3], const float pos[3], const float dir[3], float intersect[3])
void | fm_inverseRT (const double matrix[16], const double pos[3], double t[3])
void | fm_inverseRT (const float matrix[16], const float pos[3], float t[3])
void | fm_inverseTransform (const double matrix[16], double inverse_matrix[16])
void | fm_inverseTransform (const float matrix[16], float inverse_matrix[16])
bool | fm_isMeshCoplanar (uint32_t tcount, const uint32_t *indices, const double *vertices, bool doubleSided)
bool | fm_isMeshCoplanar (uint32_t tcount, const uint32_t *indices, const float *vertices, bool doubleSided)
bool | fm_isValidTriangle (const double *p1, const double *p2, const double *p3, double epsilon=0.00001f)
bool | fm_isValidTriangle (const float *p1, const float *p2, const float *p3, float epsilon=0.00001f)
void | fm_lerp (const double p1[3], const double p2[3], double dest[3], double lerpValue)
void | fm_lerp (const float p1[3], const float p2[3], float dest[3], float lerpValue)
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_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_lineSphereIntersect (const double center[3], double radius, const double p1[3], const double p2[3], double intersect[3])
bool | fm_lineSphereIntersect (const float center[3], float radius, const float p1[3], const float p2[3], float intersect[3])
bool | fm_lineTestAABB (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_lineTestAABBXZ (const double p1[3], const double p2[3], const double bmin[3], const double bmax[3], double &time)
bool | fm_lineTestAABBXZ (const float p1[3], const float p2[3], const float bmin[3], const float bmax[3], float &time)
void | fm_matrixMultiply (const double A[16], const double B[16], double dest[16])
void | fm_matrixMultiply (const float A[16], const float B[16], float dest[16])
void | fm_matrixToQuat (const double matrix[16], double quat[4])
void | fm_matrixToQuat (const float matrix[16], float quat[4])
void | fm_minmax (const double p[3], double bmin[3], double bmax[3])
void | fm_minmax (const float p[3], float bmin[3], float bmax[3])
void | fm_multiply (double *A, double scaler)
void | fm_multiply (float *A, float scaler)
void | fm_multiplyQuat (const double *qa, const double *qb, double *quat)
void | fm_multiplyQuat (const float *qa, const float *qb, float *quat)
void | fm_multiplyTransform (const double *pA, const double *pB, double *pM)
void | fm_multiplyTransform (const float *pA, const float *pB, float *pM)
void | fm_nearestPointInTriangle (const double *pos, const double *p1, const double *p2, const double *p3, double *nearest)
void | fm_nearestPointInTriangle (const float *pos, const float *p1, const float *p2, const float *p3, float *nearest)
double | fm_normalize (double n[3])
float | fm_normalize (float n[3])
double | fm_normalizeQuat (double n[4])
float | fm_normalizeQuat (float n[4])
void | fm_OBBtoAABB (const float obmin[3], const float obmax[3], const float matrix[16], float abmin[3], float abmax[3])
void | fm_planeToMatrix (const double plane[4], double matrix[16])
void | fm_planeToMatrix (const float plane[4], float matrix[16])
void | fm_planeToQuat (const double plane[4], double quat[4], double pos[3])
void | fm_planeToQuat (const float plane[4], float quat[4], float pos[3])
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)
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)
bool | fm_pointInsidePolygon2d (uint32_t pcount, const double *points, uint32_t pstride, const double *point, uint32_t xindex=0, uint32_t yindex=1)
bool | fm_pointInsidePolygon2d (uint32_t pcount, const float *points, uint32_t pstride, const float *point, uint32_t xindex=0, uint32_t yindex=1)
void | fm_quatRotate (const double quat[4], const double v[3], double r[3])
void | fm_quatRotate (const float quat[4], const float v[3], float r[3])
void | fm_quatToEuler (const double quat[4], double &ax, double &ay, double &az)
void | fm_quatToEuler (const float quat[4], float &ax, float &ay, float &az)
void | fm_quatToMatrix (const double quat[4], double matrix[16])
void | fm_quatToMatrix (const float quat[4], float matrix[16])
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_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_raySphereIntersect (const double center[3], double radius, const double pos[3], const double dir[3], double distance, double intersect[3])
bool | fm_raySphereIntersect (const float center[3], float radius, const float pos[3], const float dir[3], float distance, float intersect[3])
void | fm_releaseTesselate (fm_Tesselate *t)
void | fm_releaseTriangulate (fm_Triangulate *t)
void | fm_releaseVertexIndex (fm_VertexIndex *vindex)
void | fm_rotate (const double matri[16], const double pos[3], double t[3])
void | fm_rotate (const float matrix[16], const float pos[3], float t[3])
void | fm_rotationArc (const double v0[3], const double v1[3], double quat[4])
void | fm_rotationArc (const float v0[3], const float v1[3], float quat[4])
bool | fm_samePlane (const double p1[4], const double p2[4], double normalEpsilon=0.01, double dEpsilon=0.001, bool doubleSided=false)
bool | fm_samePlane (const float p1[4], const float p2[4], float normalEpsilon=0.01f, float dEpsilon=0.001f, bool doubleSided=false)
void | fm_scale (double x, double y, double z, double matrix[16])
void | fm_scale (float x, float y, float z, float matrix[16])
void | fm_setTranslation (const double *translation, double matrix[16])
void | fm_setTranslation (const float *translation, float matrix[16])
double | fm_solveX (const double plane[4], double y, double z)
float | fm_solveX (const float plane[4], float y, float z)
double | fm_solveY (const double plane[4], double x, double z)
float | fm_solveY (const float plane[4], float x, float z)
double | fm_solveZ (const double plane[4], double x, double y)
float | fm_solveZ (const float plane[4], float x, float y)
double | fm_sphereVolume (double radius)
float | fm_sphereVolume (float radius)
void | fm_subtract (const double *A, const double *B, double *diff)
void | fm_subtract (const float *A, const float *B, float *diff)
void | fm_transform (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_transformAABB (const double bmin[3], const double bmax[3], const double matrix[16], double tbmin[3], double tbmax[3])
void | fm_transformAABB (const float bmin[3], const float bmax[3], const float matrix[16], float tbmin[3], float tbmax[3])
## Variables
const float | FM_DEG_TO_RAD = ((2.0f * FM_PI) / 360.0f)
const float | FM_PI = 3.1415926535897932384626433832795028841971693993751f
const float | FM_RAD_TO_DEG = (360.0f / (2.0f * FM_PI))

## Enumeration Type Documentation

enum FLOAT_MATH::FM_Axis

Enumerator:

  FM_XAXIS |
  FM_YAXIS |
  FM_ZAXIS |

enum FLOAT_MATH::FM_ClipState

Enumerator:

  FMCS_XMIN |
  FMCS_XMAX |
  FMCS_YMIN |
  FMCS_YMAX |
  FMCS_ZMIN |
  FMCS_ZMAX |

enum FLOAT_MATH::IntersectResult

Enumerator:

  IR_DONT_INTERSECT |
  IR_DO_INTERSECT |
  IR_COINCIDENT |
  IR_PARALLEL |

enum FLOAT_MATH::LineSegmentType

Enumerator:

  LS_START |
  LS_MIDDLE |
  LS_END |

enum FLOAT_MATH::PlaneTriResult

Enumerator:

  PTR_ON_PLANE |
  PTR_FRONT |
  PTR_BACK |
  PTR_SPLIT |

## Function Documentation

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

uint32_t 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_Tesselate* FLOAT_MATH::fm_createTesselate | ( | void |  | ) |

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void FLOAT_MATH::fm_doubleToFloat3 | ( | const double | p[3],
|  | float | t[3] |
| ) |  |  | `[inline]`

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

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

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

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

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

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

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

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

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

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

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

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

void FLOAT_MATH::fm_floatToDouble3 | ( | const float | p[3],
|  | double | t[3] |
| ) |  |  | `[inline]`

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

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

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

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

double FLOAT_MATH::fm_getDeterminant | ( | const double | matrix[16] | ) |

float FLOAT_MATH::fm_getDeterminant | ( | const float | matrix[16] | ) |

FM_Axis FLOAT_MATH::fm_getDominantAxis | ( | const double | normal[3] | ) |

FM_Axis FLOAT_MATH::fm_getDominantAxis | ( | const float | normal[3] | ) |

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

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

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

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

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

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

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

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

void FLOAT_MATH::fm_identity | ( | double | matrix[16] | ) |

void FLOAT_MATH::fm_identity | ( | float | matrix[16] | ) |

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double FLOAT_MATH::fm_normalize | ( | double | n[3] | ) |

float FLOAT_MATH::fm_normalize | ( | float | n[3] | ) |

double FLOAT_MATH::fm_normalizeQuat | ( | double | n[4] | ) |

float FLOAT_MATH::fm_normalizeQuat | ( | float | n[4] | ) |

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double FLOAT_MATH::fm_sphereVolume | ( | double | radius | ) |

float FLOAT_MATH::fm_sphereVolume | ( | float | radius | ) |

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

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

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

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

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

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

## Variable Documentation

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

const float FLOAT_MATH::FM_PI = 3.1415926535897932384626433832795028841971693993751f

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