|
half | operator+ (half one, half two) |
|
half | operator- (half one, half two) |
|
half | operator* (half one, half two) |
|
half | operator/ (half one, half two) |
|
half | operator+ (half one, float two) |
|
half | operator- (half one, float two) |
|
half | operator* (half one, float two) |
|
half | operator/ (half one, float two) |
|
float | operator+ (float one, half two) |
|
float | operator- (float one, half two) |
|
float | operator* (float one, half two) |
|
float | operator/ (float one, half two) |
|
mat4 | reflect (const vec4 &p) |
| based on this http://www.opengl.org/discussion_boards/showthread.php/169605-reflection-matrix-how-to-derive
|
|
void | decompose (const mat4 &mat, vec3 &outScale, quat &outRotation, vec3 &outTranslation) |
|
mat4 | affine (const vec3 &scale, const vec3 &rotationCenter, const quat &rotation, const vec3 &translation) |
|
mat4 | affine (const vec3 &scale, const quat &rotation, const vec3 &translation) |
|
mat4 | affine (const vec3 &scale, const vec3 &rotation, const vec3 &translation) |
|
mat4 | affinetransformation (scalar scale, const vec3 &rotationCenter, const quat &rotation, const vec3 &translation) |
|
mat4 | rotationquat (const quat &q) |
| TODO: rewrite using SSE.
|
|
mat4 | transformation (const vec3 &scalingCenter, const quat &scalingRotation, const vec3 &scale, const vec3 &rotationCenter, const quat &rotation, const vec3 &trans) |
|
bool | ispointinside (const vec4 &p, const mat4 &m) |
|
mat4 | fromeuler (const vec3 &v) |
|
vec3 | aseuler (const mat4 &m) |
|
mat4 | skewsymmetric (const vec3 &v) |
|
__forceinline bool | isidentity (const mat4 &m) |
|
__forceinline scalar | determinant (const mat4 &m) |
|
__forceinline mat4 | inverse (const mat4 &m) |
|
__forceinline mat4 | lookatlh (const point &eye, const point &at, const vector &up) |
|
__forceinline mat4 | lookatrh (const point &eye, const point &at, const vector &up) |
|
__forceinline mat4 | operator* (const mat4 &m0, const mat4 &m1) |
|
__forceinline vec4 | operator* (const mat4 &m, const vec4 &v) |
|
__forceinline vec4 | operator* (const mat4 &m, const vec3 &v) |
|
__forceinline vec4 | operator* (const mat4 &m, const point &p) |
|
__forceinline vector | operator* (const mat4 &m, const vector &v) |
|
__forceinline mat4 | ortholh (scalar w, scalar h, scalar zn, scalar zf) |
|
__forceinline mat4 | orthorh (scalar w, scalar h, scalar zn, scalar zf) |
|
__forceinline mat4 | orthooffcenterlh (scalar l, scalar r, scalar t, scalar b, scalar zn, scalar zf) |
|
__forceinline mat4 | orthooffcenterrh (scalar l, scalar r, scalar t, scalar b, scalar zn, scalar zf) |
|
__forceinline mat4 | perspfovlh (scalar fovy, scalar aspect, scalar zn, scalar zf) |
|
__forceinline mat4 | perspfovrh (scalar fovy, scalar aspect, scalar zn, scalar zf) |
|
__forceinline mat4 | persplh (scalar w, scalar h, scalar zn, scalar zf) |
|
__forceinline mat4 | persprh (scalar w, scalar h, scalar zn, scalar zf) |
|
__forceinline mat4 | perspoffcenterlh (scalar l, scalar r, scalar b, scalar t, scalar zn, scalar zf) |
|
__forceinline mat4 | perspoffcenterrh (scalar l, scalar r, scalar b, scalar t, scalar zn, scalar zf) |
|
__forceinline mat4 | rotationaxis (const vec3 &axis, scalar angle) |
|
__forceinline mat4 | rotationx (scalar angle) |
|
__forceinline mat4 | rotationy (scalar angle) |
|
__forceinline mat4 | rotationz (scalar angle) |
|
__forceinline mat4 | rotationyawpitchroll (scalar yaw, scalar pitch, scalar roll) |
|
__forceinline mat4 | scaling (scalar scale) |
|
__forceinline mat4 | scaling (scalar sx, scalar sy, scalar sz) |
|
__forceinline mat4 | scaling (const vec3 &s) |
|
__forceinline mat4 | translation (scalar x, scalar y, scalar z) |
|
__forceinline mat4 | translation (const vec3 &t) |
|
__forceinline mat4 | trs (const vec3 &position, const quat &rotation, const vec3 &scale) |
| A short hand for creating a TRS (translation, rotation, scale) matrix from pos, rot and scale.
|
|
__forceinline mat4 | transpose (const mat4 &m) |
|
vector | get_normal (const plane &plane) |
|
point | get_point (const plane &plane) |
|
bool | intersectline (const plane &plane, const point &startPoint, const point &endPoint, point &outIntersectPoint) |
|
bool | intersectplane (const plane &p1, const plane &p2, line &outLine) |
| TODO: Test and make sure it produces correct intersection line.
|
|
ClipStatus::Type | clip (const plane &plane, const line &l, line &outClippedLine) |
|
__forceinline scalar | dot (const plane &p, const vec4 &v1) |
|
__forceinline plane | normalize (const plane &p) |
|
__forceinline plane | operator* (const mat4 &m, const plane &p) |
|
__forceinline point | operator+ (const point &lhs, const vector &rhs) |
|
__forceinline point | operator- (const point &lhs, const vector &rhs) |
|
__forceinline vector | operator- (const point &lhs, const point &rhs) |
|
__forceinline scalar | dot (const point &p0, const point &p1) |
|
__forceinline scalar | dot (const vector &v, const point &p) |
|
__forceinline scalar | dot (const point &p, const vector &v) |
|
__forceinline point | maximize (const point &v0, const point &v1) |
|
__forceinline point | minimize (const point &v0, const point &v1) |
|
__forceinline bool | less_any (const point &v0, const point &v1) |
|
__forceinline bool | less_all (const point &v0, const point &v1) |
|
__forceinline bool | lessequal_any (const point &v0, const point &v1) |
|
__forceinline bool | lessequal_all (const point &v0, const point &v1) |
|
__forceinline bool | greater_any (const point &v0, const point &v1) |
|
__forceinline bool | greater_all (const point &v0, const point &v1) |
|
__forceinline bool | greaterequal_any (const point &v0, const point &v1) |
|
__forceinline bool | greaterequal_all (const point &v0, const point &v1) |
|
__forceinline bool | equal_any (const point &v0, const point &v1) |
|
__forceinline bool | nearequal (const point &v0, const point &v1, float epsilon) |
|
__forceinline point | less (const point &v0, const point &v1) |
|
__forceinline point | greater (const point &v0, const point &v1) |
|
__forceinline point | equal (const point &v0, const point &v1) |
|
__forceinline vec3 | xyz (const point &v) |
|
quat | rotationmatrix (const mat4 &m) |
|
quat | quatyawpitchroll (scalar y, scalar x, scalar z) |
|
vec3 | to_euler (const quat &q) |
|
quat | from_euler (const vec3 &v) |
|
quat | slerp (const quat &q1, const quat &q2, scalar t) |
| quat slerp TODO: rewrite using sse/avx
|
|
vec3 | rotate (quat const &q, vec3 const &v) |
| Rotate a vector by a quaternion.
|
|
__forceinline bool | isidentity (const quat &q) |
|
__forceinline scalar | length (const quat &q) |
|
__forceinline scalar | lengthsq (const quat &q) |
|
__forceinline quat | quatUndenormalize (const quat &q) |
|
__forceinline quat | barycentric (const quat &q0, const quat &q1, const quat &q2, scalar f, scalar g) |
|
__forceinline quat | conjugate (const quat &q) |
|
__forceinline scalar | dot (const quat &q0, const quat &q1) |
|
__forceinline quat | quatExp (const quat &q) |
|
__forceinline quat | identity () |
|
__forceinline quat | inverse (const quat &q) |
|
__forceinline quat | ln (const quat &q) |
|
__forceinline quat | operator* (const quat &q0, const quat &q1) |
|
__forceinline quat | normalize (const quat &q) |
|
__forceinline quat | rotationquataxis (const vec3 &axis, scalar angle) |
| quat from rotation axis + angle.
|
|
__forceinline void | squadsetup (const quat &q0, const quat &q1, const quat &q2, const quat &q3, quat &aOut, quat &bOut, quat &cOut) |
|
__forceinline quat | squad (const quat &q1, const quat &a, const quat &b, const quat &c, scalar t) |
|
__forceinline void | to_axisangle (const quat &q, vec4 &outAxis, scalar &outAngle) |
|
__forceinline scalar | rand () |
| Return a pseudo random number between 0 and 1.
|
|
__forceinline scalar | rand (scalar min, scalar max) |
| Return a pseudo random number between min and max.
|
|
__forceinline scalar | sin (scalar x) |
|
__forceinline scalar | cos (scalar x) |
|
__forceinline scalar | tan (scalar x) |
|
__forceinline scalar | asin (scalar x) |
|
__forceinline scalar | acos (scalar x) |
|
__forceinline scalar | atan (scalar x) |
|
__forceinline scalar | sqrt (scalar x) |
|
__forceinline int | fchop (scalar f) |
| Chop float to int.
|
|
__forceinline scalar | fmod (scalar x, scalar y) |
|
__forceinline scalar | modangle (scalar a) |
| Normalize an angular value into the range rad(0) to rad(360).
|
|
__forceinline scalar | log2 (scalar f) |
| log2() function.
|
|
__forceinline scalar | exp2 (scalar x) |
|
__forceinline scalar | log (scalar x) |
| get logarithm of x
|
|
__forceinline scalar | exp (scalar x) |
|
__forceinline int | frnd (scalar f) |
| Round float to integer.
|
|
__forceinline scalar | pow (scalar x, scalar y) |
|
__forceinline bool | fequal (scalar f0, scalar f1, scalar tol) |
| A fuzzy floating point equality check.
|
|
template<typename TYPE > |
__forceinline TYPE | max (TYPE a, TYPE b) |
|
template<typename TYPE0 , typename ... TYPEN> |
__forceinline TYPE0 | max (TYPE0 first, TYPE0 second, TYPEN... rest) |
|
template<> |
__forceinline unsigned int | max (unsigned int a, unsigned int b) |
| branchless max for uint32
|
|
template<typename TYPE > |
__forceinline TYPE | min (TYPE a, TYPE b) |
|
template<> |
__forceinline unsigned int | min (unsigned int a, unsigned int b) |
| branchless min for uints
|
|
template<> |
__forceinline uint16_t | min (uint16_t a, uint16_t b) |
| branchless min for uints
|
|
template<typename TYPE0 , typename ... TYPEN> |
__forceinline TYPE0 | min (TYPE0 first, TYPE0 second, TYPEN... rest) |
|
__forceinline scalar | abs (scalar a) |
|
__forceinline double | abs (double a) |
|
__forceinline int | abs (int a) |
|
__forceinline scalar | sgn (scalar a) |
|
__forceinline constexpr scalar | deg2rad (scalar d) |
|
__forceinline constexpr scalar | rad2deg (scalar r) |
|
__forceinline float | clamp (float val, float minVal, float maxVal) |
| Float clamping.
|
|
__forceinline int64_t | clamp (int64_t val, int64_t minVal, int64_t maxVal) |
| int clamping.
|
|
__forceinline int32_t | clamp (int32_t val, int32_t minVal, int32_t maxVal) |
| int clamping.
|
|
__forceinline float | ceil (float val) |
| Floating point ceiling.
|
|
__forceinline float | floor (float val) |
| Floating point flooring.
|
|
__forceinline float | round (float val) |
| Floating point rounding.
|
|
__forceinline bool | fless (scalar f0, scalar f1, scalar tol) |
| A fuzzy floating point less-then check.
|
|
__forceinline bool | fgreater (scalar f0, scalar f1, scalar tol) |
| A fuzzy floating point greater-then check.
|
|
__forceinline scalar | saturate (scalar val) |
| Saturate a value (clamps between 0.0f and 1.0f)
|
|
__forceinline double | saturate (double val) |
| Saturate a value (clamps between 0.0f and 1.0f)
|
|
__forceinline float | lerp (float x, float y, float l) |
| Linearly interpolate between 2 values: ret = x + l * (y - x)
|
|
__forceinline scalar | angulardistance (scalar from, scalar to) |
| Get angular distance.
|
|
__forceinline bool | isdenormal (scalar s) |
| Returns true if the input scalar is denormalized (#DEN)
|
|
__forceinline float | undenormalize (scalar s) |
| Returns 0 if scalar is denormal.
|
|
__forceinline bool | nearequal (scalar a, scalar b, scalar epsilon) |
| test of nearly equal given a tolerance (epsilon)
|
|
__forceinline scalar | cot (scalar x) |
|
__forceinline scalar | smoothstep (scalar edge0, scalar edge1, scalar x) |
|
__forceinline int | irand (int min, int max) |
| Return a pseudo integer random number between min and max.
|
|
__forceinline int | mostsignificant (unsigned int val) |
| Returns the position of the most significant bit of the number.
|
|
__forceinline unsigned int | align (unsigned int alignant, unsigned int alignment) |
|
__forceinline uintptr_t | alignptr (uintptr_t alignant, uintptr_t alignment) |
|
__forceinline unsigned int | align_down (unsigned int alignant, unsigned int alignment) |
|
__forceinline uintptr_t | align_downptr (uintptr_t alignant, uintptr_t alignment) |
|
__forceinline unsigned int | divandroundup (unsigned int dividend, unsigned int divider) |
| Integer division with rounding.
|
|
__forceinline unsigned int | roundtopow2 (unsigned int val) |
| Rounds up to next power of 2.
|
|
__forceinline uint64 | randxor (randxorstate &state) |
|
__forceinline uint32_t | pointerhash (void *ptr) |
| cheap pointer hash using modulo with a mersenne prime
|
|
float | normtofloat (uint16_t value) |
| convert normalized uint16_t to float
|
|
float | normtofloat (int16_t value) |
| convert normalized int16_t to float
|
|
float | normtofloat (uint8_t value) |
| convert normalized uint8_t to float
|
|
float | normtofloat (int8_t value) |
| convert normalized int8_t to float
|
|
__forceinline __m128 | fmadd (__m128 a, __m128 b, __m128 c) |
| Fused multiply-add operation, (a * b) + c.
|
|
__forceinline __m128 | less (__m128 a, __m128 b) |
| Constructs a vector of results where each element corresponds to a[i] < b[i] with either 0 or 1.
|
|
__forceinline __m128 | greater (__m128 a, __m128 b) |
| Constructs a vector of results where each element corresponds to a[i] > b[i] with either 0 or 1.
|
|
__forceinline __m128 | recip (__m128 a) |
|
__forceinline __m128 | mul (__m128 a, __m128 b) |
|
__forceinline __m128 | div (__m128 a, __m128 b) |
|
template<int x, int y, int z, int w> |
__forceinline __m128 | swizzle (__m128 v) |
|
transform | operator* (const transform &a, const transform &b) |
|
transform | lerp (const transform &a, const transform &b, float t) |
|
point | operator* (const transform &a, const point &b) |
| transforms a position (applies scale, rotation and offset)
|
|
vector | operator* (const transform &a, const vector &b) |
| transforms a vector (ignores position)
|
|
__forceinline vec2 | lerp (const vec2 &v0, const vec2 &v1, scalar s) |
|
__forceinline vec3 | operator- (const vec3 &lhs) |
|
__forceinline vec3 | operator* (const vec3 &lhs, scalar t) |
|
__forceinline vec3 | operator* (const vec3 &lhs, const vec3 &rhs) |
|
__forceinline vec3 | operator+ (const vec3 &lhs, const vec3 &rhs) |
|
__forceinline vec3 | operator- (const vec3 &lhs, const vec3 &rhs) |
|
__forceinline scalar | length (const vec3 &v) |
|
__forceinline scalar | lengthsq (const vec3 &v) |
|
__forceinline vec3 | reciprocal (const vec3 &v) |
|
__forceinline vec3 | reciprocalapprox (const vec3 &v) |
|
__forceinline vec3 | multiply (const vec3 &v0, const vec3 &v1) |
|
__forceinline vec3 | multiplyadd (const vec3 &v0, const vec3 &v1, const vec3 &v2) |
|
__forceinline vec3 | divide (const vec3 &v0, const vec3 &v1) |
|
__forceinline vec3 | abs (const vec3 &v) |
|
__forceinline vec3 | cross (const vec3 &v0, const vec3 &v1) |
|
__forceinline scalar | dot (const vec3 &v0, const vec3 &v1) |
|
__forceinline vec3 | barycentric (const vec3 &v0, const vec3 &v1, const vec3 &v2, scalar f, scalar g) |
| calculates Result = v0 + f * (v1 - v0) + g * (v2 - v0)
|
|
__forceinline vec3 | catmullrom (const vec3 &v0, const vec3 &v1, const vec3 &v2, const vec3 &v3, scalar s) |
|
__forceinline vec3 | hermite (const vec3 &v1, const vec3 &t1, const vec3 &v2, const vec3 &t2, scalar s) |
|
__forceinline scalar | angle (const vec3 &v0, const vec3 &v1) |
|
__forceinline vec3 | lerp (const vec3 &v0, const vec3 &v1, scalar s) |
|
__forceinline vec3 | maximize (const vec3 &v0, const vec3 &v1) |
|
__forceinline vec3 | minimize (const vec3 &v0, const vec3 &v1) |
|
__forceinline vec3 | clamp (const vec3 &clamp, const vec3 &min, const vec3 &max) |
|
__forceinline vec3 | normalize (const vec3 &v) |
|
__forceinline vec3 | normalizeapprox (const vec3 &v) |
|
__forceinline vec3 | reflect (const vec3 &normal, const vec3 &incident) |
|
__forceinline bool | less_any (const vec3 &v0, const vec3 &v1) |
|
__forceinline bool | less_all (const vec3 &v0, const vec3 &v1) |
|
__forceinline bool | lessequal_any (const vec3 &v0, const vec3 &v1) |
|
__forceinline bool | lessequal_all (const vec3 &v0, const vec3 &v1) |
|
__forceinline bool | greater_any (const vec3 &v0, const vec3 &v1) |
|
__forceinline bool | greater_all (const vec3 &v0, const vec3 &v1) |
|
__forceinline bool | greaterequal_any (const vec3 &v0, const vec3 &v1) |
|
__forceinline bool | greaterequal_all (const vec3 &v0, const vec3 &v1) |
|
__forceinline bool | equal_any (const vec3 &v0, const vec3 &v1) |
|
__forceinline bool | nearequal (const vec3 &v0, const vec3 &v1, float epsilon) |
|
__forceinline bool | nearequal (const vec3 &v0, const vec3 &v1, const vec3 &epsilon) |
|
__forceinline vec3 | less (const vec3 &v0, const vec3 &v1) |
|
__forceinline vec3 | greater (const vec3 &v0, const vec3 &v1) |
|
__forceinline vec3 | equal (const vec3 &v0, const vec3 &v1) |
|
__forceinline vec3 | splat (const vec3 &v, uint element) |
|
__forceinline vec3 | splat_x (const vec3 &v) |
|
__forceinline vec3 | splat_y (const vec3 &v) |
|
__forceinline vec3 | splat_z (const vec3 &v) |
|
__forceinline vec3 | permute (const vec3 &v0, const vec3 &v1, unsigned int i0, unsigned int i1, unsigned int i2) |
|
__forceinline vec3 | select (const vec3 &v0, const vec3 &v1, const uint i0, const uint i1, const uint i2) |
|
__forceinline vec3 | select (const vec3 &v0, const vec3 &v1, const vec3 &control) |
|
__forceinline vec3 | floor (const vec3 &v) |
|
__forceinline vec3 | ceiling (const vec3 &v) |
|
__forceinline vec4 | operator- (const vec4 &lhs) |
|
__forceinline vec4 | operator* (const vec4 &lhs, scalar t) |
|
__forceinline vec4 | operator* (const vec4 &lhs, const vec4 &rhs) |
|
__forceinline vec4 | operator+ (const vec4 &lhs, const vec4 &rhs) |
|
__forceinline vec4 | operator- (const vec4 &lhs, const vec4 &rhs) |
|
__forceinline scalar | length (const vec4 &v) |
|
__forceinline scalar | length3 (const vec4 &v) |
|
__forceinline scalar | lengthsq (const vec4 &v) |
|
__forceinline scalar | lengthsq3 (const vec4 &v) |
|
__forceinline vec4 | reciprocal (const vec4 &v) |
|
__forceinline vec4 | reciprocalapprox (const vec4 &v) |
|
__forceinline vec4 | multiply (const vec4 &v0, const vec4 &v1) |
|
__forceinline vec4 | multiplyadd (const vec4 &v0, const vec4 &v1, const vec4 &v2) |
|
__forceinline vec4 | divide (const vec4 &v0, const vec4 &v1) |
|
__forceinline vec4 | abs (const vec4 &v) |
|
__forceinline vec4 | cross3 (const vec4 &v0, const vec4 &v1) |
|
__forceinline scalar | dot (const vec4 &v0, const vec4 &v1) |
|
__forceinline scalar | dot3 (const vec4 &v0, const vec4 &v1) |
|
__forceinline vec4 | barycentric (const vec4 &v0, const vec4 &v1, const vec4 &v2, scalar f, scalar g) |
| calculates Result = v0 + f * (v1 - v0) + g * (v2 - v0)
|
|
__forceinline vec4 | catmullrom (const vec4 &v0, const vec4 &v1, const vec4 &v2, const vec4 &v3, scalar s) |
|
__forceinline vec4 | hermite (const vec4 &v1, const vec4 &t1, const vec4 &v2, const vec4 &t2, scalar s) |
|
__forceinline scalar | angle (const vec4 &v0, const vec4 &v1) |
|
__forceinline vec4 | lerp (const vec4 &v0, const vec4 &v1, scalar s) |
|
__forceinline vec4 | maximize (const vec4 &v0, const vec4 &v1) |
|
__forceinline vec4 | minimize (const vec4 &v0, const vec4 &v1) |
|
__forceinline vec4 | clamp (const vec4 &clamp, const vec4 &min, const vec4 &max) |
|
__forceinline vec4 | normalize (const vec4 &v) |
|
__forceinline vec4 | normalizeapprox (const vec4 &v) |
|
__forceinline vec4 | normalize3 (const vec4 &v) |
|
__forceinline vec4 | normalize3approx (const vec4 &v) |
|
__forceinline vec4 | reflect (const vec4 &normal, const vec4 &incident) |
|
__forceinline vec4 | perspective_div (const vec4 &v) |
|
__forceinline bool | less_any (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | less_all (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | lessequal_any (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | lessequal_all (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | greater_any (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | greater_all (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | greaterequal_any (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | greaterequal_all (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | equal_any (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | nearequal (const vec4 &v0, const vec4 &v1, const float epsilon) |
|
__forceinline bool | nearequal (const vec4 &v0, const vec4 &v1, const vec4 &epsilon) |
|
__forceinline vec4 | less (const vec4 &v0, const vec4 &v1) |
|
__forceinline vec4 | greater (const vec4 &v0, const vec4 &v1) |
|
__forceinline vec4 | equal (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | less3_any (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | less3_all (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | lessequal3_any (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | lessequal3_all (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | greater3_any (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | greater3_all (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | greaterequal3_any (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | greaterequal3_all (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | equal3_any (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | equal3_all (const vec4 &v0, const vec4 &v1) |
|
__forceinline bool | nearequal3 (const vec4 &v0, const vec4 &v1, const vec4 &epsilon) |
|
__forceinline vec4 | splat (const vec4 &v, uint element) |
|
__forceinline vec4 | splat_x (const vec4 &v) |
|
__forceinline vec4 | splat_y (const vec4 &v) |
|
__forceinline vec4 | splat_z (const vec4 &v) |
|
__forceinline vec4 | splat_w (const vec4 &v) |
|
__forceinline vec4 | permute (const vec4 &v0, const vec4 &v1, unsigned int i0, unsigned int i1, unsigned int i2, unsigned int i3) |
|
__forceinline vec4 | select (const vec4 &v0, const vec4 &v1, const uint i0, const uint i1, const uint i2, const uint i3) |
|
__forceinline vec4 | select (const vec4 &v0, const vec4 &v1, const vec4 &control) |
|
__forceinline vec4 | floor (const vec4 &v) |
|
__forceinline vec4 | ceil (const vec4 &v) |
|
__forceinline vec3 | xyz (const vec4 &v) |
|
__forceinline vector | operator- (const vector &rhs) |
|
__forceinline vector | operator+ (const vector &lhs, const vector &rhs) |
|
__forceinline vector | operator- (const vector &lhs, const vector &rhs) |
|
__forceinline vector | operator* (const vector &lhs, scalar s) |
|
__forceinline vector | operator* (const vector &lhs, const vector &rhs) |
|
__forceinline vector | normalize (const vector &v) |
|
__forceinline vector | normalizeapprox (const vector &v) |
|
__forceinline scalar | dot (const vector &v0, const vector &v1) |
|
__forceinline vector | cross (const vector &v0, const vector &v1) |
|
__forceinline scalar | length (const vector &v) |
|
__forceinline scalar | lengthsq (const vector &v) |
|