aos

namespace aos

Classes

• PxMatTransformV

• PxTransformV

Functions

• BAllEq(const BoolV a, const BoolV b)

• BAllEqFFFF(const BoolV a)

• BAllEqTTTT(const BoolV a)

• BAllTrue3(const BoolV a)

• BAllTrue4(const BoolV a)

• BAnd(const BoolV a, const BoolV b)

• BAndNot(const BoolV a, const BoolV b)

• BAnyTrue3(const BoolV a)

• BAnyTrue4(const BoolV a)

• BFFFF()

• BFFFT()

• BFFTF()

• BFFTT()

• BFTFF()

• BFTFT()

• BFTTF()

• BFTTT()

• BGetBitMask(const BoolV a): Get BoolV as bits set in an PxU32. A bit in the output is set if the element is 'true' in the input. There is a bit for each element in a, with element 0s value held in bit0, element 1 in bit 1s and so forth. If nothing is true in the input it will return 0, and if all are true if will return 0xf. NOTE! That performance of the function varies considerably by platform, thus it is recommended to use where your algorithm really needs a BoolV in an integer variable.

• BGetW(const BoolV f)

• BGetX(const BoolV f)

• BGetY(const BoolV f)

• BGetZ(const BoolV f)

• BLoad(const bool f)

• BLoad(const bool *const f)

• BNot(const BoolV a)

• BOr(const BoolV a, const BoolV b)

• BSetW(const BoolV v, const BoolV f)

• BSetX(const BoolV v, const BoolV f)

• BSetY(const BoolV v, const BoolV f)

• BSetZ(const BoolV v, const BoolV f)

• BSplatElement(Vec4V a)

• BSplatElement(BoolV a)

• BStoreA(const BoolV b, PxU32 *f)

• BTFFF()

• BTFFT()

• BTFTF()

• BTFTT()

• BTTFF()

• BTTFT()

• BTTTF()

• BTTTT()

• BWMask()

• BXMask()

• BYMask()

• BZMask()

• FAbs(const FloatV a)

• FAdd(const FloatV a, const FloatV b)

• FAllEq(const FloatV a, const FloatV b)

• FAllGrtr(const FloatV a, const FloatV b)

• FAllGrtrOrEq(const FloatV a, const FloatV b)

• FClamp(const FloatV a, const FloatV minV, const FloatV maxV)

• FCos(const FloatV a)

• FDiv(const FloatV a, const FloatV b)

• FDivFast(const FloatV a, const FloatV b)

• FEps()

• FEps6()

• FHalf()

• FInBounds(const FloatV a, const FloatV min, const FloatV max)

• FInBounds(const FloatV a, const FloatV bounds)

• FIsEq(const FloatV a, const FloatV b)

• FIsGrtr(const FloatV a, const FloatV b)

• FIsGrtrOrEq(const FloatV a, const FloatV b)

• FLoad(const PxF32 f)

• FMax(const FloatV a, const FloatV b)

• FMin(const FloatV a, const FloatV b)

• FMul(const FloatV a, const FloatV b)

• FNeg(const FloatV f)

• FNegMax()

• FNegScaleSub(const FloatV a, const FloatV b, const FloatV c)

• FOne()

• FOutOfBounds(const FloatV a, const FloatV bounds)

• FOutOfBounds(const FloatV a, const FloatV min, const FloatV max)

• FRecip(const FloatV a)

• FRecipFast(const FloatV a)

• FRound(const FloatV a)

• FRsqrt(const FloatV a)

• FRsqrtFast(const FloatV a)

• FScaleAdd(const FloatV a, const FloatV b, const FloatV c)

• FSel(const BoolV c, const FloatV a, const FloatV b)

• FSin(const FloatV a)

• FSqrt(const FloatV a)

• FStore(const FloatV a, PxF32 *f)

• FSub(const FloatV a, const FloatV b)

• FZero()

• I4Load(const PxI32 i)

• I4LoadA(const PxI32 *i)

• I4LoadU(const PxI32 *i)

• I4LoadXYZW(const PxI32 &x, const PxI32 &y, const PxI32 &z, const PxI32 &w)

• I4StoreA(const VecI32V iv, PxI32 *i)

• M33Abs(const Mat33V &a)

• M33Add(const Mat33V &a, const Mat33V &b)

