Functions

Name	Description
Abs(v128Param)	Returns a vector with the Abs function applied to all 4 elements.
EqualWithinEpsilon(v128Param, v128Param, v128Param)	Returns true if all elements of a and b are within g_VecEpsilon of each other.
GetV128FromString(const C *)	Parses a v128 from the given string.
GetV128FromStringXYZ(const C *, float)	Parses a v128 from the given string, ignoring the W-component and instead setting it to the given value.
IsFinite(v128Param)	Returns true if all of the 4 elements of v are finite.
IsNan(v128Param)	Returns true if any of the 4 elements of v are NANs.
Lerp(v128Param, v128Param, v128Param)	Linearly interpolated between the corresponding components of a and b.
Max(const v128 &, const v128 &)	Returns a vector where each element has the maximum value of the corresponding values in a and b NOTE - the Min3 template function will work with the v128 type as well.
Min(const v128 &, const v128 &)	Returns a vector where each element has the minimum value of the corresponding values in a and b NOTE - the Min3 template function will work with the v128 type as well.
operator-(Geo::v128Param, Geo::v128Param)	Operator - (component-wise subtraction)
operator-(Geo::v128Param)	The unary - operator. Equivalent to (VZero() - v);.
operator*(Geo::v128Param, Geo::v128Param)	Operator * (component-wise multiplication)
operator*=(Geo::v128 &, Geo::v128Param)	Inplace *.
operator/(Geo::v128Param, Geo::v128Param)	Operator / (component-wise division)
operator/=(Geo::v128 &, Geo::v128Param)	Inplace /.
operator+(Geo::v128Param, Geo::v128Param)	Operator + (component-wise addition)
operator+(Geo::v128Param)	The unary + operator (effectively a no-op)
operator+=(Geo::v128 &, Geo::v128Param)	Inplace +.
operator-=(Geo::v128 &, Geo::v128Param)	Inplace -.
V128ToUtf8String(const Geo::v128 &)	Creates a GeoString representation of the vector (space-separated).
V128ToUtf8StringXYZ(const Geo::v128 &)	Creates a GeoString representation of the vector (space-separated).
VBroadcast(float)	Construct a v128 by broadcasting a float into all elements.
VBroadcastInt(s32)	Construct a v128 by converting an integer to a float and broadcasting it into all elements.
VCeil(v128Param)	Return ceil(v).
VCompareEquals(v128Param, v128Param)	Compares all corresponding elements to see if a == b (exact equals).
VCompareGE(v128Param, v128Param)	Compares all corresponding elements to see if a >= b.
VCompareGT(v128Param, v128Param)	Compares all corresponding elements to see if a > b.
VCompareIsFinite(v128Param)	Tests all elements of v to see if they are finite or not.
VCompareIsNan(v128Param)	Tests all elements of v to see if any of them are NANs.
VCompareLE(v128Param, v128Param)	Compares all corresponding elements to see if a <= b.
VCompareLT(v128Param, v128Param)	Compares all corresponding elements to see if a < b.
VCompareWithFlagsEquals(v128Param, v128Param, u32 &)	Compares all corresponding elements to see if a == b (exact equals).
VCompareWithFlagsGE(v128Param, v128Param, u32 &)	Compares all corresponding elements to see if a >= b.
VCompareWithFlagsGT(v128Param, v128Param, u32 &)	Compares all corresponding elements to see if a > b.
VCompareWithFlagsLE(v128Param, v128Param, u32 &)	Compares all corresponding elements to see if a <= b.
VCompareWithFlagsLT(v128Param, v128Param, u32 &)	Compares all corresponding elements to see if a < b.
VConstruct(float, float, float, float)	Construct a v128 from 4 floats. Fairly slow.
VConstructBitwise(u32, u32, u32, u32)	Re-intreprets 4 ints as floats and construct a vector from them.
VCross3(v128Param, v128Param)	Cross the first 3 elements of each.
VCross3ZeroW(v128Param, v128Param)	Cross the first 3 elements of each.
VFrac(Geo::v128Param)	Returns the fractional part of each element of v.
VGetMaskNotSignBit()	Returns a mask with everything but the 4 sign bits set.
VGetMaskSignBit()	Returns a mask with just the 4 sign bits set.
VLoadAligned(const float *)	Load a 4-float array from 16-byte aligned memory.
VLoadUnaligned(const float *)	Load a 4-float array from arbitrarily aligned memory. Cannot be null.
VMadd(Geo::v128Param, Geo::v128Param, Geo::v128Param)	This is a vector multiply accumulate operation returning (a * b) + c.
VNegate(v128Param)	Return -v. You can use the operator overload instead if you prefer.
VOpAnd(Geo::v128Param, Geo::v128Param)	This is a bitwise & operation.
VOpOnesCompl(Geo::v128Param)	This is a bitwise ~ operation.
VOpOr(Geo::v128Param, Geo::v128Param)	This is a bitwise \| operation.
VOpXor(Geo::v128Param, Geo::v128Param)	This is a bitwise ^ operation.
VPackX4(const Geo::v128 &, const Geo::v128 &, const Geo::v128 &, const Geo::v128 &)	Packs the X component from each of the four vectors into a single vector.
VPerpendicular(v128Param, float)	Returns a vector perpendicular to v (with one of its components being zero).
VRecip(v128Param)	Return 1.f / v. (inaccurate)
VRecipFast(v128Param)	Return 1.f / v. (fast approximate where available. If not, implemented as VRecip)
VRecipSqrt(v128Param)	Return 1.f / sqrt(v). (inaccurate)
VRecipSqrtFast(v128Param)	Return 1.f / sqrt(v). (inaccurate)
VReverse(v128Param)	Reverses the order of the components from xyzw to wzyx.
VShuffle(v128Param, int, int, int, int)	Returns the specified permutation of the parameter vector. Any permutation is valid.
VSqrt(v128Param)	Return sqrt(v). (more inaccurate than the reciprocal version on non-sse hardware)
VTestFlagsAllFalse(u32)	Tests the flags produced by the VCompareWithFlags* operations.
VTestFlagsAllTrue(u32)	Tests the flags produced by the VCompareWithFlags* operations.
VTestFlagsSomeFalse(u32)	Tests the flags produced by the VCompareWithFlags* operations.
VTestFlagsSomeTrue(u32)	Tests the flags produced by the VCompareWithFlags* operations.
VZero()	A fully-zeroed out vector.

