Functions

• ExtGpu::PxCreateAndPopulateParticleAndDiffuseBuffer(const ExtGpu::PxParticleAndDiffuseBufferDesc &desc, PxCudaContextManager *cudaContextManager): Creates and populates a particle buffer that includes support for diffuse particles.

• ExtGpu::PxCreateAndPopulateParticleBuffer(const ExtGpu::PxParticleBufferDesc &desc, PxCudaContextManager *cudaContextManager): Creates and populates a particle buffer.

• ExtGpu::PxCreateAndPopulateParticleClothBuffer(const ExtGpu::PxParticleBufferDesc &desc, const PxParticleClothDesc &clothDesc, PxPartitionedParticleCloth &output, PxCudaContextManager *cudaContextManager): Creates and populates a particle cloth buffer.

• ExtGpu::PxCreateAndPopulateParticleRigidBuffer(const ExtGpu::PxParticleBufferDesc &desc, const ExtGpu::PxParticleRigidDesc &rigidDesc, PxCudaContextManager *cudaContextManager): Creates and populates a particle rigid buffer.

• ExtGpu::PxCreateParticleAttachmentBuffer(PxParticleBuffer &particleBuffer, PxParticleSystem &particleSystem): Creates a particle attachment buffer.

• ExtGpu::PxCreateParticleClothBufferHelper(const PxU32 maxCloths, const PxU32 maxTriangles, const PxU32 maxSprings, const PxU32 maxParticles, PxCudaContextManager *cudaContextManager): Creates a PxParticleClothBufferHelper helper.

• ExtGpu::PxCreateParticleRigidBufferHelper(PxU32 maxRigids, PxU32 maxParticles, PxCudaContextManager *cudaContextManager): Creates a PxParticleRigidBufferHelper .

• ExtGpu::PxCreateParticleVolumeBufferHelper(PxU32 maxVolumes, PxU32 maxTriangles, PxCudaContextManager *cudaContextManager): Creates a PxParticleVolumeBufferHelper .

• PxAtomicAdd(volatile PxI32 *val, PxI32 delta)

• PxAtomicCompareExchange(volatile PxI32 *dest, PxI32 exch, PxI32 comp)

• PxAtomicCompareExchangePointer(volatile void **dest, void *exch, void *comp)

• PxAtomicDecrement(volatile PxI32 *val)

• PxAtomicExchange(volatile PxI32 *dest, PxI32 val)

• PxAtomicIncrement(volatile PxI32 *val)

• PxAtomicMax(volatile PxI32 *val, PxI32 val2)

• PxBitCount(uint32_t v)

• PxComputeHash(const void *ptr)

• PxComputeHash(const uint64_t key)

• PxComputeHash(const uint32_t key)

• PxComputeHash(const int32_t key)

• PxComputeHash(const PxPair< F, S > &p)

• PxContactJointCreate(PxPhysics &physics, PxRigidActor *actor0, const PxTransform &localFrame0, PxRigidActor *actor1, const PxTransform &localFrame1): Create a contact Joint.

• PxCreateCudaContextManager(physx::PxFoundation &foundation, const physx::PxCudaContextManagerDesc &desc, physx::PxProfilerCallback *profilerCallback=NULL, bool launchSynchronous=false): Allocate a CUDA Context manager, complete with heaps.

• PxCreateOmniPvd(physx::PxFoundation &foundation): Creates an instance of the OmniPvd object.

• PxCudaRegisterFatBinary(void *): Internally used callback to register cuda modules at load time.

• PxCudaRegisterFunction(int moduleIndex, const char *functionName): Internally used callback to register function names of cuda kernels.

• PxDebugBreak()

• PxDisableFPExceptions(): Disables floating point exceptions for the scalar and SIMD unit.

• PxEnableFPExceptions(): Enables floating point exceptions for the scalar and SIMD unit.

• PxGetCudaFunctionTable(): Access to the loaded cuda functions (kernels)

• PxGetCudaFunctionTableSize(): Number of loaded cuda functions (kernels)

• PxGetCudaModuleTable(): Access to the registered cuda modules.

• PxGetCudaModuleTableSize(): Number of registered cuda modules.

• PxGetPhysicsGpu()

• PxGetSuggestedCudaDeviceOrdinal(physx::PxErrorCallback &errc): Ask the NVIDIA control panel which GPU has been selected for use by PhysX.