• M33Diagonal(const Vec3V &)

• M33Diagonal(const Vec3VArg d)

• M33Identity()

• M33Inverse(const Mat33V &a)

• M33Load(const PxMat33 &m)

• M33MulM33(const Mat33V &a, const Mat33V &b)

• M33MulV3(const Mat33V &a, const Vec3V b)

• M33MulV3AddV3(const Mat33V &A, const Vec3V b, const Vec3V c)

• M33Neg(const Mat33V &a)

• M33Scale(const Mat33V &a, const FloatV &b)

• M33Sub(const Mat33V &a, const Mat33V &b)

• M33Trnsps(const Mat33V &a)

• M33TrnspsMulV3(const Mat33V &a, const Vec3V b)

• M34Add(const Mat34V &a, const Mat34V &b)

• M34Mul33MM34(const Mat34V &a, const Mat34V &b)

• M34Mul33V3(const Mat34V &a, const Mat33V &b)

• M34Mul33V3(const Mat34V &a, const Vec3V b)

• M34MulM33(const Mat34V &a, const Mat33V &b)

• M34MulM34(const Mat34V &a, const Mat34V &b)

• M34MulV3(const Mat34V &a, const Vec3V b)

• M34Trnsps33(const Mat34V &a)

• M34TrnspsMul33V3(const Mat34V &a, const Vec3V b)

• M44Add(const Mat44V &a, const Mat44V &b)

• M44Inverse(const Mat44V &a)

• M44MulM44(const Mat44V &a, const Mat44V &b)

• M44MulV4(const Mat44V &a, const Vec4V b)

• M44Trnsps(const Mat44V &a)

• M44TrnspsMulV4(const Mat44V &a, const Vec4V b)

• Mat33GetQuatV(const Mat33V &a)

• Mat33V_From_PxMat33(const PxMat33 &m)

• PxI32_From_VecI32V(const VecI32VArg a, PxI32 *i)

• PxMat33_From_Mat33V(const Mat33V &m, PxMat33 &out)

• QuatAdd(const QuatV a, const QuatV b)

• QuatConjugate(const QuatV q)

• QuatDot(const QuatV a, const QuatV b)

• QuatGetBasisVector0(const QuatV q): brief computes rotation of x-axis

• QuatGetBasisVector1(const QuatV q): brief computes rotation of y-axis

• QuatGetBasisVector2(const QuatV q): brief computes rotation of z-axis

• QuatGetImaginaryPart(const QuatV q)

• QuatGetMat33V(const QuatV &q)

• QuatGetMat33V(const QuatV &q, Vec3V &column0, Vec3V &column1, Vec3V &column2)

• QuatGetMat33V(const QuatVArg q, Vec3V &column0, Vec3V &column1, Vec3V &column2)

• QuatGetMat33V(const QuatVArg q)

• QuatIdentity()

• QuatLength(const QuatV q)

• QuatLengthSq(const QuatV q)

• QuatMerge(const FloatV &x, const FloatV &y, const FloatV &z, const FloatV &w)

• QuatMerge(const FloatV *const v)

• QuatMerge(const FloatVArg x, const FloatVArg y, const FloatVArg z, const FloatVArg w)

• QuatMul(const QuatV a, const QuatV b)

• QuatNeg(const QuatV q)

• QuatNormalize(const QuatV q)

• QuatRotate(const QuatV q, const Vec3V v)

• QuatRotateInv(const QuatV q, const Vec3V v)

• QuatScale(const QuatV a, const FloatV b)

• QuatSub(const QuatV a, const QuatV b)

• QuatTransform(const QuatV q, const Vec3V p, const Vec3V v)

• QuatVLoadA(const PxF32 *v)

• QuatVLoadU(const PxF32 *v)

• QuatVLoadXYZW(const PxF32 x, const PxF32 y, const PxF32 z, const PxF32 w)

• QuatV_From_RotationAxisAngle(const Vec3V u, const FloatV a)

• Store_From_BoolV(const BoolV b, PxU32 *b2)

• U4Load(const PxU32 f)

• U4LoadA(const PxU32 *f)

• U4LoadU(const PxU32 *f)

• U4LoadXYZW(PxU32 x, PxU32 y, PxU32 z, PxU32 w)

• U4One()

• U4StoreA(const VecU32V uv, PxU32 *u)