Variables

Name	Description
const v128 g_VecEpsilon = VBroadcast(0.001f)	This has the value of g_VecEpsilonF broadcast into all elements.
const float g_VecEpsilonF = 0.001f	A general epsilon for use with the IsUnitLength function.
const u32 g_VecMaskFalse = 0x00000000	A mask value of 'false' = 0x00000000.
const u32 g_VecMaskTrue = 0xffffffff	A mask value of 'true' = 0xffffffff.
const v128 g_VecNormaliseEpsilon = VBroadcast(1e-35f)	An internal epsilon used inside the vector normalisation functions.
const Geo::v128 g_VFours	Some common useful constants.
const Geo::v128 g_VHalves	Some common useful constants.
const Geo::v128 g_VMinusOnes	Some common useful constants.
const Geo::v128 g_VMinusOneTwoEights	Some common useful constants.
const Geo::v128 g_VOneOverOneTwoSevens	Some common useful constants.
const Geo::v128 g_VOneOverPi	Some common useful constants.
const Geo::v128 g_VOneOverTwoFives	Some common useful constants.
const Geo::v128 g_VOneOverTwoPi	Some common useful constants.
const Geo::v128 g_VOnes	Some common useful constants.
const Geo::v128 g_VOneTwoSevens	Some common useful constants.
const Geo::v128 g_VPi	Some common useful constants.
const Geo::v128 g_VQuarters	Some common useful constants.
const Geo::v128 g_VThirds	Some common useful constants.
const Geo::v128 g_VThrees	Some common useful constants.
const Geo::v128 g_VTwoFiveFives	Some common useful constants.
const Geo::v128 g_VTwos	Some common useful constants.
const Geo::v128 g_VZero	Some common useful constants.

Enums

Name	Description
eVShufflePosition	Shuffle constants for the GEO_VSHUFFLE macro.

Defines

