NW4F Sys
Loading...
Searching...
No Matches
nw::math Namespace Reference

Namespaces

namespace  internal

Classes

struct  MTX34
struct  MTX34_
struct  MTX44
struct  MTX44_
struct  QUAT
struct  QUAT_
struct  Transform2
struct  Transform2_
struct  Transform3
struct  Transform3_
struct  VEC2
struct  VEC2_
struct  VEC3
struct  VEC3_
struct  VEC4
struct  VEC4_

Typedefs

typedef struct MTX34 Matrix34
typedef struct MTX44 Matrix44
typedef struct QUAT Quaternion
typedef struct VEC2 Vector2
typedef struct VEC3 Vector3
typedef struct VEC4 Vector4

Enumerations

enum  PivotDirection {
  PIVOT_NONE , PIVOT_UPSIDE_TO_TOP , PIVOT_UPSIDE_TO_RIGHT , PIVOT_UPSIDE_TO_BOTTOM ,
  PIVOT_UPSIDE_TO_LEFT , PIVOT_NUM
}

Functions

f32 RadToDeg (f32 rad)
f32 DegToRad (f32 deg)
f32 SinIdx (u32 idx)
f32 CosIdx (u32 idx)
void SinCosIdx (f32 *pSin, f32 *pCos, u32 idx)
f32 TanIdx (u32 idx)
f32 SinRad (f32 rad)
f32 CosRad (f32 rad)
void SinCosRad (f32 *pSin, f32 *pCos, f32 rad)
f32 TanRad (f32 rad)
f32 SinDeg (f32 deg)
f32 CosDeg (f32 deg)
void SinCosDeg (f32 *pSin, f32 *pCos, f32 deg)
f32 TanDeg (f32 deg)
f32 FSelect (f32 cond, f32 ifPos, f32 ifNeg)
f32 FAbs (f32 x)
f32 FNAbs (f32 x)
f32 FCopySign (f32 abs, f32 sign)
f32 FExp (f32 x)
f32 FLog (f32 x)
f32 FLog10 (f32 x)
f32 FMod (f32 x, f32 y)
f32 FModf (f32 x, f32 *y)
f32 FCeil (f32 x)
f32 FFloor (f32 x)
s16 F32ToS16 (f32 x)
u16 F32ToU16 (f32 x)
f32 U16ToF32 (u16 x)
f32 S16ToF32 (s16 x)
f32 FInv (f32 x)
f32 FSqrt (f32 x)
f32 FCbrt (f32 x)
f32 Reciprocal (f32 x)
f32 Hermite (f32 v0, f32 t0, f32 v1, f32 t1, f32 s)
NW_FORCE_INLINE f32 Hermite (f32 v0, f32 t0, f32 v1, f32 t1, f32 p, f32 d)
bool IsPwr2 (int x)
int Rightmost1 (int x)
int Rightmost0 (int x)
NW_MATH_INLINE MTX34 * MTX34Zero (MTX34 *pOut)
NW_MATH_INLINE bool MTX34IsIdentity (const MTX34 *p)
NW_MATH_INLINE MTX34 * MTX34Identity (MTX34 *pOut)
NW_MATH_INLINE MTX34 * MTX34Add (MTX34 *pOut, const MTX34 *p1, const MTX34 *p2)
NW_MATH_INLINE MTX34 * MTX34Sub (MTX34 *pOut, const MTX34 *p1, const MTX34 *p2)
NW_MATH_INLINE MTX34 * MTX34Mult (MTX34 *pOut, const MTX34 *p, f32 f)
NW_MATH_INLINE MTX34 * MTX34MAdd (MTX34 *pOut, f32 t, const MTX34 *p1, const MTX34 *p2)
NW_MATH_INLINE MTX34 * MTX34MultArray (MTX34 *pOut, const MTX34 *p1, const MTX34 *pSrc, s32 count)
NW_MATH_INLINE u32 MTX34Inverse (MTX34 *pOut, const MTX34 *p)
NW_MATH_INLINE MTX34 * MTX34Transpose (MTX34 *pOut, const MTX34 *p)
NW_MATH_INLINE u32 MTX34InvTranspose (MTX34 *pOut, const MTX34 *p)
NW_MATH_INLINE MTX34 * MTX34LookAt (MTX34 *pOut, const VEC3 *pCamPos, const VEC3 *pCamUp, const VEC3 *pTarget)
NW_MATH_INLINE MTX34 * MTX34LookAt (MTX34 *pOut, const VEC3 *pCamPos, f32 twist, const VEC3 *pTarget)
NW_MATH_INLINE MTX34 * MTX34CameraRotate (MTX34 *pOut, const VEC3 *pCamPos, const VEC3 *pCamRotate)
NW_MATH_INLINE MTX34 * MTX34TextureProjectionFrustum (MTX34 *pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
NW_MATH_INLINE MTX34 * MTX34TextureProjectionPerspective (MTX34 *pOut, f32 fovy, f32 aspect, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
NW_MATH_INLINE MTX34 * MTX34TextureProjectionOrtho (MTX34 *pOut, f32 l, f32 r, f32 b, f32 t, f32 scaleS, f32 scaleT, f32 translateS, f32 translateT)
NW_MATH_INLINE MTX34 * MTX34RotXYZIdx (MTX34 *pOut, u32 idxX, u32 idxY, u32 idxZ)
NW_MATH_INLINE MTX34 * MTX34RotXYZTranslateIdx (MTX34 *pOut, u32 idxX, u32 idxY, u32 idxZ, const VEC3 *pT)
NW_MATH_INLINE MTX34 * MTX34RotAxisIdx (MTX34 *pOut, const VEC3 *pAxis, u32 idx)
NW_MATH_INLINE MTX34 * MTX34Scale (MTX34 *pOut, const VEC3 *pS)
NW_MATH_INLINE MTX34 * MTX34MultScale (MTX34 *pOut, const MTX34 *pM, const VEC3 *pS)
NW_MATH_INLINE MTX34 * MTX34MultScale (MTX34 *pOut, const VEC3 *pS, const MTX34 *pM)
NW_MATH_INLINE MTX34 * MTX34Translate (MTX34 *pOut, const VEC3 *pT)
NW_MATH_INLINE MTX34 * MTX34MultTranslate (MTX34 *pOut, const MTX34 *pM, const VEC3 *pT)
NW_MATH_INLINE MTX34 * MTX34MultTranslate (MTX34 *pOut, const VEC3 *pT, const MTX34 *pM)
NW_MATH_INLINE MTX34 * MTX34MakeSRT (MTX34 *pOut, const VEC3 *pS, const VEC3 *pR, const VEC3 *pT)
NW_MATH_INLINE MTX34 * MTX34MakeST (MTX34 *pOut, const VEC3 *pS, const VEC3 *pT)
NW_MATH_INLINE MTX34 * MTX34MakeS (MTX34 *pOut, const VEC3 *pS)
NW_MATH_INLINE MTX34 * QUATToMTX34 (MTX34 *pOut, const QUAT *p)
NW_FORCE_INLINE MTX34 * MTX34Copy (MTX34 *pOut, const MTX34 *p)
NW_FORCE_INLINE MTX34 * MTX34Mult (MTX34 *pOut, const MTX34 *p1, const MTX34 *p2)
MTX34 * MTX34RotXYZRad (MTX34 *pOut, f32 fRadX, f32 fRadY, f32 fRadZ)
MTX34 * MTX34RotXYZDeg (MTX34 *pOut, f32 fDegX, f32 fDegY, f32 fDegZ)
MTX34 * MTX34RotAxisRad (MTX34 *pOut, const VEC3 *pAxis, f32 fRad)
MTX34 * MTX34RotAxisDeg (MTX34 *pOut, const VEC3 *pAxis, f32 fDeg)
MTX34 operator* (f32 f, const MTX34 &rhs)
bool MTX34IsIdentity (const MTX34 &m)
MTX34 * MTX34Add (MTX34 *pOut, const MTX34 &m1, const MTX34 &m2)
MTX34 * MTX34Sub (MTX34 *pOut, const MTX34 &m1, const MTX34 &m2)
MTX34 * MTX34Mult (MTX34 *pOut, const MTX34 &m, f32 f)
MTX34 * MTX34Mult (MTX34 *pOut, const MTX34 &m1, const MTX34 &m2)
MTX34 * MTX34MAdd (MTX34 *pOut, f32 t, const MTX34 &m1, const MTX34 &m2)
MTX34 * MTX34Copy (MTX34 *pOut, const MTX34 &m)
MTX34 * MTX34MultArray (MTX34 *pOut, const MTX34 &m1, const MTX34 *pSrc, s32 count)
u32 MTX34Inverse (MTX34 *pOut, const MTX34 &m)
MTX34 * MTX34Transpose (MTX34 *pOut, const MTX34 &m)
u32 MTX34InvTranspose (MTX34 *pOut, const MTX34 &m)
MTX34 * MTX34LookAt (MTX34 *pOut, const VEC3 &vCamPos, const VEC3 &vCamUp, const VEC3 &vTarget)
MTX34 * MTX34LookAt (MTX34 *pOut, const VEC3 &vCamPos, f32 twist, const VEC3 &vTarget)
MTX34 * MTX34CameraRotate (MTX34 *pOut, const VEC3 &vCamPos, const VEC3 &vCamRotate)
MTX34 * MTX34RotXYZTranslateIdx (MTX34 *pOut, u32 idxX, u32 idxY, u32 idxZ, const VEC3 &vT)
MTX34 * MTX34RotAxisIdx (MTX34 *pOut, const VEC3 &vAxis, u32 idx)
MTX34 * MTX34RotAxisRad (MTX34 *pOut, const VEC3 &vAxis, f32 fRad)
MTX34 * MTX34RotAxisDeg (MTX34 *pOut, const VEC3 &vAxis, f32 fDeg)
MTX34 * MTX34Scale (MTX34 *pOut, const VEC3 &vS)
MTX34 * MTX34MultScale (MTX34 *pOut, const MTX34 &m, const VEC3 &vS)
MTX34 * MTX34MultScale (MTX34 *pOut, const VEC3 &vS, const MTX34 &m)
MTX34 * MTX34Translate (MTX34 *pOut, const VEC3 &vT)
MTX34 * MTX34MultTranslate (MTX34 *pOut, const MTX34 &m, const VEC3 &vT)
MTX34 * MTX34MultTranslate (MTX34 *pOut, const VEC3 &vT, const MTX34 &m)
MTX34 * MTX34MakeSRT (MTX34 *pOut, const VEC3 &s, const VEC3 &r, const VEC3 &t)
MTX34 * MTX34MakeST (MTX34 *pOut, const VEC3 &s, const VEC3 &t)
MTX34 * MTX34MakeS (MTX34 *pOut, const VEC3 &s)
MTX34 * QUATToMTX34 (MTX34 *pOut, const QUAT &q)
NW_MATH_INLINE MTX44 * MTX44Zero (MTX44 *pOut)
NW_MATH_INLINE bool MTX44IsIdentity (const MTX44 *p)
NW_MATH_INLINE MTX44 * MTX44Identity (MTX44 *pOut)
NW_MATH_INLINE MTX44 * MTX44Copy (MTX44 *pOut, const MTX44 *p)
NW_MATH_INLINE MTX44 * MTX44Add (MTX44 *pOut, const MTX44 *p1, const MTX44 *p2)
NW_MATH_INLINE MTX44 * MTX44Sub (MTX44 *pOut, const MTX44 *p1, const MTX44 *p2)
NW_MATH_INLINE MTX44 * MTX44Mult (MTX44 *pOut, const MTX44 *p, f32 f)
NW_MATH_INLINE MTX44 * MTX44Mult (MTX44 *pOut, const MTX44 *p1, const MTX44 *p2)
NW_MATH_INLINE MTX44 * MTX44FrustumNew (MTX44 *pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f)
NW_MATH_INLINE MTX44 * MTX44OrthoNew (MTX44 *pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f)
NW_MATH_INLINE MTX44 * MTX44PerspectiveRadNew (MTX44 *pOut, f32 fovyRad, f32 aspect, f32 n, f32 f)
NW_MATH_INLINE MTX44 * MTX44FrustumOld (MTX44 *pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f)
NW_MATH_INLINE MTX44 * MTX44OrthoOld (MTX44 *pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f)
NW_MATH_INLINE MTX44 * MTX44PerspectiveRadOld (MTX44 *pOut, f32 fovyRad, f32 aspect, f32 n, f32 f)
NW_MATH_INLINE MTX44 * MTX44Frustum (MTX44 *pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f)
NW_MATH_INLINE MTX44 * MTX44Ortho (MTX44 *pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f)
NW_MATH_INLINE MTX44 * MTX44PerspectiveRad (MTX44 *pOut, f32 fovyRad, f32 aspect, f32 n, f32 f)
NW_MATH_INLINE MTX44 * MTX44Transpose (MTX44 *pOut, const MTX44 *pSrc)
NW_MATH_INLINE MTX44 * MTX44MultArray (MTX44 *pOut, const MTX44 *p1, const MTX44 *pSrc, s32 count)
NW_MATH_INLINE u32 MTX44Inverse (MTX44 *pOut, const MTX44 *p)
NW_MATH_INLINE MTX44 * MTX44RotXYZIdx (MTX44 *pOut, u32 idxX, u32 idxY, u32 idxZ)
NW_MATH_INLINE MTX44 * MTX44RotAxisIdx (MTX44 *pOut, const VEC3 *pAxis, u32 idx)
NW_MATH_INLINE MTX44 * MTX44Scale (MTX44 *pOut, const VEC3 *pS)
NW_MATH_INLINE MTX44 * MTX44MultScale (MTX44 *pOut, const MTX44 *pM, const VEC3 *pS)
NW_MATH_INLINE MTX44 * MTX44MultScale (MTX44 *pOut, const VEC3 *pS, const MTX44 *pM)
NW_MATH_INLINE MTX44 * MTX44Translate (MTX44 *pOut, const VEC3 *pT)
NW_MATH_INLINE MTX44 * MTX44MultTranslate (MTX44 *pOut, const MTX44 *pM, const VEC3 *pT)
NW_MATH_INLINE MTX44 * MTX44MultTranslate (MTX44 *pOut, const VEC3 *pT, const MTX44 *pM)
NW_MATH_INLINE MTX44 * MTX44FrustumPivot (MTX44 *pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot=PIVOT_NONE)
NW_MATH_INLINE MTX44 * MTX44OrthoPivot (MTX44 *pOut, f32 l, f32 r, f32 b, f32 t, f32 n, f32 f, PivotDirection pivot=PIVOT_NONE)
NW_MATH_INLINE MTX44 * MTX44PerspectivePivotRad (MTX44 *pOut, f32 fovyRad, f32 aspect, f32 n, f32 f, PivotDirection pivot=PIVOT_NONE)
MTX44 * MTX44PerspectiveDeg (MTX44 *pOut, f32 fovyDeg, f32 aspect, f32 n, f32 f)
MTX44 * MTX44Perspective (MTX44 *pOut, f32 fovyRad, f32 aspect, f32 n, f32 f)
MTX44 * MTX44PerspectivePivotDeg (MTX44 *pOut, f32 fovyDeg, f32 aspect, f32 n, f32 f, PivotDirection pivot=PIVOT_NONE)
MTX44 * MTX44RotXYZRad (MTX44 *pOut, f32 fRadX, f32 fRadY, f32 fRadZ)
MTX44 * MTX44RotXYZDeg (MTX44 *pOut, f32 fDegX, f32 fDegY, f32 fDegZ)
MTX44 * MTX44RotAxisRad (MTX44 *pOut, const VEC3 *pAxis, f32 fRad)
MTX44 * MTX44RotAxisDeg (MTX44 *pOut, const VEC3 *pAxis, f32 fDeg)
MTX44 * MTX44Copy (MTX44 *pOut, const MTX44 &m)
bool MTX44IsIdentity (const MTX44 &m)
MTX44 * MTX44Add (MTX44 *pOut, const MTX44 &m1, const MTX44 &m2)
MTX44 * MTX44Sub (MTX44 *pOut, const MTX44 &m1, const MTX44 &m2)
MTX44 * MTX44Mult (MTX44 *pOut, const MTX44 &m, f32 f)
MTX44 * MTX44Mult (MTX44 *pOut, const MTX44 &m1, const MTX44 &m2)
MTX44 * MTX44Transpose (MTX44 *pOut, const MTX44 &m)
MTX44 * MTX44MultArray (MTX44 *pOut, const MTX44 &m1, const MTX44 *pSrc, s32 count)
u32 MTX44Inverse (MTX44 *pOut, const MTX44 &m)
MTX44 * MTX44RotAxisIdx (MTX44 *pOut, const VEC3 &vAxis, u32 idx)
MTX44 * MTX44RotAxisRad (MTX44 *pOut, const VEC3 &vAxis, f32 fRad)
MTX44 * MTX44RotAxisDeg (MTX44 *pOut, const VEC3 &vAxis, f32 fDeg)
MTX44 * MTX44Scale (MTX44 *pOut, const VEC3 &S)
MTX44 * MTX44MultScale (MTX44 *pOut, const MTX44 &M, const VEC3 &S)
MTX44 * MTX44MultScale (MTX44 *pOut, const VEC3 &S, const MTX44 &M)
MTX44 * MTX44Translate (MTX44 *pOut, const VEC3 &T)
MTX44 * MTX44MultTranslate (MTX44 *pOut, const MTX44 &M, const VEC3 &T)
MTX44 * MTX44MultTranslate (MTX44 *pOut, const VEC3 &T, const MTX44 &M)
NW_MATH_INLINE QUAT * QUATAdd (QUAT *pOut, const QUAT *q1, const QUAT *q2)
NW_MATH_INLINE QUAT * QUATSub (QUAT *pOut, const QUAT *q1, const QUAT *q2)
NW_MATH_INLINE QUAT * QUATDivide (QUAT *pOut, const QUAT *q1, const QUAT *q2)
NW_MATH_INLINE QUAT * QUATMult (QUAT *pOut, const QUAT *q1, const QUAT *q2)
NW_MATH_INLINE f32 QUATDot (const QUAT *q1, const QUAT *q2)
NW_MATH_INLINE QUAT * QUATInverse (QUAT *pOut, const QUAT *q)
NW_MATH_INLINE QUAT * QUATScale (QUAT *pOut, const QUAT *q, f32 scale)
NW_MATH_INLINE QUAT * QUATNormalize (QUAT *pOut, const QUAT *q)
NW_MATH_INLINE QUAT * QUATExp (QUAT *pOut, const QUAT *q)
NW_MATH_INLINE QUAT * QUATLogN (QUAT *pOut, const QUAT *q)
NW_MATH_INLINE QUAT * QUATLerp (QUAT *pOut, const QUAT *q1, const QUAT *q2, f32 t)
NW_MATH_INLINE QUAT * QUATSlerp (QUAT *pOut, const QUAT *q1, const QUAT *q2, f32 t)
NW_MATH_INLINE QUAT * MTX34ToQUAT (QUAT *pOut, const MTX34 *pMtx)
NW_MATH_INLINE QUAT * QUATSquad (QUAT *pOut, const QUAT *p, const QUAT *a, const QUAT *b, const QUAT *q, f32 t)
NW_MATH_INLINE QUAT * QUATMakeClosest (QUAT *pOut, const QUAT *q, const QUAT *qto)
NW_MATH_INLINE QUAT * QUATRotAxisRad (QUAT *pOut, const VEC3 *axis, f32 rad)
NW_MATH_INLINE QUAT * QUATMakeVectorRotation (QUAT *pOut, const VEC3 *pFrom, const VEC3 *pTo)
QUAT operator* (f32 f, const QUAT &rhs)
QUAT * QUATAdd (QUAT *pOut, const QUAT &q1, const QUAT &q2)
QUAT * QUATSub (QUAT *pOut, const QUAT &q1, const QUAT &q2)
QUAT * QUATDivide (QUAT *pOut, const QUAT &q1, const QUAT &q2)
QUAT * QUATMult (QUAT *pOut, const QUAT &q1, const QUAT &q2)
f32 QUATDot (const QUAT &q1, const QUAT &q2)
QUAT * QUATInverse (QUAT *pOut, const QUAT &q)
QUAT * QUATScale (QUAT *pOut, const QUAT &q, f32 scale)
QUAT * QUATNormalize (QUAT *pOut, const QUAT &q)
QUAT * QUATExp (QUAT *pOut, const QUAT &q)
QUAT * QUATLogN (QUAT *pOut, const QUAT &q)
QUAT * QUATLerp (QUAT *pOut, const QUAT &q1, const QUAT &q2, f32 t)
QUAT * QUATSlerp (QUAT *pOut, const QUAT &q1, const QUAT &q2, f32 t)
QUAT * MTX34ToQUAT (QUAT *pOut, const MTX34 &mtx)
QUAT * QUATSquad (QUAT *pOut, const QUAT &p, const QUAT &a, const QUAT &b, const QUAT &q, f32 t)
QUAT * QUATMakeClosest (QUAT *pOut, const QUAT &q, const QUAT &qto)
QUAT * QUATRotAxisRad (QUAT *pOut, const VEC3 &axis, f32 rad)
QUAT * QUATMakeVectorRotation (QUAT *pOut, const VEC3 &from, const VEC3 &to)
Transform2 * Transform2Identity (Transform2 *pOut)
Transform3 * Transform3Identity (Transform3 *pOut)
NW_MATH_INLINE VEC3 * VEC3TransformArray (VEC3 *pOut, const MTX34 *pM, const VEC3 *pV, s32 count)
NW_MATH_INLINE VEC4 * VEC3TransformArray (VEC4 *pOut, const MTX44 *pM, const VEC3 *pV, u32 count)
NW_MATH_INLINE VEC3 * VEC3TransformNormal (VEC3 *pOut, const MTX34 *pM, const VEC3 *pV)
NW_MATH_INLINE VEC3 * VEC3TransformNormalArray (VEC3 *pOutArray, const MTX34 *pM, const VEC3 *pArray, u32 n)
NW_MATH_INLINE VEC3 * VEC3TransformCoord (VEC3 *pOut, const MTX44 *pM, const VEC3 *pV)
NW_MATH_INLINE VEC3 * VEC3TransformCoordArray (VEC3 *pOut, const MTX44 *pM, const VEC3 *pV, u32 count)
NW_MATH_INLINE VEC4 * VEC4Transform (VEC4 *pOut, const MTX44 *pM, const VEC4 *pV)
NW_MATH_INLINE VEC4 * VEC4TransformArray (VEC4 *pOut, const MTX44 *pM, const VEC4 *pV, u32 n)
NW_MATH_INLINE VEC4 * VEC4Transform (VEC4 *pOut, const MTX34 *pM, const VEC4 *pV)
NW_MATH_INLINE VEC4 * VEC4TransformArray (VEC4 *pOut, const MTX34 *pM, const VEC4 *pV, u32 n)
VEC3 * VEC3Transform (VEC3 *pOut, const MTX34 &m, const VEC3 &v)
VEC4 * VEC3Transform (VEC4 *pOut, const MTX44 &m, const VEC3 &v)
VEC3 * VEC3TransformArray (VEC3 *pOutArray, const MTX34 &m, const VEC3 *pArray, s32 count)
VEC4 * VEC3TransformArray (VEC4 *pOutArray, const MTX44 &m, const VEC3 *pArray, u32 count)
VEC3 * VEC3TransformNormal (VEC3 *pOut, const MTX34 &m, const VEC3 &v)
VEC3 * VEC3TransformNormalArray (VEC3 *pOutArray, const MTX34 &m, const VEC3 *pArray, u32 n)
VEC3 * VEC3TransformCoord (VEC3 *pOut, const MTX44 &m, const VEC3 &v)
VEC3 * VEC3TransformCoordArray (VEC3 *pOutArray, const MTX44 &m, const VEC3 *pArray, u32 count)
VEC4 * VEC4Transform (VEC4 *pOut, const MTX44 &m, const VEC4 &v)
VEC4 * VEC4TransformArray (VEC4 *pOutArray, const MTX44 &m, const VEC4 *pArray, u32 n)
NW_MATH_INLINE bool VEC2IsZero (const VEC2 *p)
NW_MATH_INLINE VEC2 * VEC2Lerp (VEC2 *pOut, const VEC2 *p1, const VEC2 *p2, f32 t)
NW_MATH_INLINE f32 VEC2Dot (const VEC2 *p1, const VEC2 *p2)
NW_MATH_INLINE VEC2 * VEC2Maximize (VEC2 *pOut, const VEC2 *p1, const VEC2 *p2)
NW_MATH_INLINE VEC2 * VEC2Minimize (VEC2 *pOut, const VEC2 *p1, const VEC2 *p2)
VEC2 * VEC2Normalize (VEC2 *pOut, const VEC2 *p)
VEC2 * VEC2FastNormalize (VEC2 *pOut, const VEC2 *p)
VEC2 * VEC2SafeNormalize (VEC2 *pOut, const VEC2 *p, const VEC2 &alt)
VEC2 * VEC2FastSafeNormalize (VEC2 *pOut, const VEC2 *p, const VEC2 &alt)
NW_MATH_INLINE f32 VEC2DistSq (const VEC2 *p1, const VEC2 *p2)
VEC2 * VEC2Add (VEC2 *pOut, const VEC2 *p1, const VEC2 *p2)
VEC2 * VEC2Sub (VEC2 *pOut, const VEC2 *p1, const VEC2 *p2)
VEC2 * VEC2Scale (VEC2 *pOut, const VEC2 *p, f32 scale)
f32 VEC2LenSq (const VEC2 *p)
f32 VEC2Len (const VEC2 *p)
VEC2 operator* (f32 f, const VEC2 &rhs)
bool VEC2IsZero (const VEC2 &v)
VEC2 * VEC2Add (VEC2 *pOut, const VEC2 &p1, const VEC2 &p2)
VEC2 * VEC2Sub (VEC2 *pOut, const VEC2 &v1, const VEC2 &v2)
VEC2 * VEC2Scale (VEC2 *pOut, const VEC2 &v, f32 scale)
VEC2 * VEC2Lerp (VEC2 *pOut, const VEC2 &v1, const VEC2 &v2, f32 t)
f32 VEC2Dot (const VEC2 &v1, const VEC2 &v2)
f32 VEC2LenSq (const VEC2 &v)
f32 VEC2Len (const VEC2 &v)
f32 VEC2DistSq (const VEC2 &v1, const VEC2 &v2)
VEC2 * VEC2Maximize (VEC2 *pOut, const VEC2 &v1, const VEC2 &v2)
VEC2 * VEC2Minimize (VEC2 *pOut, const VEC2 &v1, const VEC2 &v2)
VEC2 * VEC2Normalize (VEC2 *pOut, const VEC2 &v)
VEC2 * VEC2FastNormalize (VEC2 *pOut, const VEC2 &v)
VEC2 * VEC2SafeNormalize (VEC2 *pOut, const VEC2 &v, const VEC2 &alt)
VEC2 * VEC2FastSafeNormalize (VEC2 *pOut, const VEC2 &v, const VEC2 &alt)
NW_MATH_INLINE bool VEC3IsZero (const VEC3 *p)
NW_MATH_INLINE VEC3 * VEC3Maximize (VEC3 *pOut, const VEC3 *p1, const VEC3 *p2)
NW_MATH_INLINE VEC3 * VEC3Minimize (VEC3 *pOut, const VEC3 *p1, const VEC3 *p2)
NW_MATH_INLINE VEC3 * VEC3Cross (VEC3 *pOut, const VEC3 *p1, const VEC3 *p2)
NW_MATH_INLINE VEC3 * VEC3Normalize (VEC3 *pOut, const VEC3 *p)
VEC3 * VEC3FastNormalize (VEC3 *pOut, const VEC3 *p)
NW_MATH_INLINE VEC3 * VEC3SafeNormalize (VEC3 *pOut, const VEC3 *p, const VEC3 &alt)
VEC3 * VEC3FastSafeNormalize (VEC3 *pOut, const VEC3 *p, const VEC3 &alt)
NW_MATH_INLINE f32 VEC3SquareDist (const VEC3 *p1, const VEC3 *p2)
VEC3 * VEC3Add (VEC3 *pOut, const VEC3 *p1, const VEC3 *p2)
VEC3 * VEC3Sub (VEC3 *pOut, const VEC3 *p1, const VEC3 *p2)
VEC3 * VEC3Mult (VEC3 *pOut, const VEC3 *p1, const VEC3 *p2)
VEC3 * VEC3Scale (VEC3 *pOut, const VEC3 *p, f32 scale)
VEC3 * VEC3Lerp (VEC3 *pOut, const VEC3 *p1, const VEC3 *p2, f32 t)
f32 VEC3Dot (const VEC3 *p1, const VEC3 *p2)
f32 VEC3Len (const VEC3 *p)
f32 VEC3SquareLen (const VEC3 *p)
f32 VEC3Dist (const VEC3 *p1, const VEC3 *p2)
VEC3 operator* (f32 f, const VEC3 &rhs)
bool VEC3IsZero (const VEC3 &v)
VEC3 * VEC3Maximize (VEC3 *pOut, const VEC3 &v1, const VEC3 &v2)
VEC3 * VEC3Minimize (VEC3 *pOut, const VEC3 &v1, const VEC3 &v2)
VEC3 * VEC3Cross (VEC3 *pOut, const VEC3 &v1, const VEC3 &v2)
VEC3 * VEC3Normalize (VEC3 *pOut, const VEC3 &v)
VEC3 * VEC3FastNormalize (VEC3 *pOut, const VEC3 &v)
VEC3 * VEC3SafeNormalize (VEC3 *pOut, const VEC3 &v, const VEC3 &alt)
VEC3 * VEC3FastSafeNormalize (VEC3 *pOut, const VEC3 &v, const VEC3 &alt)
f32 VEC3SquareDist (const VEC3 &v1, const VEC3 &v2)
VEC3 * VEC3Add (VEC3 *pOut, const VEC3 &v1, const VEC3 &v2)
VEC3 * VEC3Sub (VEC3 *pOut, const VEC3 &v1, const VEC3 &v2)
VEC3 * VEC3Scale (VEC3 *pOut, const VEC3 &v, f32 scale)
VEC3 * VEC3Lerp (VEC3 *pOut, const VEC3 &v1, const VEC3 &v2, f32 t)
f32 VEC3Dot (const VEC3 &v1, const VEC3 &v2)
f32 VEC3Len (const VEC3 &v)
f32 VEC3SquareLen (const VEC3 &v)
f32 VEC3Dist (const VEC3 &v1, const VEC3 &v2)
NW_MATH_INLINE bool VEC4IsZero (const VEC4 *p)
NW_MATH_INLINE bool VEC4IsZeroWOne (const VEC4 *p)
NW_MATH_INLINE VEC4 * VEC4Add (VEC4 *pOut, const VEC4 *p1, const VEC4 *p2)
NW_MATH_INLINE VEC4 * VEC4Sub (VEC4 *pOut, const VEC4 *p1, const VEC4 *p2)
NW_MATH_INLINE VEC4 * VEC4Scale (VEC4 *pOut, const VEC4 *p, f32 scale)
NW_MATH_INLINE VEC4 * VEC4Lerp (VEC4 *pOut, const VEC4 *p1, const VEC4 *p2, f32 t)
NW_MATH_INLINE f32 VEC4Dot (const VEC4 *p1, const VEC4 *p2)
NW_MATH_INLINE f32 VEC4LenSq (const VEC4 *p)
NW_MATH_INLINE f32 VEC4Len (const VEC4 *p)
VEC4 * VEC4Normalize (VEC4 *pOut, const VEC4 *p)
VEC4 * VEC4FastNormalize (VEC4 *pOut, const VEC4 *p)
VEC4 * VEC4SafeNormalize (VEC4 *pOut, const VEC4 *p, const VEC4 &alt)
VEC4 * VEC4FastSafeNormalize (VEC4 *pOut, const VEC4 *p, const VEC4 &alt)
NW_MATH_INLINE f32 VEC4DistSq (const VEC4 *p1, const VEC4 *p2)
NW_MATH_INLINE VEC4 * VEC4Maximize (VEC4 *pOut, const VEC4 *p1, const VEC4 *p2)
NW_MATH_INLINE VEC4 * VEC4Minimize (VEC4 *pOut, const VEC4 *p1, const VEC4 *p2)
VEC4 operator* (f32 f, const VEC4 &rhs)
bool VEC4IsZero (const VEC4 &v)
bool VEC4IsZeroWOne (const VEC4 &v)
VEC4 * VEC4Add (VEC4 *pOut, const VEC4 &v1, const VEC4 &v2)
VEC4 * VEC4Sub (VEC4 *pOut, const VEC4 &v1, const VEC4 &v2)
VEC4 * VEC4Scale (VEC4 *pOut, const VEC4 &v, f32 scale)
VEC4 * VEC4Lerp (VEC4 *pOut, const VEC4 &v1, const VEC4 &v2, f32 t)
f32 VEC4Dot (const VEC4 &v1, const VEC4 &v2)
f32 VEC4LenSq (const VEC4 &v)
f32 VEC4Len (const VEC4 &v)
VEC4 * VEC4Normalize (VEC4 *pOut, const VEC4 &v)
VEC4 * VEC4FastNormalize (VEC4 *pOut, const VEC4 &v)
VEC4 * VEC4SafeNormalize (VEC4 *pOut, const VEC4 &v, const VEC4 &alt)
VEC4 * VEC4FastSafeNormalize (VEC4 *pOut, const VEC4 &v, const VEC4 &alt)
f32 VEC4DistSq (const VEC4 &v1, const VEC4 &v2)
VEC4 * VEC4Maximize (VEC4 *pOut, const VEC4 &v1, const VEC4 &v2)
VEC4 * VEC4Minimize (VEC4 *pOut, const VEC4 &v1, const VEC4 &v2)

Variables

const f32 F_PI = 3.141592653589793f
const u32 I_HALF_ROUND_IDX = 0x80000000
const f32 F_ULP = std::numeric_limits<f32>::epsilon() * 2.0f

Typedef Documentation

◆ Matrix34

typedef struct MTX34 nw::math::Matrix34

◆ Matrix44

typedef struct MTX44 nw::math::Matrix44

◆ Quaternion

typedef struct QUAT nw::math::Quaternion

◆ Vector2

typedef struct VEC2 nw::math::Vector2

◆ Vector3

typedef struct VEC3 nw::math::Vector3

◆ Vector4

typedef struct VEC4 nw::math::Vector4

Enumeration Type Documentation

◆ PivotDirection

enum nw::math::PivotDirection
Enumerator
PIVOT_NONE 
PIVOT_UPSIDE_TO_TOP 
PIVOT_UPSIDE_TO_RIGHT 
PIVOT_UPSIDE_TO_BOTTOM 
PIVOT_UPSIDE_TO_LEFT 
PIVOT_NUM 

Function Documentation

◆ RadToDeg()

f32 nw::math::RadToDeg ( f32 rad)
inline

◆ DegToRad()

f32 nw::math::DegToRad ( f32 deg)
inline

◆ SinIdx()

f32 nw::math::SinIdx ( u32 idx)
inline

◆ CosIdx()

f32 nw::math::CosIdx ( u32 idx)
inline

◆ SinCosIdx()

void nw::math::SinCosIdx ( f32 * pSin,
f32 * pCos,
u32 idx )
inline

◆ TanIdx()

f32 nw::math::TanIdx ( u32 idx)
inline

◆ SinRad()

f32 nw::math::SinRad ( f32 rad)
inline

◆ CosRad()

f32 nw::math::CosRad ( f32 rad)
inline

◆ SinCosRad()

void nw::math::SinCosRad ( f32 * pSin,
f32 * pCos,
f32 rad )
inline

◆ TanRad()

f32 nw::math::TanRad ( f32 rad)
inline

◆ SinDeg()

f32 nw::math::SinDeg ( f32 deg)
inline

◆ CosDeg()

f32 nw::math::CosDeg ( f32 deg)
inline

◆ SinCosDeg()

void nw::math::SinCosDeg ( f32 * pSin,
f32 * pCos,
f32 deg )
inline

◆ TanDeg()

f32 nw::math::TanDeg ( f32 deg)
inline

◆ FSelect()

f32 nw::math::FSelect ( f32 cond,
f32 ifPos,
f32 ifNeg )
inline

◆ FAbs()

f32 nw::math::FAbs ( f32 x)
inline

◆ FNAbs()

f32 nw::math::FNAbs ( f32 x)
inline

◆ FCopySign()

f32 nw::math::FCopySign ( f32 abs,
f32 sign )
inline

◆ FExp()

f32 nw::math::FExp ( f32 x)
inline

◆ FLog()

f32 nw::math::FLog ( f32 x)
inline

◆ FLog10()

f32 nw::math::FLog10 ( f32 x)
inline

◆ FMod()

f32 nw::math::FMod ( f32 x,
f32 y )
inline

◆ FModf()

f32 nw::math::FModf ( f32 x,
f32 * y )
inline

◆ FCeil()

f32 nw::math::FCeil ( f32 x)
inline

◆ FFloor()

f32 nw::math::FFloor ( f32 x)
inline

◆ F32ToS16()

s16 nw::math::F32ToS16 ( f32 x)
inline

◆ F32ToU16()

u16 nw::math::F32ToU16 ( f32 x)
inline

◆ U16ToF32()

f32 nw::math::U16ToF32 ( u16 x)
inline

◆ S16ToF32()

f32 nw::math::S16ToF32 ( s16 x)
inline

◆ FInv()

f32 nw::math::FInv ( f32 x)
inline

◆ FSqrt()

f32 nw::math::FSqrt ( f32 x)
inline

◆ FCbrt()

f32 nw::math::FCbrt ( f32 x)
inline

◆ Reciprocal()

f32 nw::math::Reciprocal ( f32 x)
inline

◆ Hermite() [1/2]

f32 nw::math::Hermite ( f32 v0,
f32 t0,
f32 v1,
f32 t1,
f32 s )
inline

◆ Hermite() [2/2]

NW_FORCE_INLINE f32 nw::math::Hermite ( f32 v0,
f32 t0,
f32 v1,
f32 t1,
f32 p,
f32 d )

◆ IsPwr2()

bool nw::math::IsPwr2 ( int x)
inline

◆ Rightmost1()

int nw::math::Rightmost1 ( int x)
inline

◆ Rightmost0()

int nw::math::Rightmost0 ( int x)
inline

◆ MTX34Zero()

NW_MATH_INLINE MTX34 * nw::math::MTX34Zero ( MTX34 * pOut)

◆ MTX34IsIdentity() [1/2]

NW_MATH_INLINE bool nw::math::MTX34IsIdentity ( const MTX34 * p)

◆ MTX34Identity()

NW_MATH_INLINE MTX34 * nw::math::MTX34Identity ( MTX34 * pOut)

◆ MTX34Add() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34Add ( MTX34 * pOut,
const MTX34 * p1,
const MTX34 * p2 )

◆ MTX34Sub() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34Sub ( MTX34 * pOut,
const MTX34 * p1,
const MTX34 * p2 )

◆ MTX34Mult() [1/4]

NW_MATH_INLINE MTX34 * nw::math::MTX34Mult ( MTX34 * pOut,
const MTX34 * p,
f32 f )

◆ MTX34MAdd() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34MAdd ( MTX34 * pOut,
f32 t,
const MTX34 * p1,
const MTX34 * p2 )

◆ MTX34MultArray() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34MultArray ( MTX34 * pOut,
const MTX34 * p1,
const MTX34 * pSrc,
s32 count )

◆ MTX34Inverse() [1/2]

NW_MATH_INLINE u32 nw::math::MTX34Inverse ( MTX34 * pOut,
const MTX34 * p )

◆ MTX34Transpose() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34Transpose ( MTX34 * pOut,
const MTX34 * p )

◆ MTX34InvTranspose() [1/2]

NW_MATH_INLINE u32 nw::math::MTX34InvTranspose ( MTX34 * pOut,
const MTX34 * p )

◆ MTX34LookAt() [1/4]

NW_MATH_INLINE MTX34 * nw::math::MTX34LookAt ( MTX34 * pOut,
const VEC3 * pCamPos,
const VEC3 * pCamUp,
const VEC3 * pTarget )

◆ MTX34LookAt() [2/4]

NW_MATH_INLINE MTX34 * nw::math::MTX34LookAt ( MTX34 * pOut,
const VEC3 * pCamPos,
f32 twist,
const VEC3 * pTarget )

◆ MTX34CameraRotate() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34CameraRotate ( MTX34 * pOut,
const VEC3 * pCamPos,
const VEC3 * pCamRotate )

◆ MTX34TextureProjectionFrustum()

NW_MATH_INLINE MTX34 * nw::math::MTX34TextureProjectionFrustum ( MTX34 * pOut,
f32 l,
f32 r,
f32 b,
f32 t,
f32 n,
f32 scaleS,
f32 scaleT,
f32 translateS,
f32 translateT )

◆ MTX34TextureProjectionPerspective()

NW_MATH_INLINE MTX34 * nw::math::MTX34TextureProjectionPerspective ( MTX34 * pOut,
f32 fovy,
f32 aspect,
f32 scaleS,
f32 scaleT,
f32 translateS,
f32 translateT )

◆ MTX34TextureProjectionOrtho()

NW_MATH_INLINE MTX34 * nw::math::MTX34TextureProjectionOrtho ( MTX34 * pOut,
f32 l,
f32 r,
f32 b,
f32 t,
f32 scaleS,
f32 scaleT,
f32 translateS,
f32 translateT )

◆ MTX34RotXYZIdx()

NW_MATH_INLINE MTX34 * nw::math::MTX34RotXYZIdx ( MTX34 * pOut,
u32 idxX,
u32 idxY,
u32 idxZ )

◆ MTX34RotXYZTranslateIdx() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34RotXYZTranslateIdx ( MTX34 * pOut,
u32 idxX,
u32 idxY,
u32 idxZ,
const VEC3 * pT )

◆ MTX34RotAxisIdx() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34RotAxisIdx ( MTX34 * pOut,
const VEC3 * pAxis,
u32 idx )

◆ MTX34Scale() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34Scale ( MTX34 * pOut,
const VEC3 * pS )

◆ MTX34MultScale() [1/4]

NW_MATH_INLINE MTX34 * nw::math::MTX34MultScale ( MTX34 * pOut,
const MTX34 * pM,
const VEC3 * pS )

◆ MTX34MultScale() [2/4]

NW_MATH_INLINE MTX34 * nw::math::MTX34MultScale ( MTX34 * pOut,
const VEC3 * pS,
const MTX34 * pM )

◆ MTX34Translate() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34Translate ( MTX34 * pOut,
const VEC3 * pT )

◆ MTX34MultTranslate() [1/4]

NW_MATH_INLINE MTX34 * nw::math::MTX34MultTranslate ( MTX34 * pOut,
const MTX34 * pM,
const VEC3 * pT )

◆ MTX34MultTranslate() [2/4]

NW_MATH_INLINE MTX34 * nw::math::MTX34MultTranslate ( MTX34 * pOut,
const VEC3 * pT,
const MTX34 * pM )

◆ MTX34MakeSRT() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34MakeSRT ( MTX34 * pOut,
const VEC3 * pS,
const VEC3 * pR,
const VEC3 * pT )

◆ MTX34MakeST() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34MakeST ( MTX34 * pOut,
const VEC3 * pS,
const VEC3 * pT )

◆ MTX34MakeS() [1/2]

NW_MATH_INLINE MTX34 * nw::math::MTX34MakeS ( MTX34 * pOut,
const VEC3 * pS )

◆ QUATToMTX34() [1/2]

NW_MATH_INLINE MTX34 * nw::math::QUATToMTX34 ( MTX34 * pOut,
const QUAT * p )

◆ MTX34Copy() [1/2]

NW_FORCE_INLINE MTX34 * nw::math::MTX34Copy ( MTX34 * pOut,
const MTX34 * p )

◆ MTX34Mult() [2/4]

NW_INLINE MTX34 * nw::math::MTX34Mult ( MTX34 * pOut,
const MTX34 * p1,
const MTX34 * p2 )

◆ MTX34RotXYZRad()

MTX34 * nw::math::MTX34RotXYZRad ( MTX34 * pOut,
f32 fRadX,
f32 fRadY,
f32 fRadZ )
inline

◆ MTX34RotXYZDeg()

MTX34 * nw::math::MTX34RotXYZDeg ( MTX34 * pOut,
f32 fDegX,
f32 fDegY,
f32 fDegZ )
inline

◆ MTX34RotAxisRad() [1/2]

MTX34 * nw::math::MTX34RotAxisRad ( MTX34 * pOut,
const VEC3 * pAxis,
f32 fRad )
inline

◆ MTX34RotAxisDeg() [1/2]

MTX34 * nw::math::MTX34RotAxisDeg ( MTX34 * pOut,
const VEC3 * pAxis,
f32 fDeg )
inline

◆ operator*() [1/5]

MTX34 nw::math::operator* ( f32 f,
const MTX34 & rhs )
inline

◆ MTX34IsIdentity() [2/2]

bool nw::math::MTX34IsIdentity ( const MTX34 & m)
inline

◆ MTX34Add() [2/2]

MTX34 * nw::math::MTX34Add ( MTX34 * pOut,
const MTX34 & m1,
const MTX34 & m2 )
inline

◆ MTX34Sub() [2/2]

MTX34 * nw::math::MTX34Sub ( MTX34 * pOut,
const MTX34 & m1,
const MTX34 & m2 )
inline

◆ MTX34Mult() [3/4]

MTX34 * nw::math::MTX34Mult ( MTX34 * pOut,
const MTX34 & m,
f32 f )
inline

◆ MTX34Mult() [4/4]

MTX34 * nw::math::MTX34Mult ( MTX34 * pOut,
const MTX34 & m1,
const MTX34 & m2 )
inline

◆ MTX34MAdd() [2/2]

MTX34 * nw::math::MTX34MAdd ( MTX34 * pOut,
f32 t,
const MTX34 & m1,
const MTX34 & m2 )
inline

◆ MTX34Copy() [2/2]

MTX34 * nw::math::MTX34Copy ( MTX34 * pOut,
const MTX34 & m )
inline

◆ MTX34MultArray() [2/2]

MTX34 * nw::math::MTX34MultArray ( MTX34 * pOut,
const MTX34 & m1,
const MTX34 * pSrc,
s32 count )
inline

◆ MTX34Inverse() [2/2]

u32 nw::math::MTX34Inverse ( MTX34 * pOut,
const MTX34 & m )
inline

◆ MTX34Transpose() [2/2]

MTX34 * nw::math::MTX34Transpose ( MTX34 * pOut,
const MTX34 & m )
inline

◆ MTX34InvTranspose() [2/2]

u32 nw::math::MTX34InvTranspose ( MTX34 * pOut,
const MTX34 & m )
inline

◆ MTX34LookAt() [3/4]

MTX34 * nw::math::MTX34LookAt ( MTX34 * pOut,
const VEC3 & vCamPos,
const VEC3 & vCamUp,
const VEC3 & vTarget )
inline

◆ MTX34LookAt() [4/4]

MTX34 * nw::math::MTX34LookAt ( MTX34 * pOut,
const VEC3 & vCamPos,
f32 twist,
const VEC3 & vTarget )
inline

◆ MTX34CameraRotate() [2/2]

MTX34 * nw::math::MTX34CameraRotate ( MTX34 * pOut,
const VEC3 & vCamPos,
const VEC3 & vCamRotate )
inline

◆ MTX34RotXYZTranslateIdx() [2/2]

MTX34 * nw::math::MTX34RotXYZTranslateIdx ( MTX34 * pOut,
u32 idxX,
u32 idxY,
u32 idxZ,
const VEC3 & vT )
inline

◆ MTX34RotAxisIdx() [2/2]

MTX34 * nw::math::MTX34RotAxisIdx ( MTX34 * pOut,
const VEC3 & vAxis,
u32 idx )
inline

◆ MTX34RotAxisRad() [2/2]

MTX34 * nw::math::MTX34RotAxisRad ( MTX34 * pOut,
const VEC3 & vAxis,
f32 fRad )
inline

◆ MTX34RotAxisDeg() [2/2]

MTX34 * nw::math::MTX34RotAxisDeg ( MTX34 * pOut,
const VEC3 & vAxis,
f32 fDeg )
inline

◆ MTX34Scale() [2/2]

MTX34 * nw::math::MTX34Scale ( MTX34 * pOut,
const VEC3 & vS )
inline

◆ MTX34MultScale() [3/4]

MTX34 * nw::math::MTX34MultScale ( MTX34 * pOut,
const MTX34 & m,
const VEC3 & vS )
inline

◆ MTX34MultScale() [4/4]

MTX34 * nw::math::MTX34MultScale ( MTX34 * pOut,
const VEC3 & vS,
const MTX34 & m )
inline

◆ MTX34Translate() [2/2]

MTX34 * nw::math::MTX34Translate ( MTX34 * pOut,
const VEC3 & vT )
inline

◆ MTX34MultTranslate() [3/4]

MTX34 * nw::math::MTX34MultTranslate ( MTX34 * pOut,
const MTX34 & m,
const VEC3 & vT )
inline

◆ MTX34MultTranslate() [4/4]

MTX34 * nw::math::MTX34MultTranslate ( MTX34 * pOut,
const VEC3 & vT,
const MTX34 & m )
inline

◆ MTX34MakeSRT() [2/2]

MTX34 * nw::math::MTX34MakeSRT ( MTX34 * pOut,
const VEC3 & s,
const VEC3 & r,
const VEC3 & t )
inline

◆ MTX34MakeST() [2/2]

MTX34 * nw::math::MTX34MakeST ( MTX34 * pOut,
const VEC3 & s,
const VEC3 & t )
inline

◆ MTX34MakeS() [2/2]

MTX34 * nw::math::MTX34MakeS ( MTX34 * pOut,
const VEC3 & s )
inline

◆ QUATToMTX34() [2/2]

MTX34 * nw::math::QUATToMTX34 ( MTX34 * pOut,
const QUAT & q )
inline

◆ MTX44Zero()

NW_MATH_INLINE MTX44 * nw::math::MTX44Zero ( MTX44 * pOut)

◆ MTX44IsIdentity() [1/2]

NW_MATH_INLINE bool nw::math::MTX44IsIdentity ( const MTX44 * p)

◆ MTX44Identity()

NW_MATH_INLINE MTX44 * nw::math::MTX44Identity ( MTX44 * pOut)

◆ MTX44Copy() [1/2]

NW_MATH_INLINE MTX44 * nw::math::MTX44Copy ( MTX44 * pOut,
const MTX44 * p )

◆ MTX44Add() [1/2]

NW_MATH_INLINE MTX44 * nw::math::MTX44Add ( MTX44 * pOut,
const MTX44 * p1,
const MTX44 * p2 )

◆ MTX44Sub() [1/2]

NW_MATH_INLINE MTX44 * nw::math::MTX44Sub ( MTX44 * pOut,
const MTX44 * p1,
const MTX44 * p2 )

◆ MTX44Mult() [1/4]

NW_MATH_INLINE MTX44 * nw::math::MTX44Mult ( MTX44 * pOut,
const MTX44 * p,
f32 f )

◆ MTX44Mult() [2/4]

NW_MATH_INLINE MTX44 * nw::math::MTX44Mult ( MTX44 * pOut,
const MTX44 * p1,
const MTX44 * p2 )

◆ MTX44FrustumNew()

NW_MATH_INLINE MTX44 * nw::math::MTX44FrustumNew ( MTX44 * pOut,
f32 l,
f32 r,
f32 b,
f32 t,
f32 n,
f32 f )

◆ MTX44OrthoNew()

NW_MATH_INLINE MTX44 * nw::math::MTX44OrthoNew ( MTX44 * pOut,
f32 l,
f32 r,
f32 b,
f32 t,
f32 n,
f32 f )

◆ MTX44PerspectiveRadNew()

NW_MATH_INLINE MTX44 * nw::math::MTX44PerspectiveRadNew ( MTX44 * pOut,
f32 fovyRad,
f32 aspect,
f32 n,
f32 f )

◆ MTX44FrustumOld()

NW_MATH_INLINE MTX44 * nw::math::MTX44FrustumOld ( MTX44 * pOut,
f32 l,
f32 r,
f32 b,
f32 t,
f32 n,
f32 f )

◆ MTX44OrthoOld()

NW_MATH_INLINE MTX44 * nw::math::MTX44OrthoOld ( MTX44 * pOut,
f32 l,
f32 r,
f32 b,
f32 t,
f32 n,
f32 f )

◆ MTX44PerspectiveRadOld()

NW_MATH_INLINE MTX44 * nw::math::MTX44PerspectiveRadOld ( MTX44 * pOut,
f32 fovyRad,
f32 aspect,
f32 n,
f32 f )

◆ MTX44Frustum()

NW_MATH_INLINE MTX44 * nw::math::MTX44Frustum ( MTX44 * pOut,
f32 l,
f32 r,
f32 b,
f32 t,
f32 n,
f32 f )

◆ MTX44Ortho()

NW_MATH_INLINE MTX44 * nw::math::MTX44Ortho ( MTX44 * pOut,
f32 l,
f32 r,
f32 b,
f32 t,
f32 n,
f32 f )

◆ MTX44PerspectiveRad()

NW_MATH_INLINE MTX44 * nw::math::MTX44PerspectiveRad ( MTX44 * pOut,
f32 fovyRad,
f32 aspect,
f32 n,
f32 f )

◆ MTX44Transpose() [1/2]

NW_MATH_INLINE MTX44 * nw::math::MTX44Transpose ( MTX44 * pOut,
const MTX44 * pSrc )

◆ MTX44MultArray() [1/2]

NW_MATH_INLINE MTX44 * nw::math::MTX44MultArray ( MTX44 * pOut,
const MTX44 * p1,
const MTX44 * pSrc,
s32 count )

◆ MTX44Inverse() [1/2]

NW_MATH_INLINE u32 nw::math::MTX44Inverse ( MTX44 * pOut,
const MTX44 * p )

◆ MTX44RotXYZIdx()

NW_MATH_INLINE MTX44 * nw::math::MTX44RotXYZIdx ( MTX44 * pOut,
u32 idxX,
u32 idxY,
u32 idxZ )

◆ MTX44RotAxisIdx() [1/2]

NW_MATH_INLINE MTX44 * nw::math::MTX44RotAxisIdx ( MTX44 * pOut,
const VEC3 * pAxis,
u32 idx )

◆ MTX44Scale() [1/2]

NW_MATH_INLINE MTX44 * nw::math::MTX44Scale ( MTX44 * pOut,
const VEC3 * pS )

◆ MTX44MultScale() [1/4]

NW_MATH_INLINE MTX44 * nw::math::MTX44MultScale ( MTX44 * pOut,
const MTX44 * pM,
const VEC3 * pS )

◆ MTX44MultScale() [2/4]

NW_MATH_INLINE MTX44 * nw::math::MTX44MultScale ( MTX44 * pOut,
const VEC3 * pS,
const MTX44 * pM )

◆ MTX44Translate() [1/2]

NW_MATH_INLINE MTX44 * nw::math::MTX44Translate ( MTX44 * pOut,
const VEC3 * pT )

◆ MTX44MultTranslate() [1/4]

NW_MATH_INLINE MTX44 * nw::math::MTX44MultTranslate ( MTX44 * pOut,
const MTX44 * pM,
const VEC3 * pT )

◆ MTX44MultTranslate() [2/4]

NW_MATH_INLINE MTX44 * nw::math::MTX44MultTranslate ( MTX44 * pOut,
const VEC3 * pT,
const MTX44 * pM )

◆ MTX44FrustumPivot()

NW_MATH_INLINE MTX44 * nw::math::MTX44FrustumPivot ( MTX44 * pOut,
f32 l,
f32 r,
f32 b,
f32 t,
f32 n,
f32 f,
PivotDirection pivot = PIVOT_NONE )

◆ MTX44OrthoPivot()

NW_MATH_INLINE MTX44 * nw::math::MTX44OrthoPivot ( MTX44 * pOut,
f32 l,
f32 r,
f32 b,
f32 t,
f32 n,
f32 f,
PivotDirection pivot = PIVOT_NONE )

◆ MTX44PerspectivePivotRad()

NW_MATH_INLINE MTX44 * nw::math::MTX44PerspectivePivotRad ( MTX44 * pOut,
f32 fovyRad,
f32 aspect,
f32 n,
f32 f,
PivotDirection pivot = PIVOT_NONE )

◆ MTX44PerspectiveDeg()

MTX44 * nw::math::MTX44PerspectiveDeg ( MTX44 * pOut,
f32 fovyDeg,
f32 aspect,
f32 n,
f32 f )
inline

◆ MTX44Perspective()

MTX44 * nw::math::MTX44Perspective ( MTX44 * pOut,
f32 fovyRad,
f32 aspect,
f32 n,
f32 f )
inline

◆ MTX44PerspectivePivotDeg()

MTX44 * nw::math::MTX44PerspectivePivotDeg ( MTX44 * pOut,
f32 fovyDeg,
f32 aspect,
f32 n,
f32 f,
PivotDirection pivot = PIVOT_NONE )
inline

◆ MTX44RotXYZRad()

MTX44 * nw::math::MTX44RotXYZRad ( MTX44 * pOut,
f32 fRadX,
f32 fRadY,
f32 fRadZ )
inline

◆ MTX44RotXYZDeg()

MTX44 * nw::math::MTX44RotXYZDeg ( MTX44 * pOut,
f32 fDegX,
f32 fDegY,
f32 fDegZ )
inline

◆ MTX44RotAxisRad() [1/2]

MTX44 * nw::math::MTX44RotAxisRad ( MTX44 * pOut,
const VEC3 * pAxis,
f32 fRad )
inline

◆ MTX44RotAxisDeg() [1/2]

MTX44 * nw::math::MTX44RotAxisDeg ( MTX44 * pOut,
const VEC3 * pAxis,
f32 fDeg )
inline

◆ MTX44Copy() [2/2]

MTX44 * nw::math::MTX44Copy ( MTX44 * pOut,
const MTX44 & m )
inline

◆ MTX44IsIdentity() [2/2]

bool nw::math::MTX44IsIdentity ( const MTX44 & m)
inline

◆ MTX44Add() [2/2]

MTX44 * nw::math::MTX44Add ( MTX44 * pOut,
const MTX44 & m1,
const MTX44 & m2 )
inline

◆ MTX44Sub() [2/2]

MTX44 * nw::math::MTX44Sub ( MTX44 * pOut,
const MTX44 & m1,
const MTX44 & m2 )
inline

◆ MTX44Mult() [3/4]

MTX44 * nw::math::MTX44Mult ( MTX44 * pOut,
const MTX44 & m,
f32 f )
inline

◆ MTX44Mult() [4/4]

MTX44 * nw::math::MTX44Mult ( MTX44 * pOut,
const MTX44 & m1,
const MTX44 & m2 )
inline

◆ MTX44Transpose() [2/2]

MTX44 * nw::math::MTX44Transpose ( MTX44 * pOut,
const MTX44 & m )
inline

◆ MTX44MultArray() [2/2]

MTX44 * nw::math::MTX44MultArray ( MTX44 * pOut,
const MTX44 & m1,
const MTX44 * pSrc,
s32 count )
inline

◆ MTX44Inverse() [2/2]

u32 nw::math::MTX44Inverse ( MTX44 * pOut,
const MTX44 & m )
inline

◆ MTX44RotAxisIdx() [2/2]

MTX44 * nw::math::MTX44RotAxisIdx ( MTX44 * pOut,
const VEC3 & vAxis,
u32 idx )
inline

◆ MTX44RotAxisRad() [2/2]

MTX44 * nw::math::MTX44RotAxisRad ( MTX44 * pOut,
const VEC3 & vAxis,
f32 fRad )
inline

◆ MTX44RotAxisDeg() [2/2]

MTX44 * nw::math::MTX44RotAxisDeg ( MTX44 * pOut,
const VEC3 & vAxis,
f32 fDeg )
inline

◆ MTX44Scale() [2/2]

MTX44 * nw::math::MTX44Scale ( MTX44 * pOut,
const VEC3 & S )
inline

◆ MTX44MultScale() [3/4]

MTX44 * nw::math::MTX44MultScale ( MTX44 * pOut,
const MTX44 & M,
const VEC3 & S )
inline

◆ MTX44MultScale() [4/4]

MTX44 * nw::math::MTX44MultScale ( MTX44 * pOut,
const VEC3 & S,
const MTX44 & M )
inline

◆ MTX44Translate() [2/2]

MTX44 * nw::math::MTX44Translate ( MTX44 * pOut,
const VEC3 & T )
inline

◆ MTX44MultTranslate() [3/4]

MTX44 * nw::math::MTX44MultTranslate ( MTX44 * pOut,
const MTX44 & M,
const VEC3 & T )
inline

◆ MTX44MultTranslate() [4/4]

MTX44 * nw::math::MTX44MultTranslate ( MTX44 * pOut,
const VEC3 & T,
const MTX44 & M )
inline

◆ QUATAdd() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATAdd ( QUAT * pOut,
const QUAT * q1,
const QUAT * q2 )

◆ QUATSub() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATSub ( QUAT * pOut,
const QUAT * q1,
const QUAT * q2 )

◆ QUATDivide() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATDivide ( QUAT * pOut,
const QUAT * q1,
const QUAT * q2 )

◆ QUATMult() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATMult ( QUAT * pOut,
const QUAT * q1,
const QUAT * q2 )

◆ QUATDot() [1/2]

NW_MATH_INLINE f32 nw::math::QUATDot ( const QUAT * q1,
const QUAT * q2 )

◆ QUATInverse() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATInverse ( QUAT * pOut,
const QUAT * q )

◆ QUATScale() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATScale ( QUAT * pOut,
const QUAT * q,
f32 scale )

◆ QUATNormalize() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATNormalize ( QUAT * pOut,
const QUAT * q )

◆ QUATExp() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATExp ( QUAT * pOut,
const QUAT * q )

◆ QUATLogN() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATLogN ( QUAT * pOut,
const QUAT * q )

◆ QUATLerp() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATLerp ( QUAT * pOut,
const QUAT * q1,
const QUAT * q2,
f32 t )

◆ QUATSlerp() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATSlerp ( QUAT * pOut,
const QUAT * q1,
const QUAT * q2,
f32 t )

◆ MTX34ToQUAT() [1/2]

NW_MATH_INLINE QUAT * nw::math::MTX34ToQUAT ( QUAT * pOut,
const MTX34 * pMtx )

◆ QUATSquad() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATSquad ( QUAT * pOut,
const QUAT * p,
const QUAT * a,
const QUAT * b,
const QUAT * q,
f32 t )

◆ QUATMakeClosest() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATMakeClosest ( QUAT * pOut,
const QUAT * q,
const QUAT * qto )

◆ QUATRotAxisRad() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATRotAxisRad ( QUAT * pOut,
const VEC3 * axis,
f32 rad )

◆ QUATMakeVectorRotation() [1/2]

NW_MATH_INLINE QUAT * nw::math::QUATMakeVectorRotation ( QUAT * pOut,
const VEC3 * pFrom,
const VEC3 * pTo )

◆ operator*() [2/5]

QUAT nw::math::operator* ( f32 f,
const QUAT & rhs )
inline

◆ QUATAdd() [2/2]

QUAT * nw::math::QUATAdd ( QUAT * pOut,
const QUAT & q1,
const QUAT & q2 )
inline

◆ QUATSub() [2/2]

QUAT * nw::math::QUATSub ( QUAT * pOut,
const QUAT & q1,
const QUAT & q2 )
inline

◆ QUATDivide() [2/2]

QUAT * nw::math::QUATDivide ( QUAT * pOut,
const QUAT & q1,
const QUAT & q2 )
inline

◆ QUATMult() [2/2]

QUAT * nw::math::QUATMult ( QUAT * pOut,
const QUAT & q1,
const QUAT & q2 )
inline

◆ QUATDot() [2/2]

f32 nw::math::QUATDot ( const QUAT & q1,
const QUAT & q2 )
inline

◆ QUATInverse() [2/2]

QUAT * nw::math::QUATInverse ( QUAT * pOut,
const QUAT & q )
inline

◆ QUATScale() [2/2]

QUAT * nw::math::QUATScale ( QUAT * pOut,
const QUAT & q,
f32 scale )
inline

◆ QUATNormalize() [2/2]

QUAT * nw::math::QUATNormalize ( QUAT * pOut,
const QUAT & q )
inline

◆ QUATExp() [2/2]

QUAT * nw::math::QUATExp ( QUAT * pOut,
const QUAT & q )
inline

◆ QUATLogN() [2/2]

QUAT * nw::math::QUATLogN ( QUAT * pOut,
const QUAT & q )
inline

◆ QUATLerp() [2/2]

QUAT * nw::math::QUATLerp ( QUAT * pOut,
const QUAT & q1,
const QUAT & q2,
f32 t )
inline

◆ QUATSlerp() [2/2]

QUAT * nw::math::QUATSlerp ( QUAT * pOut,
const QUAT & q1,
const QUAT & q2,
f32 t )
inline

◆ MTX34ToQUAT() [2/2]

QUAT * nw::math::MTX34ToQUAT ( QUAT * pOut,
const MTX34 & mtx )
inline

◆ QUATSquad() [2/2]

QUAT * nw::math::QUATSquad ( QUAT * pOut,
const QUAT & p,
const QUAT & a,
const QUAT & b,
const QUAT & q,
f32 t )
inline

◆ QUATMakeClosest() [2/2]

QUAT * nw::math::QUATMakeClosest ( QUAT * pOut,
const QUAT & q,
const QUAT & qto )
inline

◆ QUATRotAxisRad() [2/2]

QUAT * nw::math::QUATRotAxisRad ( QUAT * pOut,
const VEC3 & axis,
f32 rad )
inline

◆ QUATMakeVectorRotation() [2/2]

QUAT * nw::math::QUATMakeVectorRotation ( QUAT * pOut,
const VEC3 & from,
const VEC3 & to )
inline

◆ Transform2Identity()

Transform2 * nw::math::Transform2Identity ( Transform2 * pOut)
inline

◆ Transform3Identity()

Transform3 * nw::math::Transform3Identity ( Transform3 * pOut)
inline

◆ VEC3TransformArray() [1/4]

NW_MATH_INLINE VEC3 * nw::math::VEC3TransformArray ( VEC3 * pOut,
const MTX34 * pM,
const VEC3 * pV,
s32 count )

◆ VEC3TransformArray() [2/4]

NW_MATH_INLINE VEC4 * nw::math::VEC3TransformArray ( VEC4 * pOut,
const MTX44 * pM,
const VEC3 * pV,
u32 count )

◆ VEC3TransformNormal() [1/2]

NW_MATH_INLINE VEC3 * nw::math::VEC3TransformNormal ( VEC3 * pOut,
const MTX34 * pM,
const VEC3 * pV )

◆ VEC3TransformNormalArray() [1/2]

NW_MATH_INLINE VEC3 * nw::math::VEC3TransformNormalArray ( VEC3 * pOutArray,
const MTX34 * pM,
const VEC3 * pArray,
u32 n )

◆ VEC3TransformCoord() [1/2]

NW_MATH_INLINE VEC3 * nw::math::VEC3TransformCoord ( VEC3 * pOut,
const MTX44 * pM,
const VEC3 * pV )

◆ VEC3TransformCoordArray() [1/2]

NW_MATH_INLINE VEC3 * nw::math::VEC3TransformCoordArray ( VEC3 * pOut,
const MTX44 * pM,
const VEC3 * pV,
u32 count )

◆ VEC4Transform() [1/3]

NW_MATH_INLINE VEC4 * nw::math::VEC4Transform ( VEC4 * pOut,
const MTX44 * pM,
const VEC4 * pV )

◆ VEC4TransformArray() [1/3]

NW_MATH_INLINE VEC4 * nw::math::VEC4TransformArray ( VEC4 * pOut,
const MTX44 * pM,
const VEC4 * pV,
u32 n )

◆ VEC4Transform() [2/3]

NW_MATH_INLINE VEC4 * nw::math::VEC4Transform ( VEC4 * pOut,
const MTX34 * pM,
const VEC4 * pV )

◆ VEC4TransformArray() [2/3]

NW_MATH_INLINE VEC4 * nw::math::VEC4TransformArray ( VEC4 * pOut,
const MTX34 * pM,
const VEC4 * pV,
u32 n )

◆ VEC3Transform() [1/2]

VEC3 * nw::math::VEC3Transform ( VEC3 * pOut,
const MTX34 & m,
const VEC3 & v )
inline

◆ VEC3Transform() [2/2]

VEC4 * nw::math::VEC3Transform ( VEC4 * pOut,
const MTX44 & m,
const VEC3 & v )
inline

◆ VEC3TransformArray() [3/4]

VEC3 * nw::math::VEC3TransformArray ( VEC3 * pOutArray,
const MTX34 & m,
const VEC3 * pArray,
s32 count )
inline

◆ VEC3TransformArray() [4/4]

VEC4 * nw::math::VEC3TransformArray ( VEC4 * pOutArray,
const MTX44 & m,
const VEC3 * pArray,
u32 count )
inline

◆ VEC3TransformNormal() [2/2]

VEC3 * nw::math::VEC3TransformNormal ( VEC3 * pOut,
const MTX34 & m,
const VEC3 & v )
inline

◆ VEC3TransformNormalArray() [2/2]

VEC3 * nw::math::VEC3TransformNormalArray ( VEC3 * pOutArray,
const MTX34 & m,
const VEC3 * pArray,
u32 n )
inline

◆ VEC3TransformCoord() [2/2]

VEC3 * nw::math::VEC3TransformCoord ( VEC3 * pOut,
const MTX44 & m,
const VEC3 & v )
inline

◆ VEC3TransformCoordArray() [2/2]

VEC3 * nw::math::VEC3TransformCoordArray ( VEC3 * pOutArray,
const MTX44 & m,
const VEC3 * pArray,
u32 count )
inline

◆ VEC4Transform() [3/3]

VEC4 * nw::math::VEC4Transform ( VEC4 * pOut,
const MTX44 & m,
const VEC4 & v )
inline

◆ VEC4TransformArray() [3/3]

VEC4 * nw::math::VEC4TransformArray ( VEC4 * pOutArray,
const MTX44 & m,
const VEC4 * pArray,
u32 n )
inline

◆ VEC2IsZero() [1/2]

NW_MATH_INLINE bool nw::math::VEC2IsZero ( const VEC2 * p)

◆ VEC2Lerp() [1/2]

VEC2 * nw::math::VEC2Lerp ( VEC2 * pOut,
const VEC2 * p1,
const VEC2 * p2,
f32 t )
inline

◆ VEC2Dot() [1/2]

f32 nw::math::VEC2Dot ( const VEC2 * p1,
const VEC2 * p2 )
inline

◆ VEC2Maximize() [1/2]

NW_MATH_INLINE VEC2 * nw::math::VEC2Maximize ( VEC2 * pOut,
const VEC2 * p1,
const VEC2 * p2 )

◆ VEC2Minimize() [1/2]

NW_MATH_INLINE VEC2 * nw::math::VEC2Minimize ( VEC2 * pOut,
const VEC2 * p1,
const VEC2 * p2 )

◆ VEC2Normalize() [1/2]

VEC2 * nw::math::VEC2Normalize ( VEC2 * pOut,
const VEC2 * p )
extern

◆ VEC2FastNormalize() [1/2]

VEC2 * nw::math::VEC2FastNormalize ( VEC2 * pOut,
const VEC2 * p )
extern

◆ VEC2SafeNormalize() [1/2]

VEC2 * nw::math::VEC2SafeNormalize ( VEC2 * pOut,
const VEC2 * p,
const VEC2 & alt )
extern

◆ VEC2FastSafeNormalize() [1/2]

VEC2 * nw::math::VEC2FastSafeNormalize ( VEC2 * pOut,
const VEC2 * p,
const VEC2 & alt )
extern

◆ VEC2DistSq() [1/2]

f32 nw::math::VEC2DistSq ( const VEC2 * p1,
const VEC2 * p2 )
inline

◆ VEC2Add() [1/2]

VEC2 * nw::math::VEC2Add ( VEC2 * pOut,
const VEC2 * p1,
const VEC2 * p2 )
inline

◆ VEC2Sub() [1/2]

VEC2 * nw::math::VEC2Sub ( VEC2 * pOut,
const VEC2 * p1,
const VEC2 * p2 )
inline

◆ VEC2Scale() [1/2]

VEC2 * nw::math::VEC2Scale ( VEC2 * pOut,
const VEC2 * p,
f32 scale )
inline

◆ VEC2LenSq() [1/2]

f32 nw::math::VEC2LenSq ( const VEC2 * p)
inline

◆ VEC2Len() [1/2]

f32 nw::math::VEC2Len ( const VEC2 * p)
inline

◆ operator*() [3/5]

VEC2 nw::math::operator* ( f32 f,
const VEC2 & rhs )
inline

◆ VEC2IsZero() [2/2]

bool nw::math::VEC2IsZero ( const VEC2 & v)
inline

◆ VEC2Add() [2/2]

VEC2 * nw::math::VEC2Add ( VEC2 * pOut,
const VEC2 & p1,
const VEC2 & p2 )
inline

◆ VEC2Sub() [2/2]

VEC2 * nw::math::VEC2Sub ( VEC2 * pOut,
const VEC2 & v1,
const VEC2 & v2 )
inline

◆ VEC2Scale() [2/2]

VEC2 * nw::math::VEC2Scale ( VEC2 * pOut,
const VEC2 & v,
f32 scale )
inline

◆ VEC2Lerp() [2/2]

VEC2 * nw::math::VEC2Lerp ( VEC2 * pOut,
const VEC2 & v1,
const VEC2 & v2,
f32 t )
inline

◆ VEC2Dot() [2/2]

f32 nw::math::VEC2Dot ( const VEC2 & v1,
const VEC2 & v2 )
inline

◆ VEC2LenSq() [2/2]

f32 nw::math::VEC2LenSq ( const VEC2 & v)
inline

◆ VEC2Len() [2/2]

f32 nw::math::VEC2Len ( const VEC2 & v)
inline

◆ VEC2DistSq() [2/2]

f32 nw::math::VEC2DistSq ( const VEC2 & v1,
const VEC2 & v2 )
inline

◆ VEC2Maximize() [2/2]

VEC2 * nw::math::VEC2Maximize ( VEC2 * pOut,
const VEC2 & v1,
const VEC2 & v2 )
inline

◆ VEC2Minimize() [2/2]

VEC2 * nw::math::VEC2Minimize ( VEC2 * pOut,
const VEC2 & v1,
const VEC2 & v2 )
inline

◆ VEC2Normalize() [2/2]

VEC2 * nw::math::VEC2Normalize ( VEC2 * pOut,
const VEC2 & v )
inline

◆ VEC2FastNormalize() [2/2]

VEC2 * nw::math::VEC2FastNormalize ( VEC2 * pOut,
const VEC2 & v )
inline

◆ VEC2SafeNormalize() [2/2]

VEC2 * nw::math::VEC2SafeNormalize ( VEC2 * pOut,
const VEC2 & v,
const VEC2 & alt )
inline

◆ VEC2FastSafeNormalize() [2/2]

VEC2 * nw::math::VEC2FastSafeNormalize ( VEC2 * pOut,
const VEC2 & v,
const VEC2 & alt )
inline

◆ VEC3IsZero() [1/2]

NW_MATH_INLINE bool nw::math::VEC3IsZero ( const VEC3 * p)

◆ VEC3Maximize() [1/2]

NW_MATH_INLINE VEC3 * nw::math::VEC3Maximize ( VEC3 * pOut,
const VEC3 * p1,
const VEC3 * p2 )

◆ VEC3Minimize() [1/2]

NW_MATH_INLINE VEC3 * nw::math::VEC3Minimize ( VEC3 * pOut,
const VEC3 * p1,
const VEC3 * p2 )

◆ VEC3Cross() [1/2]

NW_MATH_INLINE VEC3 * nw::math::VEC3Cross ( VEC3 * pOut,
const VEC3 * p1,
const VEC3 * p2 )

◆ VEC3Normalize() [1/2]

NW_MATH_INLINE VEC3 * nw::math::VEC3Normalize ( VEC3 * pOut,
const VEC3 * p )

◆ VEC3FastNormalize() [1/2]

VEC3 * nw::math::VEC3FastNormalize ( VEC3 * pOut,
const VEC3 * p )
extern

◆ VEC3SafeNormalize() [1/2]

NW_MATH_INLINE VEC3 * nw::math::VEC3SafeNormalize ( VEC3 * pOut,
const VEC3 * p,
const VEC3 & alt )

◆ VEC3FastSafeNormalize() [1/2]

VEC3 * nw::math::VEC3FastSafeNormalize ( VEC3 * pOut,
const VEC3 * p,
const VEC3 & alt )
extern

◆ VEC3SquareDist() [1/2]

NW_MATH_INLINE f32 nw::math::VEC3SquareDist ( const VEC3 * p1,
const VEC3 * p2 )

◆ VEC3Add() [1/2]

VEC3 * nw::math::VEC3Add ( VEC3 * pOut,
const VEC3 * p1,
const VEC3 * p2 )
inline

◆ VEC3Sub() [1/2]

VEC3 * nw::math::VEC3Sub ( VEC3 * pOut,
const VEC3 * p1,
const VEC3 * p2 )
inline

◆ VEC3Mult()

VEC3 * nw::math::VEC3Mult ( VEC3 * pOut,
const VEC3 * p1,
const VEC3 * p2 )
inline

◆ VEC3Scale() [1/2]

VEC3 * nw::math::VEC3Scale ( VEC3 * pOut,
const VEC3 * p,
f32 scale )
inline

◆ VEC3Lerp() [1/2]

VEC3 * nw::math::VEC3Lerp ( VEC3 * pOut,
const VEC3 * p1,
const VEC3 * p2,
f32 t )
inline

◆ VEC3Dot() [1/2]

f32 nw::math::VEC3Dot ( const VEC3 * p1,
const VEC3 * p2 )
inline

◆ VEC3Len() [1/2]

f32 nw::math::VEC3Len ( const VEC3 * p)
inline

◆ VEC3SquareLen() [1/2]

f32 nw::math::VEC3SquareLen ( const VEC3 * p)
inline

◆ VEC3Dist() [1/2]

f32 nw::math::VEC3Dist ( const VEC3 * p1,
const VEC3 * p2 )
inline

◆ operator*() [4/5]

VEC3 nw::math::operator* ( f32 f,
const VEC3 & rhs )
inline

◆ VEC3IsZero() [2/2]

bool nw::math::VEC3IsZero ( const VEC3 & v)
inline

◆ VEC3Maximize() [2/2]

VEC3 * nw::math::VEC3Maximize ( VEC3 * pOut,
const VEC3 & v1,
const VEC3 & v2 )
inline

◆ VEC3Minimize() [2/2]

VEC3 * nw::math::VEC3Minimize ( VEC3 * pOut,
const VEC3 & v1,
const VEC3 & v2 )
inline

◆ VEC3Cross() [2/2]

VEC3 * nw::math::VEC3Cross ( VEC3 * pOut,
const VEC3 & v1,
const VEC3 & v2 )
inline

◆ VEC3Normalize() [2/2]

VEC3 * nw::math::VEC3Normalize ( VEC3 * pOut,
const VEC3 & v )
inline

◆ VEC3FastNormalize() [2/2]

VEC3 * nw::math::VEC3FastNormalize ( VEC3 * pOut,
const VEC3 & v )
inline

◆ VEC3SafeNormalize() [2/2]

VEC3 * nw::math::VEC3SafeNormalize ( VEC3 * pOut,
const VEC3 & v,
const VEC3 & alt )
inline

◆ VEC3FastSafeNormalize() [2/2]

VEC3 * nw::math::VEC3FastSafeNormalize ( VEC3 * pOut,
const VEC3 & v,
const VEC3 & alt )
inline

◆ VEC3SquareDist() [2/2]

f32 nw::math::VEC3SquareDist ( const VEC3 & v1,
const VEC3 & v2 )
inline

◆ VEC3Add() [2/2]

VEC3 * nw::math::VEC3Add ( VEC3 * pOut,
const VEC3 & v1,
const VEC3 & v2 )
inline

◆ VEC3Sub() [2/2]

VEC3 * nw::math::VEC3Sub ( VEC3 * pOut,
const VEC3 & v1,
const VEC3 & v2 )
inline

◆ VEC3Scale() [2/2]

VEC3 * nw::math::VEC3Scale ( VEC3 * pOut,
const VEC3 & v,
f32 scale )
inline

◆ VEC3Lerp() [2/2]

VEC3 * nw::math::VEC3Lerp ( VEC3 * pOut,
const VEC3 & v1,
const VEC3 & v2,
f32 t )
inline

◆ VEC3Dot() [2/2]

f32 nw::math::VEC3Dot ( const VEC3 & v1,
const VEC3 & v2 )
inline

◆ VEC3Len() [2/2]

f32 nw::math::VEC3Len ( const VEC3 & v)
inline

◆ VEC3SquareLen() [2/2]

f32 nw::math::VEC3SquareLen ( const VEC3 & v)
inline

◆ VEC3Dist() [2/2]

f32 nw::math::VEC3Dist ( const VEC3 & v1,
const VEC3 & v2 )
inline

◆ VEC4IsZero() [1/2]

NW_MATH_INLINE bool nw::math::VEC4IsZero ( const VEC4 * p)

◆ VEC4IsZeroWOne() [1/2]

NW_MATH_INLINE bool nw::math::VEC4IsZeroWOne ( const VEC4 * p)

◆ VEC4Add() [1/2]

NW_MATH_INLINE VEC4 * nw::math::VEC4Add ( VEC4 * pOut,
const VEC4 * p1,
const VEC4 * p2 )

◆ VEC4Sub() [1/2]

NW_MATH_INLINE VEC4 * nw::math::VEC4Sub ( VEC4 * pOut,
const VEC4 * p1,
const VEC4 * p2 )

◆ VEC4Scale() [1/2]

NW_MATH_INLINE VEC4 * nw::math::VEC4Scale ( VEC4 * pOut,
const VEC4 * p,
f32 scale )

◆ VEC4Lerp() [1/2]

NW_MATH_INLINE VEC4 * nw::math::VEC4Lerp ( VEC4 * pOut,
const VEC4 * p1,
const VEC4 * p2,
f32 t )

◆ VEC4Dot() [1/2]

NW_MATH_INLINE f32 nw::math::VEC4Dot ( const VEC4 * p1,
const VEC4 * p2 )

◆ VEC4LenSq() [1/2]

NW_MATH_INLINE f32 nw::math::VEC4LenSq ( const VEC4 * p)

◆ VEC4Len() [1/2]

NW_MATH_INLINE f32 nw::math::VEC4Len ( const VEC4 * p)

◆ VEC4Normalize() [1/2]

VEC4 * nw::math::VEC4Normalize ( VEC4 * pOut,
const VEC4 * p )
extern

◆ VEC4FastNormalize() [1/2]

VEC4 * nw::math::VEC4FastNormalize ( VEC4 * pOut,
const VEC4 * p )
extern

◆ VEC4SafeNormalize() [1/2]

VEC4 * nw::math::VEC4SafeNormalize ( VEC4 * pOut,
const VEC4 * p,
const VEC4 & alt )
extern

◆ VEC4FastSafeNormalize() [1/2]

VEC4 * nw::math::VEC4FastSafeNormalize ( VEC4 * pOut,
const VEC4 * p,
const VEC4 & alt )
extern

◆ VEC4DistSq() [1/2]

NW_MATH_INLINE f32 nw::math::VEC4DistSq ( const VEC4 * p1,
const VEC4 * p2 )

◆ VEC4Maximize() [1/2]

NW_MATH_INLINE VEC4 * nw::math::VEC4Maximize ( VEC4 * pOut,
const VEC4 * p1,
const VEC4 * p2 )

◆ VEC4Minimize() [1/2]

NW_MATH_INLINE VEC4 * nw::math::VEC4Minimize ( VEC4 * pOut,
const VEC4 * p1,
const VEC4 * p2 )

◆ operator*() [5/5]

VEC4 nw::math::operator* ( f32 f,
const VEC4 & rhs )
inline

◆ VEC4IsZero() [2/2]

bool nw::math::VEC4IsZero ( const VEC4 & v)
inline

◆ VEC4IsZeroWOne() [2/2]

bool nw::math::VEC4IsZeroWOne ( const VEC4 & v)
inline

◆ VEC4Add() [2/2]

VEC4 * nw::math::VEC4Add ( VEC4 * pOut,
const VEC4 & v1,
const VEC4 & v2 )
inline

◆ VEC4Sub() [2/2]

VEC4 * nw::math::VEC4Sub ( VEC4 * pOut,
const VEC4 & v1,
const VEC4 & v2 )
inline

◆ VEC4Scale() [2/2]

VEC4 * nw::math::VEC4Scale ( VEC4 * pOut,
const VEC4 & v,
f32 scale )
inline

◆ VEC4Lerp() [2/2]

VEC4 * nw::math::VEC4Lerp ( VEC4 * pOut,
const VEC4 & v1,
const VEC4 & v2,
f32 t )
inline

◆ VEC4Dot() [2/2]

f32 nw::math::VEC4Dot ( const VEC4 & v1,
const VEC4 & v2 )
inline

◆ VEC4LenSq() [2/2]

f32 nw::math::VEC4LenSq ( const VEC4 & v)
inline

◆ VEC4Len() [2/2]

f32 nw::math::VEC4Len ( const VEC4 & v)
inline

◆ VEC4Normalize() [2/2]

VEC4 * nw::math::VEC4Normalize ( VEC4 * pOut,
const VEC4 & v )
inline

◆ VEC4FastNormalize() [2/2]

VEC4 * nw::math::VEC4FastNormalize ( VEC4 * pOut,
const VEC4 & v )
inline

◆ VEC4SafeNormalize() [2/2]

VEC4 * nw::math::VEC4SafeNormalize ( VEC4 * pOut,
const VEC4 & v,
const VEC4 & alt )
inline

◆ VEC4FastSafeNormalize() [2/2]

VEC4 * nw::math::VEC4FastSafeNormalize ( VEC4 * pOut,
const VEC4 & v,
const VEC4 & alt )
inline

◆ VEC4DistSq() [2/2]

f32 nw::math::VEC4DistSq ( const VEC4 & v1,
const VEC4 & v2 )
inline

◆ VEC4Maximize() [2/2]

VEC4 * nw::math::VEC4Maximize ( VEC4 * pOut,
const VEC4 & v1,
const VEC4 & v2 )
inline

◆ VEC4Minimize() [2/2]

VEC4 * nw::math::VEC4Minimize ( VEC4 * pOut,
const VEC4 & v1,
const VEC4 & v2 )
inline

Variable Documentation

◆ F_PI

const f32 nw::math::F_PI = 3.141592653589793f

◆ I_HALF_ROUND_IDX

const u32 nw::math::I_HALF_ROUND_IDX = 0x80000000

◆ F_ULP

const f32 nw::math::F_ULP = std::numeric_limits<f32>::epsilon() * 2.0f