• PxHighestSetBit(uint32_t x)

• PxILog2(uint32_t num)

• PxIsPowerOfTwo(uint32_t x)

• PxLittleEndian()

• PxLowestSetBit(uint32_t x)

• PxNextPowerOfTwo(uint32_t x)

• PxOrder(T &x, T &y, E1 &xe1, E1 &ye1)

• PxOrder(PxReal &x, PxReal &y)

• PxOrder(T &x, T &y)

• PxPointerOffset(const void *p, ptrdiff_t offset)

• PxPointerOffset(void *p, ptrdiff_t offset)

• PxPrintString(const char *): Prints the string literally (does not consume % specifier), trying to make sure it's visible to the app programmer.

• PxSetPhysXGpuLoadHook(const PxGpuLoadHook *hook): Sets GPU load hook instance for PhysX dll.

• PxSetPhysXGpuProfilerCallback(physx::PxProfilerCallback *profilerCallback): Sets profiler callback to PhysX GPU.

• PxSwap(T &x, T &y)

• PxTlsAlloc()

• PxTlsFree(PxU32 index)

• PxTlsGet(PxU32 index)

• PxTlsGetValue(PxU32 index)

• PxTlsSet(PxU32 index, void *value)

• PxTlsSetValue(PxU32 index, size_t value)

• PxTo16(PxU32 value)

• PxTo32(PxU64 value)

• PxTo8(PxU16 value)

• PxTo8(PxI32 value)

• PxTo8(PxU32 value)

• PxToI8(PxU32 value)

• Pxsnprintf(char *dst, size_t dstSize, const char *format,…)

• Pxsscanf(const char *buffer, const char *format,…)

• Pxstrcmp(const char *str1, const char *str2)

• Pxstricmp(const char *str1, const char *str2)

• Pxstrlcat(char *dst, size_t dstSize, const char *src)

• Pxstrlcpy(char *dst, size_t dstSize, const char *src)

• Pxstrlwr(char *str)

• Pxstrncmp(const char *str1, const char *str2, size_t count)

• Pxstrnicmp(const char *str1, const char *str2, size_t count)

• Pxstrupr(char *str)

• Pxvsnprintf(char *dst, size_t dstSize, const char *src, va_list arg)

• aos::BAllEq(const BoolV a, const BoolV b)

• aos::BAllEqFFFF(const BoolV a)

• aos::BAllEqTTTT(const BoolV a)

• aos::BAllTrue3(const BoolV a)

• aos::BAllTrue4(const BoolV a)

• aos::BAnd(const BoolV a, const BoolV b)

• aos::BAndNot(const BoolV a, const BoolV b)

• aos::BAnyTrue3(const BoolV a)

• aos::BAnyTrue4(const BoolV a)

• aos::BFFFF()

• aos::BFFFT()

• aos::BFFTF()

• aos::BFFTT()

• aos::BFTFF()

• aos::BFTFT()

• aos::BFTTF()

• aos::BFTTT()

• aos::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.

• aos::BGetW(const BoolV f)

• aos::BGetX(const BoolV f)

• aos::BGetY(const BoolV f)

• aos::BGetZ(const BoolV f)

• aos::BLoad(const bool f)

• aos::BLoad(const bool *const f)

• aos::BNot(const BoolV a)

• aos::BOr(const BoolV a, const BoolV b)

• aos::BSetW(const BoolV v, const BoolV f)

• aos::BSetX(const BoolV v, const BoolV f)

• aos::BSetY(const BoolV v, const BoolV f)

• aos::BSetZ(const BoolV v, const BoolV f)

• aos::BSplatElement(Vec4V a)

• aos::BSplatElement(BoolV a)

• aos::BStoreA(const BoolV b, PxU32 *f)

• aos::BTFFF()

• aos::BTFFT()

• aos::BTFTF()

• aos::BTFTT()

• aos::BTTFF()

• aos::BTTFT()

• aos::BTTTF()

• aos::BTTTT()

• aos::BWMask()

• aos::BXMask()

• aos::BYMask()

• aos::BZMask()

• aos::FAbs(const FloatV a)

• aos::FAdd(const FloatV a, const FloatV b)

• aos::FAllEq(const FloatV a, const FloatV b)

• aos::FAllGrtr(const FloatV a, const FloatV b)

