This is the documentation for Enlighten.

module Vectors

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)

VRecipSqrtAccurate(v128Param)

Return 1.f / sqrt(v). (more accurate)

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::VRecipSqrtAccurate


public: v128 VRecipSqrtAccurate
(
    v128Param v
)


Return 1.f / sqrt(v). (more accurate)


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