• U4Two()

• U4Zero()

• V3Abs(const Vec3V a)

• V3Add(const Vec3V a, const Vec3V b)

• V3AllEq(const Vec3V a, const Vec3V b)

• V3AllGrtr(const Vec3V a, const Vec3V b)

• V3AllGrtrOrEq(const Vec3V a, const Vec3V b)

• V3Clamp(const Vec3V a, const Vec3V minV, const Vec3V maxV)

• V3ColX(const Vec3V a, const Vec3V b, const Vec3V c)

• V3ColY(const Vec3V a, const Vec3V b, const Vec3V c)

• V3ColZ(const Vec3V a, const Vec3V b, const Vec3V c)

• V3Cos(const Vec3V a)

• V3Cross(const Vec3V a, const Vec3V b)

• V3Div(const Vec3V a, const Vec3V b)

• V3DivFast(const Vec3V a, const Vec3V b)

• V3Dot(const Vec3V a, const Vec3V b)

• V3Dot4(const Vec3V &a0, const Vec3V &b0, const Vec3V &a1, const Vec3V &b1, const Vec3V &a2, const Vec3V &b2, const Vec3V &a3, const Vec3V &b3)

• V3Eps()

• V3ExtractMax(const Vec3V a)

• V3ExtractMin(const Vec3V a)

• V3GetX(const Vec3V f)

• V3GetY(const Vec3V f)

• V3GetZ(const Vec3V f)

• V3InBounds(const Vec3V a, const Vec3V bounds)

• V3InBounds(const Vec3V a, const Vec3V min, const Vec3V max)

• V3IsEq(const Vec3V a, const Vec3V b)

• V3IsGrtr(const Vec3V a, const Vec3V b)

• V3IsGrtrOrEq(const Vec3V a, const Vec3V b)

• V3Length(const Vec3V a)

• V3LengthSq(const Vec3V a)

• V3Load(const PxF32 f)

• V3LoadA(const PxF32 *f)

• V3LoadA(const PxVec3 &f)

• V3LoadU(const PxF32 *f)

• V3LoadU(const PxVec3 &f)

• V3LoadU_SafeReadW(const PxVec3 &f)

• V3LoadUnsafeA(const PxVec3 &f)

• V3Max(const Vec3V a, const Vec3V b)

• V3Merge(const FloatV &x, const FloatV &y, const FloatV &z)

• V3Merge(const FloatVArg x, const FloatVArg y, const FloatVArg z)

• V3Min(const Vec3V a, const Vec3V b)

• V3Mul(const Vec3V a, const Vec3V b)

• V3MulAdd(const Vec3V a, const Vec3V b, const Vec3V c)

• V3Neg(const Vec3V c)

• V3NegMulSub(const Vec3V a, const Vec3V b, const Vec3V c)

• V3NegScaleSub(const Vec3V a, const FloatV b, const Vec3V c)

• V3Normalize(const Vec3V a)

• V3NormalizeFast(const Vec3V a)

• V3NormalizeSafe(const Vec3V a, const Vec3V unsafeReturnValue)

• V3One()

• V3OutOfBounds(const Vec3V a, const Vec3V min, const Vec3V max)

• V3OutOfBounds(const Vec3V a, const Vec3V bounds)

• V3PermXYX(const Vec3V a)

• V3PermYXX(const Vec3V a)

• V3PermYZX(const Vec3V a)

• V3PermYZZ(const Vec3V a)

• V3PermZXY(const Vec3V a)

• V3PermZZY(const Vec3V a)

• V3Perm_0Z_Zero_1X(const Vec3V v0, const Vec3V v1)

• V3Perm_1Y_0X_Zero(const Vec3V v0, const Vec3V v1)

• V3Perm_Zero_1Z_0Y(const Vec3V v0, const Vec3V v1)

• V3PrepareCross(const Vec3VArg normal)

• V3ReadX(const Vec3V &v)

• V3ReadXYZ(const Vec3V &v)

• V3ReadY(const Vec3V &v)

• V3ReadZ(const Vec3V &v)

• V3Recip(const Vec3V a)

• V3RecipFast(const Vec3V a)

• V3Round(const Vec3V a)

• V3Rsqrt(const Vec3V a)

• V3RsqrtFast(const Vec3V a)