• aos::FAllGrtrOrEq(const FloatV a, const FloatV b)

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

• aos::FCos(const FloatV a)

• aos::FDiv(const FloatV a, const FloatV b)

• aos::FDivFast(const FloatV a, const FloatV b)

• aos::FEps()

• aos::FEps6()

• aos::FHalf()

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

• aos::FInBounds(const FloatV a, const FloatV bounds)

• aos::FIsEq(const FloatV a, const FloatV b)

• aos::FIsGrtr(const FloatV a, const FloatV b)

• aos::FIsGrtrOrEq(const FloatV a, const FloatV b)

• aos::FLoad(const PxF32 f)

• aos::FMax(const FloatV a, const FloatV b)

• aos::FMin(const FloatV a, const FloatV b)

• aos::FMul(const FloatV a, const FloatV b)

• aos::FNeg(const FloatV f)

• aos::FNegMax()

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

• aos::FOne()

• aos::FOutOfBounds(const FloatV a, const FloatV bounds)

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

• aos::FRecip(const FloatV a)

• aos::FRecipFast(const FloatV a)

• aos::FRound(const FloatV a)

• aos::FRsqrt(const FloatV a)

• aos::FRsqrtFast(const FloatV a)

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

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

• aos::FSin(const FloatV a)

• aos::FSqrt(const FloatV a)

• aos::FStore(const FloatV a, PxF32 *f)

• aos::FSub(const FloatV a, const FloatV b)

• aos::FZero()

• aos::I4Load(const PxI32 i)

• aos::I4LoadA(const PxI32 *i)

• aos::I4LoadU(const PxI32 *i)

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

• aos::I4StoreA(const VecI32V iv, PxI32 *i)

• aos::M33Abs(const Mat33V &a)

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

• aos::M33Diagonal(const Vec3V &)

• aos::M33Diagonal(const Vec3VArg d)

• aos::M33Identity()

• aos::M33Inverse(const Mat33V &a)

• aos::M33Load(const PxMat33 &m)

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

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

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

• aos::M33Neg(const Mat33V &a)

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

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

• aos::M33Trnsps(const Mat33V &a)

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

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

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

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

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

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

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

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

• aos::M34Trnsps33(const Mat34V &a)

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

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

• aos::M44Inverse(const Mat44V &a)

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

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

• aos::M44Trnsps(const Mat44V &a)

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

• aos::Mat33GetQuatV(const Mat33V &a)

• aos::Mat33V_From_PxMat33(const PxMat33 &m)

• aos::PxI32_From_VecI32V(const VecI32VArg a, PxI32 *i)

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

• aos::QuatAdd(const QuatV a, const QuatV b)

• aos::QuatConjugate(const QuatV q)

• aos::QuatDot(const QuatV a, const QuatV b)

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

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

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

• aos::QuatGetImaginaryPart(const QuatV q)

• aos::QuatGetMat33V(const QuatV &q)

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

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

• aos::QuatGetMat33V(const QuatVArg q)

• aos::QuatIdentity()

• aos::QuatLength(const QuatV q)

• aos::QuatLengthSq(const QuatV q)

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

• aos::QuatMerge(const FloatV *const v)

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

• aos::QuatMul(const QuatV a, const QuatV b)

• aos::QuatNeg(const QuatV q)

• aos::QuatNormalize(const QuatV q)

• aos::QuatRotate(const QuatV q, const Vec3V v)

• aos::QuatRotateInv(const QuatV q, const Vec3V v)

• aos::QuatScale(const QuatV a, const FloatV b)

• aos::QuatSub(const QuatV a, const QuatV b)

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

• aos::QuatVLoadA(const PxF32 *v)

• aos::QuatVLoadU(const PxF32 *v)

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

• aos::QuatV_From_RotationAxisAngle(const Vec3V u, const FloatV a)

• aos::Store_From_BoolV(const BoolV b, PxU32 *b2)

• aos::U4Load(const PxU32 f)

• aos::U4LoadA(const PxU32 *f)

• aos::U4LoadU(const PxU32 *f)

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

• aos::U4One()

• aos::U4StoreA(const VecU32V uv, PxU32 *u)

• aos::U4Two()

• aos::U4Zero()

• aos::V3Abs(const Vec3V a)

• aos::V3Add(const Vec3V a, const Vec3V b)