Name	Description
GEO_VSHUFFLE VShuffle(v, x, y, z, w)	Returns the specified permutation of the parameter vector.

GEO_FORCE_INLINE v128 Geo::Abs

public: v128 Abs
(
v128Param a
)

Returns a vector with the Abs function applied to all 4 elements.

bool Geo::EqualWithinEpsilon

public: bool EqualWithinEpsilon
(
v128Param a,
v128Param b,
v128Param epsilon
)

Returns true if all elements of a and b are within g_VecEpsilon of each other.

You may specify an epsilon vector that contains different epsilon values in each element if you wish.

Geo::v128 GEO_CALL Geo::GetV128FromString

public: Geo::v128GEO_CALL GetV128FromString
(
const C * str
)

Parses a v128 from the given string.

Geo::v128 GEO_CALL Geo::GetV128FromStringXYZ

public: Geo::v128GEO_CALL GetV128FromStringXYZ
(
const C * str,
float w
)

Parses a v128 from the given string, ignoring the W-component and instead setting it to the given value.

bool Geo::IsFinite

public: bool IsFinite
(
v128Param v
)

Returns true if all of the 4 elements of v are finite.

TODO - this function doesn't detect INFs yet!

bool Geo::IsNan

public: bool IsNan
(
v128Param v
)

Returns true if any of the 4 elements of v are NANs.

v128 Geo::Lerp

public: v128 Lerp
(
v128Param a,
v128Param b,
v128Param s
)

Linearly interpolated between the corresponding components of a and b.

s is the interpolation factor, typically having values between 0 -> 1.

GEO_FORCE_INLINE v128 Geo::Max

public: v128 Max
(
const v128 & a,
const v128 & b
)

Returns a vector where each element has the maximum value of the corresponding values in a and b NOTE - the Min3 template function will work with the v128 type as well.

GEO_FORCE_INLINE v128 Geo::Min

public: v128 Min
(
const v128 & a,
const v128 & b
)

Returns a vector where each element has the minimum value of the corresponding values in a and b NOTE - the Min3 template function will work with the v128 type as well.

GEO_FORCE_INLINE Geo::v128 Geo::operator-

public: Geo::v128 operator-
(
Geo::v128Param lhs,
Geo::v128Param rhs
)

Operator - (component-wise subtraction)

GEO_FORCE_INLINE Geo::v128 Geo::operator-

public: Geo::v128 operator-
(
Geo::v128Param v
)

The unary - operator. Equivalent to (VZero() - v);.

GEO_FORCE_INLINE Geo::v128 Geo::operator*

public: Geo::v128 operator*
(
Geo::v128Param lhs,
Geo::v128Param rhs
)

Operator * (component-wise multiplication)

GEO_FORCE_INLINE Geo::v128 & Geo::operator*=

public: Geo::v128 & operator*=
(
Geo::v128 & lhs,
Geo::v128Param rhs
)

Inplace *.

GEO_FORCE_INLINE Geo::v128 Geo::operator/

public: Geo::v128 operator/
(
Geo::v128Param lhs,
Geo::v128Param rhs
)

Operator / (component-wise division)

GEO_FORCE_INLINE Geo::v128 & Geo::operator/=

public: Geo::v128 & operator/=
(
Geo::v128 & lhs,
Geo::v128Param rhs
)

Inplace /.

GEO_FORCE_INLINE Geo::v128 Geo::operator+

public: Geo::v128 operator+
(
Geo::v128Param lhs,
Geo::v128Param rhs
)

Operator + (component-wise addition)

GEO_FORCE_INLINE Geo::v128 Geo::operator+

public: Geo::v128 operator+
(
Geo::v128Param v
)

The unary + operator (effectively a no-op)

GEO_FORCE_INLINE Geo::v128 & Geo::operator+=

public: Geo::v128 & operator+=
(
Geo::v128 & lhs,
Geo::v128Param rhs
)

Inplace +.

GEO_FORCE_INLINE Geo::v128 & Geo::operator-=

public: Geo::v128 & operator-=
(
Geo::v128 & lhs,
Geo::v128Param rhs
)

Inplace -.

Geo::GeoString<char> GEO_CALL Geo::V128ToUtf8String