• V3Scale(const Vec3V a, const FloatV b)

• V3ScaleAdd(const Vec3V a, const FloatV b, const Vec3V c)

• V3ScaleInv(const Vec3V a, const FloatV b)

• V3ScaleInvFast(const Vec3V a, const FloatV b)

• V3Sel(const BoolV c, const Vec3V a, const Vec3V b)

• V3SetX(const Vec3V v, const FloatV f)

• V3SetY(const Vec3V v, const FloatV f)

• V3SetZ(const Vec3V v, const FloatV f)

• V3Sign(const Vec3V a)

• V3Sin(const Vec3V a)

• V3Splat(const FloatV f)

• V3StoreA(const Vec3V a, PxVec3 &f)

• V3StoreU(const Vec3V a, PxVec3 &f)

• V3Sub(const Vec3V a, const Vec3V b)

• V3SumElems(const Vec3V a)

• V3Transpose(Vec3V &col0, Vec3V &col1, Vec3V &col2)

• V3UnitX()

• V3UnitY()

• V3UnitZ()

• V3WriteX(Vec3V &v, const PxF32 f)

• V3WriteXYZ(Vec3V &v, const PxVec3 &f)

• V3WriteY(Vec3V &v, const PxF32 f)

• V3WriteZ(Vec3V &v, const PxF32 f)

• V3Zero()

• V4Abs(const Vec4V a)

• V4Add(const Vec4V a, const Vec4V b)

• V4AllEq(const Vec4V a, const Vec4V b)

• V4AllGrtr(const Vec4V a, const Vec4V b)

• V4AllGrtrOrEq(const Vec4V a, const Vec4V b)

• V4AllGrtrOrEq3(const Vec4V a, const Vec4V b)

• V4Andc(const Vec4V a, const VecU32V b)

• V4AnyGrtr3(const Vec4V a, const Vec4V b)

• V4Clamp(const Vec4V a, const Vec4V minV, const Vec4V maxV)

• V4ClearW(const Vec4V v)

• V4Cos(const Vec4V a)

• V4Cross(const Vec4V a, const Vec4V b)

• V4Div(const Vec4V a, const Vec4V b)

• V4DivFast(const Vec4V a, const Vec4V b)

• V4Dot(const Vec4V a, const Vec4V b)

• V4Dot3(const Vec4V a, const Vec4V b)

• V4Eps()

• V4ExtractMax(const Vec4V a)

• V4ExtractMin(const Vec4V a)

• V4GetW(const Vec4V f)

• V4GetX(const Vec4V f)

• V4GetY(const Vec4V f)

• V4GetZ(const Vec4V f)

• V4I16CompareGt(VecU16V a, VecU16V b)

• V4I32Sel(const BoolV c, const VecI32V a, const VecI32V b)

• V4IsEq(const Vec4V a, const Vec4V b)

• V4IsEqU32(const VecU32V a, const VecU32V b)

• V4IsGrtr(const Vec4V a, const Vec4V b)

• V4IsGrtrOrEq(const Vec4V a, const Vec4V b)

• V4IsGrtrV32u(const Vec4V a, const Vec4V b)

• V4Length(const Vec4V a)

• V4LengthSq(const Vec4V a)

• V4Load(const PxF32 f)

• V4LoadA(const PxF32 *const f)

• V4LoadU(const PxF32 *const f)

• V4LoadXYZW(const PxF32 &x, const PxF32 &y, const PxF32 &z, const PxF32 &w)

• V4Max(const Vec4V a, const Vec4V b)

• V4Merge(const FloatV &x, const FloatV &y, const FloatV &z, const FloatV &w)

• V4Merge(const FloatV *const f)

• V4Merge(const FloatVArg x, const FloatVArg y, const FloatVArg z, const FloatVArg w)

• V4MergeW(const Vec4V &x, const Vec4V &y, const Vec4V &z, const Vec4V &w)

• V4MergeW(const Vec4VArg x, const Vec4VArg y, const Vec4VArg z, const Vec4VArg w)

• V4MergeX(const Vec4V &x, const Vec4V &y, const Vec4V &z, const Vec4V &w)

• V4MergeX(const Vec4VArg x, const Vec4VArg y, const Vec4VArg z, const Vec4VArg w)