• aos::V3AllEq(const Vec3V a, const Vec3V b)

• aos::V3AllGrtr(const Vec3V a, const Vec3V b)

• aos::V3AllGrtrOrEq(const Vec3V a, const Vec3V b)

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

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

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

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

• aos::V3Cos(const Vec3V a)

• aos::V3Cross(const Vec3V a, const Vec3V b)

• aos::V3Div(const Vec3V a, const Vec3V b)

• aos::V3DivFast(const Vec3V a, const Vec3V b)

• aos::V3Dot(const Vec3V a, const Vec3V b)

• aos::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)

• aos::V3Eps()

• aos::V3ExtractMax(const Vec3V a)

• aos::V3ExtractMin(const Vec3V a)

• aos::V3GetX(const Vec3V f)

• aos::V3GetY(const Vec3V f)

• aos::V3GetZ(const Vec3V f)

• aos::V3InBounds(const Vec3V a, const Vec3V bounds)

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

• aos::V3IsEq(const Vec3V a, const Vec3V b)

• aos::V3IsGrtr(const Vec3V a, const Vec3V b)

• aos::V3IsGrtrOrEq(const Vec3V a, const Vec3V b)

• aos::V3Length(const Vec3V a)

• aos::V3LengthSq(const Vec3V a)

• aos::V3Load(const PxF32 f)

• aos::V3LoadA(const PxF32 *f)

• aos::V3LoadA(const PxVec3 &f)

• aos::V3LoadU(const PxF32 *f)

• aos::V3LoadU(const PxVec3 &f)

• aos::V3LoadU_SafeReadW(const PxVec3 &f)

• aos::V3LoadUnsafeA(const PxVec3 &f)

• aos::V3Max(const Vec3V a, const Vec3V b)

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

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

• aos::V3Min(const Vec3V a, const Vec3V b)

• aos::V3Mul(const Vec3V a, const Vec3V b)

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

• aos::V3Neg(const Vec3V c)

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

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

• aos::V3Normalize(const Vec3V a)

• aos::V3NormalizeFast(const Vec3V a)

• aos::V3NormalizeSafe(const Vec3V a, const Vec3V unsafeReturnValue)

• aos::V3One()

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

• aos::V3OutOfBounds(const Vec3V a, const Vec3V bounds)

• aos::V3PermXYX(const Vec3V a)

• aos::V3PermYXX(const Vec3V a)

• aos::V3PermYZX(const Vec3V a)

• aos::V3PermYZZ(const Vec3V a)

• aos::V3PermZXY(const Vec3V a)

• aos::V3PermZZY(const Vec3V a)

• aos::V3Perm_0Z_Zero_1X(const Vec3V v0, const Vec3V v1)

• aos::V3Perm_1Y_0X_Zero(const Vec3V v0, const Vec3V v1)

• aos::V3Perm_Zero_1Z_0Y(const Vec3V v0, const Vec3V v1)

• aos::V3PrepareCross(const Vec3VArg normal)

• aos::V3ReadX(const Vec3V &v)

• aos::V3ReadXYZ(const Vec3V &v)

• aos::V3ReadY(const Vec3V &v)

• aos::V3ReadZ(const Vec3V &v)

• aos::V3Recip(const Vec3V a)

• aos::V3RecipFast(const Vec3V a)

• aos::V3Round(const Vec3V a)

• aos::V3Rsqrt(const Vec3V a)

• aos::V3RsqrtFast(const Vec3V a)

• aos::V3Scale(const Vec3V a, const FloatV b)

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

• aos::V3ScaleInv(const Vec3V a, const FloatV b)

• aos::V3ScaleInvFast(const Vec3V a, const FloatV b)

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

• aos::V3SetX(const Vec3V v, const FloatV f)

• aos::V3SetY(const Vec3V v, const FloatV f)

• aos::V3SetZ(const Vec3V v, const FloatV f)

• aos::V3Sign(const Vec3V a)

• aos::V3Sin(const Vec3V a)

• aos::V3Splat(const FloatV f)

• aos::V3StoreA(const Vec3V a, PxVec3 &f)

• aos::V3StoreU(const Vec3V a, PxVec3 &f)

• aos::V3Sub(const Vec3V a, const Vec3V b)

• aos::V3SumElems(const Vec3V a)

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

• aos::V3UnitX()

• aos::V3UnitY()

• aos::V3UnitZ()