public: Geo::GeoString< char > GEO_CALL V128ToUtf8String
(
const Geo::v128 & v
)

Creates a GeoString representation of the vector (space-separated).

The ..XYZ versions return a string containing only the X, Y and Z components of the vector, the others include W.

Geo::GeoString<char> GEO_CALL Geo::V128ToUtf8StringXYZ

public: Geo::GeoString< char > GEO_CALL V128ToUtf8StringXYZ
(
const Geo::v128 & v
)

Creates a GeoString representation of the vector (space-separated).

The ..XYZ versions return a string containing only the X, Y and Z components of the vector, the others include W.

GEO_FORCE_INLINE v128 Geo::VBroadcast

public: v128 VBroadcast
(
float x
)

Construct a v128 by broadcasting a float into all elements.

This is particularly handy when you want to use the vpu to do regular fpu operations.

GEO_FORCE_INLINE v128 Geo::VBroadcastInt

public: v128 VBroadcastInt
(
s32 x
)

Construct a v128 by converting an integer to a float and broadcasting it into all elements.

GEO_FORCE_INLINE v128 Geo::VCeil

public: v128 VCeil
(
v128Param v
)

Return ceil(v).

v128 Geo::VCompareEquals

public: v128 VCompareEquals
(
v128Param a,
v128Param b
)

Compares all corresponding elements to see if a == b (exact equals).

Returns a mask with the result of all comparisons as true/false mask values.

v128 Geo::VCompareGE

public: v128 VCompareGE
(
v128Param a,
v128Param b
)

Compares all corresponding elements to see if a >= b.

Returns a mask with the result of all comparisons as true/false mask values.

v128 Geo::VCompareGT

public: v128 VCompareGT
(
v128Param a,
v128Param b
)

Compares all corresponding elements to see if a > b.

Returns a mask with the result of all comparisons as true/false mask values.

v128 Geo::VCompareIsFinite

public: v128 VCompareIsFinite
(
v128Param v
)

Tests all elements of v to see if they are finite or not.

It returns a mask with true/false mask values with the result of these 4 tests. TODO - this function isn't complete yet as it doesn't detect INF values yet!

v128 Geo::VCompareIsNan

public: v128 VCompareIsNan
(
v128Param v
)

Tests all elements of v to see if any of them are NANs.

It returns a mask with true/false mask values with the result of these 4 tests.

v128 Geo::VCompareLE

public: v128 VCompareLE
(
v128Param a,
v128Param b
)

Compares all corresponding elements to see if a <= b.

Returns a mask with the result of all comparisons as true/false mask values.

v128 Geo::VCompareLT

public: v128 VCompareLT
(
v128Param a,
v128Param b
)

Compares all corresponding elements to see if a < b.

Returns a mask with the result of all comparisons as true/false mask values.

v128 Geo::VCompareWithFlagsEquals

public: v128 VCompareWithFlagsEquals
(
v128Param a,
v128Param b,
u32 & flags
)

Compares all corresponding elements to see if a == b (exact equals).

Returns a mask with the result of all comparisons as true/false mask values. It additionally sets flags to be a platform dependent value that encodes the result of the 4 comparisons. You can only use this flag value with the VTestFlags* functions. Do not assume any particular values of the flags as they vary between platforms. The flags enable you to branch from the result of a vpu comparison operation.

v128 Geo::VCompareWithFlagsGE

public: v128 VCompareWithFlagsGE
(
v128Param a,
v128Param b,
u32 & flags
)

Compares all corresponding elements to see if a >= b.

Returns a mask with the result of all comparisons as true/false mask values. It additionally sets flags to be a platform dependent value that encodes the result of the 4 comparisions. You can only use this flag value with the VTestFlags* functions. Do not assume any particular values of the flags as they vary between platforms. The flags enable you to branch from the result of a vpu comparison operation.

v128 Geo::VCompareWithFlagsGT

public: v128 VCompareWithFlagsGT
(
v128Param a,
v128Param b,
u32 & flags
)

Compares all corresponding elements to see if a > b.