• V4MergeY(const Vec4V &x, const Vec4V &y, const Vec4V &z, const Vec4V &w)

• V4MergeY(const Vec4VArg x, const Vec4VArg y, const Vec4VArg z, const Vec4VArg w)

• V4MergeZ(const Vec4V &x, const Vec4V &y, const Vec4V &z, const Vec4V &w)

• V4MergeZ(const Vec4VArg x, const Vec4VArg y, const Vec4VArg z, const Vec4VArg w)

• V4Min(const Vec4V a, const Vec4V b)

• V4Mul(const Vec4V a, const Vec4V b)

• V4MulAdd(const Vec4V a, const Vec4V b, const Vec4V c)

• V4Neg(const Vec4V c)

• V4NegMulSub(const Vec4V a, const Vec4V b, const Vec4V c)

• V4NegScaleSub(const Vec4V a, const FloatV b, const Vec4V c)

• V4Normalize(const Vec4V a)

• V4NormalizeFast(const Vec4V a)

• V4NormalizeSafe(const Vec4V a, const Vec4V unsafeReturnValue)

• V4One()

• V4Perm(const Vec4V a)

• V4PermXZXZ(const Vec4V v)

• V4PermYWYW(const Vec4V v)

• V4PermYXWZ(const Vec4V v)

• V4PermYZXW(const Vec4V v)

• V4PermZWXY(const Vec4V a)

• V4ReadW(const Vec4V &v)

• V4ReadX(const Vec4V &v)

• V4ReadXYZ(const Vec4V &v)

• V4ReadY(const Vec4V &v)

• V4ReadZ(const Vec4V &v)

• V4Recip(const Vec4V a)

• V4RecipFast(const Vec4V a)

• V4Round(const Vec4V a)

• V4Rsqrt(const Vec4V a)

• V4RsqrtFast(const Vec4V a)

• V4Scale(const Vec4V a, const FloatV b)

• V4ScaleAdd(const Vec4V a, const FloatV b, const Vec4V c)

• V4ScaleInv(const Vec4V a, const FloatV b)

• V4ScaleInvFast(const Vec4V a, const FloatV b)

• V4Sel(const BoolV c, const Vec4V a, const Vec4V b)

• V4SetW(const Vec4V v, const FloatV f)

• V4SetW(const Vec3V v, const FloatV f)

• V4SetX(const Vec4V v, const FloatV f)

• V4SetY(const Vec4V v, const FloatV f)

• V4SetZ(const Vec4V v, const FloatV f)

• V4Sin(const Vec4V a)

• V4Splat(const FloatV f)

• V4SplatElement(Vec4V a)

• V4Sqrt(const Vec4V a)

• V4StoreA(const Vec4V a, PxF32 *f)

• V4StoreU(const Vec4V a, PxF32 *f)

• V4Sub(const Vec4V a, const Vec4V b)

• V4SumElements(const Vec4V a)

• V4Transpose(Vec4V &col0, Vec4V &col1, Vec4V &col2, Vec4V &col3)

• V4U16CompareGt(VecU16V a, VecU16V b)

• V4U16LoadAligned(VecU16V *addr)

• V4U16LoadUnaligned(VecU16V *addr)

• V4U32Andc(VecU32V a, VecU32V b)

• V4U32Sel(const BoolV c, const VecU32V a, const VecU32V b)

• V4U32SplatElement(BoolV a)

• V4U32SplatElement(VecU32V a)

• V4U32StoreAligned(VecU32V val, VecU32V *address)

• V4U32and(VecU32V a, VecU32V b)

• V4U32or(VecU32V a, VecU32V b)

• V4U32xor(VecU32V a, VecU32V b)

• V4UnitW()

• V4UnitX()

• V4UnitY()

• V4UnitZ()

• V4UnpackXY(const Vec4V &a, const Vec4V &b)

• V4UnpackXY(const Vec4VArg a, const Vec4VArg b)

• V4UnpackZW(const Vec4V &a, const Vec4V &b)

• V4UnpackZW(const Vec4VArg a, const Vec4VArg b)

• V4WriteW(Vec4V &v, const PxF32 f)

• V4WriteX(Vec4V &v, const PxF32 f)

• V4WriteXYZ(Vec4V &v, const PxVec3 &f)

• V4WriteY(Vec4V &v, const PxF32 f)