• aos::V3WriteX(Vec3V &v, const PxF32 f)

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

• aos::V3WriteY(Vec3V &v, const PxF32 f)

• aos::V3WriteZ(Vec3V &v, const PxF32 f)

• aos::V3Zero()

• aos::V4Abs(const Vec4V a)

• aos::V4Add(const Vec4V a, const Vec4V b)

• aos::V4AllEq(const Vec4V a, const Vec4V b)

• aos::V4AllGrtr(const Vec4V a, const Vec4V b)

• aos::V4AllGrtrOrEq(const Vec4V a, const Vec4V b)

• aos::V4AllGrtrOrEq3(const Vec4V a, const Vec4V b)

• aos::V4Andc(const Vec4V a, const VecU32V b)

• aos::V4AnyGrtr3(const Vec4V a, const Vec4V b)

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

• aos::V4ClearW(const Vec4V v)

• aos::V4Cos(const Vec4V a)

• aos::V4Cross(const Vec4V a, const Vec4V b)

• aos::V4Div(const Vec4V a, const Vec4V b)

• aos::V4DivFast(const Vec4V a, const Vec4V b)

• aos::V4Dot(const Vec4V a, const Vec4V b)

• aos::V4Dot3(const Vec4V a, const Vec4V b)

• aos::V4Eps()

• aos::V4ExtractMax(const Vec4V a)

• aos::V4ExtractMin(const Vec4V a)

• aos::V4GetW(const Vec4V f)

• aos::V4GetX(const Vec4V f)

• aos::V4GetY(const Vec4V f)

• aos::V4GetZ(const Vec4V f)

• aos::V4I16CompareGt(VecU16V a, VecU16V b)

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

• aos::V4IsEq(const Vec4V a, const Vec4V b)

• aos::V4IsEqU32(const VecU32V a, const VecU32V b)

• aos::V4IsGrtr(const Vec4V a, const Vec4V b)

• aos::V4IsGrtrOrEq(const Vec4V a, const Vec4V b)

• aos::V4IsGrtrV32u(const Vec4V a, const Vec4V b)

• aos::V4Length(const Vec4V a)

• aos::V4LengthSq(const Vec4V a)

• aos::V4Load(const PxF32 f)

• aos::V4LoadA(const PxF32 *const f)

• aos::V4LoadU(const PxF32 *const f)

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

• aos::V4Max(const Vec4V a, const Vec4V b)

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

• aos::V4Merge(const FloatV *const f)

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

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

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

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

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

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

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

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

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

• aos::V4Min(const Vec4V a, const Vec4V b)

• aos::V4Mul(const Vec4V a, const Vec4V b)

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

• aos::V4Neg(const Vec4V c)

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

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

• aos::V4Normalize(const Vec4V a)

• aos::V4NormalizeFast(const Vec4V a)

• aos::V4NormalizeSafe(const Vec4V a, const Vec4V unsafeReturnValue)

• aos::V4One()

• aos::V4Perm(const Vec4V a)

• aos::V4PermXZXZ(const Vec4V v)

• aos::V4PermYWYW(const Vec4V v)

• aos::V4PermYXWZ(const Vec4V v)

• aos::V4PermYZXW(const Vec4V v)

• aos::V4PermZWXY(const Vec4V a)

• aos::V4ReadW(const Vec4V &v)

• aos::V4ReadX(const Vec4V &v)

• aos::V4ReadXYZ(const Vec4V &v)

• aos::V4ReadY(const Vec4V &v)

• aos::V4ReadZ(const Vec4V &v)

• aos::V4Recip(const Vec4V a)

• aos::V4RecipFast(const Vec4V a)

• aos::V4Round(const Vec4V a)

• aos::V4Rsqrt(const Vec4V a)

• aos::V4RsqrtFast(const Vec4V a)

• aos::V4Scale(const Vec4V a, const FloatV b)

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

• aos::V4ScaleInv(const Vec4V a, const FloatV b)

• aos::V4ScaleInvFast(const Vec4V a, const FloatV b)

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

• aos::V4SetW(const Vec4V v, const FloatV f)

• aos::V4SetW(const Vec3V v, const FloatV f)

• aos::V4SetX(const Vec4V v, const FloatV f)

• aos::V4SetY(const Vec4V v, const FloatV f)

• aos::V4SetZ(const Vec4V v, const FloatV f)

