Float4
A vector with four floating-point components x
, y
, z
and w
.
Header File
#include <ply-math/Vector.h>
Also included from <ply-math/Base.h>
.
Data Members
-
w
is the fourth component. It followsz
sequentially in memory.
Constructors
-
Constructs an uninitialized
Float4
. -
Constructs a
Float4
with all components set tot
.Float4 v = {1}; StdOut::text() << v; // "{1, 1, 1, 1}"
-
Constructs a
Float4
from the given components.Float4 v = {1, 0, 0, 0};
-
Constructs a
Float4
from aFloat3
and a fourth component.Float3 a = {1, 2, 3}; StdOut::text() << Float4{a, 0}; // "{1, 2, 3, 0}"
-
Constructs a
Float4
from aFloat2
and two additional components.Float2 a = {1, 2}; StdOut::text() << Float4{a, 0, 0}; // "{1, 2, 0, 0}"
void Float4::operator=(const Float4& arg) &
[code]-
Copy assignment. Declared with an lvalue ref-qualifier so that it's an error to assign to an rvalue.
a.normalized() = b; // error
Float4 operator-(const Float4& a)
[code]-
Unary negation.
Float4 operator+(const Float4& a, const Float4& b)
[code]Float4 operator-(const Float4& a, const Float4& b)
[code]Float4 operator*(const Float4& a, const Float4& b)
[code]Float4 operator/(const Float4& a, const Float4& b)
[code]-
Returns a vector whose components are the result of applying the given operation to the corresponding components of
a
andb
. Each component is acted on independently.StdOut::text() << Float4{2, 3, 2, 0} * Float4{4, 1, 2, 5}; // "{8, 3, 4, 0}"
If you specify a scalar value in place of a
Float4
, it will be promoted to aFloat4
by replicating the value to each component.StdOut::text() << Float4{2, 3, 2, 0} * 2; // "{4, 6, 4, 0}" StdOut::text() << 8 / Float4{2, 4, 1, 8}; // "{4, 2, 8, 1}"
void operator+=(Float4& a, const Float4& b)
[code]void operator-=(Float4& a, const Float4& b)
[code]void operator*=(Float4& a, const Float4& b)
[code]void operator/=(Float4& a, const Float4& b)
[code]-
In-place versions of the above operators.
Float4 v = {2, 3, 2, 0}; v *= {4, 1, 2, 5}; StdOut::text() << v; // "{8, 3, 4, 0}"
bool operator==(const Float4& a, const Float4& b)
[code]bool operator!=(const Float4& a, const Float4& b)
[code]-
Returns
true
if the vectors are equal (or not equal) using floating-point comparison. In particular,Float4{0.f} == Float4{-0.f}
istrue
. -
Returns
true
ifa
is approximately equal tob
. The tolerance is given byepsilon
.Float4 v = {0.9999f, 0.0001f, 1.9999f, 3.0001f}; StdOut::text() << isNear(v, Float4{1, 0, 2, 3}, 1e-3f); // "true"
Bool4 operator<(const Float4& a, const Float4& b)
[code]Bool4 operator<=(const Float4& a, const Float4& b)
[code]Bool4 operator>(const Float4& a, const Float4& b)
[code]Bool4 operator>=(const Float4& a, const Float4& b)
[code]-
These functions compare each component individually. The result of each comparison is returned in a
Bool4
. Callall()
to check if the result wastrue
for all components, or callany()
to check if the result wastrue
for any component.StdOut::text() << all(Float4{1, 2, 3, 4} > Float4{0, 1, 2, 3}); // "true"
These functions are useful for testing whether a point is inside a box. See the implementation of
Box<>::contains
for an example. -
Returns the dot product of two vectors.
StdOut::text() << dot(Float4{2, 3, 1, 3}, Float4{4, 5, 1, 0}); // "24"
-
Returns the square of the length of the vector.
-
Returns the length of the vector. Equivalent to
sqrtf(this->length2())
. -
Returns
true
if the squared length of the vector is sufficiently close to 1.0. The threshold is given bythresh
. -
Returns a unit-length vector having the same direction as
this
. No safety check is performed. Float4 Float4::safeNormalized(const Float4& fallback = {1, 0, 0, 0}, float epsilon = 1e-20f) const
[code]-
Returns a unit-length vector having the same direction as
this
with safety checks. -
Returns a const reference to the first two components as a
Float2
using type punning. This should only be used as a temporary expression.Float4 v = {4, 5, 6, 7}; StdOut::text() << v.asFloat2(); // "{4, 5}"
-
Returns a const reference to the first three components as a
Float3
using type punning. This should only be used as a temporary expression.Float4 v = {4, 5, 6, 7}; StdOut::text() << v.asFloat3(); // "{4, 5, 6}"
-
Casts to
Quaternion
using type punning. This should only be used as a temporary expression. -
Converts to another 4D vector type such as
IntVec4
orInt4<s16>
.Float4 a = {4, 5, 6, 7}; IntVec4 b = a.to<IntVec4>();
-
Convenience functions for interpreting the vector as a color. The
r()
,g()
,b()
anda()
functions are aliases for thex
,y
,z
andw
components respectively.Float4 c = {1.0f, 0.8f, 0.7f, 0.5f}; StdOut::text().format("{}, {}, {}, {}", c.r(), c.g(), c.b(), c.a()); // prints "1.0, 0.8, 0.7, 0.5"
-
Returns a new vector whose components are taken from the given indices.
x
,y
,z
andw
are at indices 0, 1, 2 and 3 respectively. Similar to GLSL swizzling except that the components are specified by numeric index, and you can't use it to modify the original vector; only to read from it.Float4 v = {4, 5, 6, 0}; StdOut::text() << v.swizzle(1, 0); // "{5, 4}" StdOut::text() << v.swizzle(2, 3, 2, 1); // "{6, 0, 6, 5}"
These functions work correctly in the current version of all major compilers even though they use type punning, which is undefined behavior in standard C++.
-
Returns a copy of
v
with each component constrained to lie within the range determined by the corresponding components ofmins
andmaxs
.Float4 v = {3, 1.5f, 0, 0.5f}; StdOut::text() << clamp(v, Float4{0, 1, 2, 3}, Float4{1, 2, 3, 4}); // "{1, 1.5, 2, 3}" StdOut::text() << clamp(v, 0, 1); // "{1, 1, 0, 0.5f}"
-
Returns a vector with each component set to the absolute value of the corresponding component of
a
.StdOut::text() << abs(Float4{-2, 3, 0, -1}); // "{2, 3, 0, 1}"
-
Returns a vector with each component set to the corresponding component of
a
raised to the power of the corresponding component ofb
.StdOut::text() << pow(Float4{1, 2, 2, 3}, Float4{2, 3, 1, 2}); // "{1, 8, 2, 9}" StdOut::text() << pow(Float4{1, 2, 3, -2}, 2); // "{1, 4, 9, 4}"
-
Returns a vector with each component set to minimum of the corresponding components of
a
andb
.StdOut::text() << min(Float4{0, 1, 0, 1}, Float4{1, 0, 1, 0}); // "{0, 0, 0, 0}"
-
Returns a vector with each component set to maximum of the corresponding components of
a
andb
.StdOut::text() << max(Float4{0, 1, 0, 1}, Float4{1, 0, 1, 0}); // "{1, 1, 1, 1}"
-
Returns a vector with each component set to the rounded result of the corresponding component of
vec
. The optionalspacing
argument can be used to round to arbitrary spacings. Most precise whenspacing
is a power of 2.StdOut::text() << roundUp(Float4{-0.3f, 1.4f, 0.8f, -1.2f}); // "{0, 2, 1, -1}" StdOut::text() << roundDown(Float4{1.8f}, 0.5f); // "{1.5, 1.5, 1.5, 1.5}"
-
Returns
true
if every component ofvec
is already rounded. The optionalspacing
argument can be used to round to arbitrary spacings. Most precise whenspacing
is a power of 2.StdOut::text() << isRounded(Float4{1.5f, 0.5f, 0, 2}, 0.5f); // true