Returns a mask with the result of all comparisons as true/false mask values. It additionally sets flags to be a platform dependent value that encodes the result of the 4 comparisons. You can only use this flag value with the VTestFlags* functions. Do not assume any particular values of the flags as they vary between platforms. The flags enable you to branch from the result of a vpu comparison operation.

v128 Geo::VCompareWithFlagsLE

public: v128 VCompareWithFlagsLE
(
v128Param a,
v128Param b,
u32 & flags
)

Compares all corresponding elements to see if a <= b.

Returns a mask with the result of all comparisons as true/false mask values. It additionally sets flags to be a platform dependent value that encodes the result of the 4 comparisons. You can only use this flag value with the VTestFlags* functions. Do not assume any particular values of the flags as they vary between platforms. The flags enable you to branch from the result of a vpu comparison operation.

v128 Geo::VCompareWithFlagsLT

public: v128 VCompareWithFlagsLT
(
v128Param a,
v128Param b,
u32 & flags
)

Compares all corresponding elements to see if a < b.

Returns a mask with the result of all comparisons as true/false mask values. It additionally sets flags to be a platform dependent value that encodes the result of the 4 comparisons. You can only use this flag value with the VTestFlags* functions. Do not assume any particular values of the flags as they vary between platforms. The flags enable you to branch from the result of a vpu comparison operation.

GEO_FORCE_INLINE v128 Geo::VConstruct

public: v128 VConstruct
(
float x,
float y,
float z,
float w
)

Construct a v128 from 4 floats. Fairly slow.

GEO_FORCE_INLINE v128 Geo::VConstructBitwise

public: v128 VConstructBitwise
(
u32 x,
u32 y,
u32 z,
u32 w
)

Re-intreprets 4 ints as floats and construct a vector from them.

This is for building a mask if you need one that this file doesn't provide (see below). It's also quite slow, so if you use the mask regularly you might want to declare a static aligned bit of memory and load the vector from that.

v128 Geo::VCross3

public: v128 VCross3
(
v128Param lhs,
v128Param rhs
)

Cross the first 3 elements of each.

Providing the w element of both is finite the resulting w will be 0. If it is not finite the nan or inf will be passed through to the w. (NB: on PPU, w is just cleared.)

GEO_FORCE_INLINE v128 Geo::VCross3ZeroW

public: v128 VCross3ZeroW
(
v128Param lhs,
v128Param rhs
)

Cross the first 3 elements of each.

The w element will be set to zero. The w elements of the parameters are not considered. Prefer this if you are not sure if the w elements of your parameters are finite or not.

GEO_FORCE_INLINE Geo::v128 Geo::VFrac

public: Geo::v128 VFrac
(
Geo::v128Param v
)

Returns the fractional part of each element of v.

v128 Geo::VGetMaskNotSignBit

public: v128 VGetMaskNotSignBit()

Returns a mask with everything but the 4 sign bits set.

v128 Geo::VGetMaskSignBit

public: v128 VGetMaskSignBit()

Returns a mask with just the 4 sign bits set.

GEO_FORCE_INLINE v128 Geo::VLoadAligned

public: v128 VLoadAligned
(
const float * vecToLoad
)

Load a 4-float array from 16-byte aligned memory.

Cannot be null. NOTE: the memory must be aligned or this will crash.

GEO_FORCE_INLINE v128 Geo::VLoadUnaligned

public: v128 VLoadUnaligned
(
const float * vecToLoad
)

Load a 4-float array from arbitrarily aligned memory. Cannot be null.

GEO_FORCE_INLINE v128 Geo::VMadd

public: Geo::v128 VMadd
(
Geo::v128Param a,
Geo::v128Param b,
Geo::v128Param c
)

This is a vector multiply accumulate operation returning (a * b) + c.

GEO_FORCE_INLINE v128 Geo::VNegate

public: v128 VNegate
(
v128Param v
)

Return -v. You can use the operator overload instead if you prefer.

GEO_FORCE_INLINE v128 Geo::VOpAnd

public: Geo::v128 VOpAnd
(
Geo::v128Param lhs,
Geo::v128Param rhs
)

This is a bitwise & operation.

You can use this with masks to perform a number of useful operations, including zeroing elements. For example: v128 xz = myVec & VGetMaskXZ();

GEO_FORCE_INLINE v128 Geo::VOpOnesCompl