• aos::V4Sin(const Vec4V a)

• aos::V4Splat(const FloatV f)

• aos::V4SplatElement(Vec4V a)

• aos::V4Sqrt(const Vec4V a)

• aos::V4StoreA(const Vec4V a, PxF32 *f)

• aos::V4StoreU(const Vec4V a, PxF32 *f)

• aos::V4Sub(const Vec4V a, const Vec4V b)

• aos::V4SumElements(const Vec4V a)

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

• aos::V4U16CompareGt(VecU16V a, VecU16V b)

• aos::V4U16LoadAligned(VecU16V *addr)

• aos::V4U16LoadUnaligned(VecU16V *addr)

• aos::V4U32Andc(VecU32V a, VecU32V b)

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

• aos::V4U32SplatElement(BoolV a)

• aos::V4U32SplatElement(VecU32V a)

• aos::V4U32StoreAligned(VecU32V val, VecU32V *address)

• aos::V4U32and(VecU32V a, VecU32V b)

• aos::V4U32or(VecU32V a, VecU32V b)

• aos::V4U32xor(VecU32V a, VecU32V b)

• aos::V4UnitW()

• aos::V4UnitX()

• aos::V4UnitY()

• aos::V4UnitZ()

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

• aos::V4UnpackXY(const Vec4VArg a, const Vec4VArg b)

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

• aos::V4UnpackZW(const Vec4VArg a, const Vec4VArg b)

• aos::V4WriteW(Vec4V &v, const PxF32 f)

• aos::V4WriteX(Vec4V &v, const PxF32 f)

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

• aos::V4WriteY(Vec4V &v, const PxF32 f)

• aos::V4WriteZ(Vec4V &v, const PxF32 f)

• aos::V4Zero()

• aos::Vec3V_From_FloatV(FloatV f)

• aos::Vec3V_From_FloatV_WUndefined(FloatV f)

• aos::Vec3V_From_Vec4V(Vec4V v)

• aos::Vec3V_From_Vec4V_WUndefined(const Vec4V v)

• aos::Vec4V_From_FloatV(FloatV f)

• aos::Vec4V_From_PxVec3_WUndefined(const PxVec3 &v)

• aos::Vec4V_From_Vec3V(Vec3V f)

• aos::Vec4V_From_VecI32V(VecI32V a)

• aos::Vec4V_From_VecU32V(VecU32V a)

• aos::Vec4V_ReinterpretFrom_VecI32V(VecI32V a)

• aos::Vec4V_ReinterpretFrom_VecU32V(VecU32V a)

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

• aos::VecI32V_Add(const VecI32VArg a, const VecI32VArg b)

• aos::VecI32V_And(const VecI32VArg a, const VecI32VArg b)

• aos::VecI32V_From_BoolV(const BoolV &b)

• aos::VecI32V_From_BoolV(const BoolVArg b)

• aos::VecI32V_From_Vec4V(Vec4V a)

• aos::VecI32V_GetW(const VecI32V &a)

• aos::VecI32V_GetW(const VecI32VArg a)

• aos::VecI32V_GetX(const VecI32V &a)

• aos::VecI32V_GetX(const VecI32VArg a)

• aos::VecI32V_GetY(const VecI32V &a)

• aos::VecI32V_GetY(const VecI32VArg a)

• aos::VecI32V_GetZ(const VecI32V &a)

• aos::VecI32V_GetZ(const VecI32VArg a)

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

• aos::VecI32V_IsEq(const VecI32VArg a, const VecI32VArg b)

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

• aos::VecI32V_IsGrtr(const VecI32VArg a, const VecI32VArg b)

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

• aos::VecI32V_LeftShift(const VecI32VArg a, const PxU32 count)

• aos::VecI32V_LeftShift(const VecI32VArg a, const VecShiftVArg count)

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

• aos::VecI32V_MinusOne()

• aos::VecI32V_One()

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

• aos::VecI32V_Or(const VecI32VArg a, const VecI32VArg b)

• aos::VecI32V_PrepareShift(const VecI32V &shift)

• aos::VecI32V_PrepareShift(const VecI32VArg shift)

• aos::VecI32V_ReinterpretFrom_Vec4V(Vec4V a)

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

• aos::VecI32V_RightShift(const VecI32VArg a, const PxU32 count)