• V4WriteZ(Vec4V &v, const PxF32 f)

• V4Zero()

• Vec3V_From_FloatV(FloatV f)

• Vec3V_From_FloatV_WUndefined(FloatV f)

• Vec3V_From_Vec4V(Vec4V v)

• Vec3V_From_Vec4V_WUndefined(const Vec4V v)

• Vec4V_From_FloatV(FloatV f)

• Vec4V_From_PxVec3_WUndefined(const PxVec3 &v)

• Vec4V_From_Vec3V(Vec3V f)

• Vec4V_From_VecI32V(VecI32V a)

• Vec4V_From_VecU32V(VecU32V a)

• Vec4V_ReinterpretFrom_VecI32V(VecI32V a)

• Vec4V_ReinterpretFrom_VecU32V(VecU32V a)

• VecI32V_Add(const VecI32V &a, const VecI32V &b)

• VecI32V_Add(const VecI32VArg a, const VecI32VArg b)

• VecI32V_And(const VecI32VArg a, const VecI32VArg b)

• VecI32V_From_BoolV(const BoolV &b)

• VecI32V_From_BoolV(const BoolVArg b)

• VecI32V_From_Vec4V(Vec4V a)

• VecI32V_GetW(const VecI32V &a)

• VecI32V_GetW(const VecI32VArg a)

• VecI32V_GetX(const VecI32V &a)

• VecI32V_GetX(const VecI32VArg a)

• VecI32V_GetY(const VecI32V &a)

• VecI32V_GetY(const VecI32VArg a)

• VecI32V_GetZ(const VecI32V &a)

• VecI32V_GetZ(const VecI32VArg a)

• VecI32V_IsEq(const VecI32V &a, const VecI32V &b)

• VecI32V_IsEq(const VecI32VArg a, const VecI32VArg b)

• VecI32V_IsGrtr(const VecI32V &a, const VecI32V &b)

• VecI32V_IsGrtr(const VecI32VArg a, const VecI32VArg b)

• VecI32V_LeftShift(const VecI32V &a, const VecShiftV &shift)

• VecI32V_LeftShift(const VecI32VArg a, const PxU32 count)

• VecI32V_LeftShift(const VecI32VArg a, const VecShiftVArg count)

• VecI32V_Merge(const VecI32VArg a, const VecI32VArg b, const VecI32VArg c, const VecI32VArg d)

• VecI32V_MinusOne()

• VecI32V_One()

• VecI32V_Or(const VecI32V &a, const VecI32V &b)

• VecI32V_Or(const VecI32VArg a, const VecI32VArg b)

• VecI32V_PrepareShift(const VecI32V &shift)

• VecI32V_PrepareShift(const VecI32VArg shift)

• VecI32V_ReinterpretFrom_Vec4V(Vec4V a)

• VecI32V_RightShift(const VecI32V &a, const VecShiftV &shift)

• VecI32V_RightShift(const VecI32VArg a, const PxU32 count)

• VecI32V_RightShift(const VecI32VArg a, const VecShiftVArg count)

• VecI32V_Sel(const BoolV c, const VecI32VArg a, const VecI32VArg b)

• VecI32V_Sub(const VecI32V &a, const VecI32V &b)

• VecI32V_Sub(const VecI32VArg a, const VecI32VArg b)

• VecI32V_Two()

• VecI32V_Zero()

• VecU32V_From_BoolV(const BoolV &b)

• VecU32V_From_BoolV(const BoolVArg b)

• VecU32V_ReinterpretFrom_Vec4V(Vec4V a)

• isFiniteFloatV(const FloatV a)

• isFiniteQuatV(const QuatV q)

• isFiniteVec3V(const Vec3V a)

• isFiniteVec4V(const Vec4V a)

• isSaneQuatV(const QuatV q)

• isValidQuatV(const QuatV q)

• isValidVec3V(const Vec3V a)

• loadTransformA(const PxTransform &transform)

• loadTransformU(const PxTransform &transform)

Namespaces

• @153

• internalScalarSimd

• vecMathTests

Structs

• BoolV

• FloatV

• Mat33V

• Mat34V

• Mat43V

• Mat44V

• Vec3V

• Vec4V

• VecI16V

• VecI32V

• VecU16V

• VecU32V

Typedefs

• QuatV

• VecShiftV