public: Geo::v128 VOpOnesCompl
(
Geo::v128Param v
)

This is a bitwise ~ operation.

You can use this with masks generate the opposite mask.

GEO_FORCE_INLINE v128 Geo::VOpOr

public: Geo::v128 VOpOr
(
Geo::v128Param lhs,
Geo::v128Param rhs
)

This is a bitwise | operation.

You can use this with masks to perform a number of useful operations, including combining vectors and setting sign bits. For example: v128 xyzw = xyonly | zwonly; v128 xznegated = myVec | (VGetMaskSignBit() & VGetMaskXZ());

GEO_FORCE_INLINE v128 Geo::VOpXor

public: Geo::v128 VOpXor
(
Geo::v128Param lhs,
Geo::v128Param rhs
)

This is a bitwise ^ operation.

You can use this with masks to perform a number of useful operations, including toggling sign bits and building masks. For example: v128 xySignsSwapped = myVec ^ (VGetMaskSignBit() & VGetMaskXY());

GEO_FORCE_INLINE v128 Geo::VPackX4

public: GEO_FORCE_INLINEGeo::v128 VPackX4
(
const Geo::v128 & x,
const Geo::v128 & y,
const Geo::v128 & z,
const Geo::v128 & w
)

Packs the X component from each of the four vectors into a single vector.

v128 Geo::VPerpendicular

public: v128 VPerpendicular
(
v128Param v,
float ep
)

Returns a vector perpendicular to v (with one of its components being zero).

Must pass a vector with at least one component > g_VecEpsilonF to avoid nasty interactions with VNormalise.

v128 Geo::VRecip

public: v128 VRecip
(
v128Param v
)

Return 1.f / v. (inaccurate)

GEO_FORCE_INLINE v128 Geo::VRecipFast

public: v128 VRecipFast
(
v128Param v
)

Return 1.f / v. (fast approximate where available. If not, implemented as VRecip)

v128 Geo::VRecipSqrt

public: v128 VRecipSqrt
(
v128Param v
)

Return 1.f / sqrt(v). (inaccurate)

v128 Geo::VRecipSqrtFast

public: v128 VRecipSqrtFast
(
v128Param v
)

Return 1.f / sqrt(v). (inaccurate)

v128 Geo::VReverse

public: v128 VReverse
(
v128Param v
)

Reverses the order of the components from xyzw to wzyx.

v128 Geo::VShuffle

public: v128 VShuffle
(
v128Param v,
int x,
int y,
int z,
int w
)

Returns the specified permutation of the parameter vector. Any permutation is valid.

GEO_FORCE_INLINE v128 Geo::VSqrt

public: v128 VSqrt
(
v128Param v
)

Return sqrt(v). (more inaccurate than the reciprocal version on non-sse hardware)

bool Geo::VTestFlagsAllFalse

public: bool VTestFlagsAllFalse
(
u32 flags
)

Tests the flags produced by the VCompareWithFlags* operations.

This returns true if all 4 comparisons were false.

bool Geo::VTestFlagsAllTrue

public: bool VTestFlagsAllTrue
(
u32 flags
)

Tests the flags produced by the VCompareWithFlags* operations.

This returns true if all 4 comparisons were true.

bool Geo::VTestFlagsSomeFalse

public: bool VTestFlagsSomeFalse
(
u32 flags
)

Tests the flags produced by the VCompareWithFlags* operations.

This returns true if one or more of the 4 comparisons were false.

bool Geo::VTestFlagsSomeTrue

public: bool VTestFlagsSomeTrue
(
u32 flags
)

Tests the flags produced by the VCompareWithFlags* operations.

This returns true if one or more of the 4 comparisons were true.

GEO_FORCE_INLINE v128 Geo::VZero

public: v128 VZero()

A fully-zeroed out vector.

eVShufflePosition

public: enum eVShufflePosition
{
VSHUF_X = 0,
VSHUF_Y = 1,
VSHUF_Z = 2,
VSHUF_W = 3
}

Shuffle constants for the GEO_VSHUFFLE macro.

enumerators

VSHUF_X
VSHUF_Y
VSHUF_Z
VSHUF_W