• aos::VecI32V_RightShift(const VecI32VArg a, const VecShiftVArg count)

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

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

• aos::VecI32V_Sub(const VecI32VArg a, const VecI32VArg b)

• aos::VecI32V_Two()

• aos::VecI32V_Zero()

• aos::VecU32V_From_BoolV(const BoolV &b)

• aos::VecU32V_From_BoolV(const BoolVArg b)

• aos::VecU32V_ReinterpretFrom_Vec4V(Vec4V a)

• aos::internalScalarSimd::FStore(const FloatV a)

• aos::internalScalarSimd::hasZeroElementInFloatV(const FloatV a)

• aos::internalScalarSimd::hasZeroElementInVec3V(const Vec3V a)

• aos::internalScalarSimd::hasZeroElementInVec4V(const Vec4V a)

• aos::isFiniteFloatV(const FloatV a)

• aos::isFiniteQuatV(const QuatV q)

• aos::isFiniteVec3V(const Vec3V a)

• aos::isFiniteVec4V(const Vec4V a)

• aos::isSaneQuatV(const QuatV q)

• aos::isValidQuatV(const QuatV q)

• aos::isValidVec3V(const Vec3V a)

• aos::loadTransformA(const PxTransform &transform)

• aos::loadTransformU(const PxTransform &transform)

• aos::vecMathTests::allElementsEqualBoolV(const BoolV a, const BoolV b)

• aos::vecMathTests::allElementsEqualFloatV(const FloatV a, const FloatV b)

• aos::vecMathTests::allElementsEqualMat33V(const Mat33V &a, const Mat33V &b)

• aos::vecMathTests::allElementsEqualMat34V(const Mat34V &a, const Mat34V &b)

• aos::vecMathTests::allElementsEqualMat44V(const Mat44V &a, const Mat44V &b)

• aos::vecMathTests::allElementsEqualVec3V(const Vec3V a, const Vec3V b)

• aos::vecMathTests::allElementsEqualVec4V(const Vec4V a, const Vec4V b)

• aos::vecMathTests::allElementsEqualVecI32V(const VecI32V a, const VecI32V b)

• aos::vecMathTests::allElementsEqualVecU32V(const VecU32V a, const VecU32V b)

• aos::vecMathTests::allElementsNearEqualFloatV(const FloatV a, const FloatV b)

• aos::vecMathTests::allElementsNearEqualMat33V(const Mat33V &a, const Mat33V &b)

• aos::vecMathTests::allElementsNearEqualMat34V(const Mat34V &a, const Mat34V &b)

• aos::vecMathTests::allElementsNearEqualMat44V(const Mat44V &a, const Mat44V &b)

• aos::vecMathTests::allElementsNearEqualVec3V(const Vec3V a, const Vec3V b)

• aos::vecMathTests::allElementsNearEqualVec4V(const Vec4V a, const Vec4V b)

• aos::vecMathTests::getInvalidVec3V()

• getOmniPvdDataTypeSize()

• getOmniPvdDataTypeSize< OmniPvdDataType::eENUM_VALUE >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eFLAGS_WORD >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eFLOAT32 >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eFLOAT64 >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eINT16 >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eINT32 >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eINT64 >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eINT8 >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eOBJECT_HANDLE >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eSTRING >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eUINT16 >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eUINT32 >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eUINT64 >()

• getOmniPvdDataTypeSize< OmniPvdDataType::eUINT8 >()

• normalToTangents(const PxVec3 &normal, PxVec3 &tangent0, PxVec3 &tangent1)

• operator<<(PxRenderOutput &out, const PxDebugArc &arc)

• operator<<(PxRenderOutput &out, const PxDebugBasis &basis)

• operator<<(PxRenderOutput &out, const PxDebugArrow &arrow)

• operator<<(PxRenderOutput &out, const PxDebugCircle &circle)

• operator<<(PxRenderOutput &out, const PxDebugBox &box)

• transformKernelVec4(const FloatVArg wa, const Vec4VArg va, const Vec4VArg pa, const FloatVArg wb, const Vec4VArg vb, const Vec4VArg pb, FloatV &wo, Vec4V &vo, Vec4V &po)

• transformMultiply(PxTransform32 &out, const PxTransform32 &a, const PxTransform32 &b)

• transformMultiply(PxTransform &out, const PxTransform &a, const PxTransform &b)