Struct ico_math::Vector3

#[repr(C)]
pub struct Vector3 {
    pub data: __m128,
}

A vector of 3 floats (x,y,z).

Fields

data: __m128

Methods

impl Vector3

pub fn new(x: f32, y: f32, z: f32) -> Vector3

Construct a new vector from f32 components.

Examples

use ico_math::Vector3;
let one_two_three = Vector3::new(1.0, 2.0, 3.0);

pub fn set<T: Into<FloatVector>>(value: T) -> Vector3

Set all values of the vector to the same f32 value.

Examples

use ico_math::Vector3;
let ones = Vector3::set(1.0);

pub fn zero() -> Vector3

Construct a new vector of zeros.

Examples

use ico_math::Vector3;
let zeros = Vector3::zero();

pub fn x(self) -> FloatVector

Get the x value of the vector, broadcast to all components as a FloatVector (xxxx).

Examples

use ico_math::Vector3;
let one_two_three = Vector3::new(1.0, 2.0, 3.0);
let one = one_two_three.x();

pub fn y(self) -> FloatVector

Get the y value of the vector, broadcast to all components as a FloatVector (yyyy).

Examples

use ico_math::Vector3;
let one_two_three = Vector3::new(1.0, 2.0, 3.0);
let two = one_two_three.y();

pub fn z(self) -> FloatVector

Get the z value of the vector, broadcast to all components as a FloatVector (zzzz).

Examples

use ico_math::Vector3;
let one_two_three = Vector3::new(1.0, 2.0, 3.0);
let three = one_two_three.z();

pub fn load(raw: &RawVector_f32) -> Vector3

Load a value from aligned memory.

Examples

use ico_math::Vector3;
use ico_math::raw::RawVector_f32;
let raw = RawVector_f32{data:[0.0,1.0,2.0,0.0]};
let one_two_three = Vector3::load(&raw);

pub fn store(self, dst: &mut RawVector_f32)

Store a value to aligned memory.

Examples

use ico_math::Vector3;
use ico_math::raw::RawVector_f32;
let mut raw = RawVector_f32{data:[0.0; 4]};
let one_two_three = Vector3::new(1.0, 2.0, 3.0);
one_two_three.store(&mut raw);

pub fn set_x<T: Into<FloatVector>>(&mut self, value: T)

Set the x value of this vector, leaving the other components unchanged.

Examples

use ico_math::Vector3;
let mut one_two_three = Vector3::new(1.0, 2.0, 3.0);
one_two_three.set_x(0.5);

pub fn set_y<T: Into<FloatVector>>(&mut self, value: T)

Set the y value of this vector, leaving the other components unchanged.

Examples

use ico_math::Vector3;
let mut one_two_three = Vector3::new(1.0, 2.0, 3.0);
one_two_three.set_y(0.5);

pub fn set_z<T: Into<FloatVector>>(&mut self, value: T)

Set the z value of this vector, leaving the other components unchanged. This doesn't modify W.

Examples

use ico_math::Vector3;
let mut one_two_three = Vector3::new(1.0, 2.0, 3.0);
one_two_three.set_z(0.5);

pub fn dot(self, v2: Vector3) -> FloatVector

Compute the 3 element dot-product, and return it as a broadcast FloatVector.

pub fn cross(self, rhs: Vector3) -> Vector3

Right handed cross product.

pub fn add(self, v2: Vector3) -> Vector3

Compute the sum of two vectors and return it as a new vector.

pub fn sub(self, v2: Vector3) -> Vector3

Subtract a vector and return it as a new vector.

pub fn mul(self, v2: Vector3) -> Vector3

Multiply two vectors component-wise, and return it as a new vector.
(x1 * x2, y1 * y2, z1 * z2, w1 * w2)

pub fn div(self, v2: Vector3) -> Vector3

Divide two vectors component-wise, and return it as a new vector.
(x1 / x2, y1 / y2, z1 / z2, w1 / w2)

pub fn mul_add(self, v2: Vector3, v3: Vector3) -> Vector3

Fused Multiply Add. Result = (a * b) + c.

pub fn mul_sub(self, v2: Vector3, v3: Vector3) -> Vector3

Fused Multiply Sub. Result = (a * b) - c.

pub fn neg_mul_add(self, v2: Vector3, v3: Vector3) -> Vector3

Negated Fused Multiply Add. Result = -(a * b) + c.

pub fn neg_mul_sub(self, v2: Vector3, v3: Vector3) -> Vector3

Negated Fused Multiply Sub. Result = -(a * b) - c.

pub fn and<T: SIMDVector3>(self, v2: T) -> Vector3

Compute the bitwise AND of two vectors. This function treats inputs as binary data, and doesn't perform any conversions.

pub fn or<T: SIMDVector3>(self, v2: T) -> Vector3

Compute the bitwise OR of two vectors. This function treats inputs as binary data, and doesn't perform any conversions.

pub fn andnot<T: SIMDVector3>(self, v2: T) -> Vector3

Compute the bitwise ANDNOT of two vectors. This function treats inputs as binary data, and doesn't perform any conversions.

pub fn xor<T: SIMDVector3>(self, v2: T) -> Vector3

Compute the bitwise XOR of two vectors. This function treats inputs as binary data, and doesn't perform any conversions.

pub fn equal(self, v2: Vector3) -> Vector3Bool

Equals, computed component-wise. This compares bits, and is exact.

pub fn not_equal(self, v2: Vector3) -> Vector3Bool

NotEquals, computed component-wise. This compares bits, and is exact.

pub fn greater_equal(self, v2: Vector3) -> Vector3Bool

Greater than or equal to, computed component-wise. This compares bits, and is exact.

pub fn greater(self, v2: Vector3) -> Vector3Bool

Greater than, computed component-wise. This compares bits, and is exact.

pub fn less_equal(self, v2: Vector3) -> Vector3Bool

Less than or equal to, computed component-wise. This compares bits, and is exact.

pub fn less(self, v2: Vector3) -> Vector3Bool

Less than, computed component-wise. This compares bits, and is exact.

pub fn approx_equal(self, v2: Vector3) -> Vector3Bool

Relative and absolute epsilon comparison.
Uses machine epsilon as absolute, and 4*machine epsilon for relative. return abs(a - b) <= max(machine_epsilon, (max( abs(a), abs(b) ) * relative_epsilon); Adapted from Knuth.
https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

pub fn definitely_greater(self, v2: Vector3) -> Vector3Bool

Adapted from Knuth with an added absolute epsilon return (a - b) > max(machine_epsilon, (max( abs(a), abs(b) ) * relative_epsilon);

pub fn definitely_less(self, v2: Vector3) -> Vector3Bool

Adapted from Knuth with an added absolute epsilon return (a - b) > max(machine_epsilon, (max( abs(a), abs(b) ) * relative_epsilon);

pub fn abs(self) -> Vector3

The absolute value of each component of the vector.

pub fn copysign(self, v2: Vector3) -> Vector3

Take the magnitude of the first argument (self), and use the sign of the second argument to produce a new vector

pub fn floor(self) -> Vector3

Floor function. Returns signed 0 when applicable.

pub fn ceil(self) -> Vector3

Ceil function. Returns signed 0 when applicable.

pub fn round(self) -> Vector3

Round to nearest even function. Returns signed 0 when applicable.

pub fn truncate(self) -> Vector3

Truncate function.

pub fn floor_to_int(self) -> Vector3Int

Convert to an integer vector using the floor function.

pub fn ceil_to_int(self) -> Vector3Int

Convert to an integer vector using the ceil function.

pub fn round_to_int(self) -> Vector3Int

Convert to an integer vector using the round function.

pub fn truncate_to_int(self) -> Vector3Int

Convert to an integer vector using the truncate function.

pub fn frac(self) -> Vector3

Compute the fractional component of each component Result = X - Floor(x)

pub fn sqrt(self) -> Vector3

Compute the square root of each component

pub fn sin(self) -> Vector3

Compute the approximate sin of each component

pub fn cos(self) -> Vector3

Compute the approximate cos of each component

pub fn tan(self) -> Vector3

Compute the approximate tan of each component

pub fn acos(self) -> Vector3

Compute the approximate acos of each component

pub fn asin(self) -> Vector3

Compute the approximate asin of each component

pub fn atan2(self, x: Vector3) -> Vector3

pub fn max(self, v2: Vector3) -> Vector3

Compute the component-wise max.

pub fn min(self, v2: Vector3) -> Vector3

Compute the component-wise min.

pub fn horizontal_min(self) -> FloatVector

pub fn horizontal_max(self) -> FloatVector

pub fn select(self, v2: Vector3, mask: Vector3Bool) -> Vector3

Choose component wise between A and B based on the mask. False = A, True = B.

pub fn lerp<T: Into<FloatVector>>(self, v2: Vector3, t: T) -> Vector3

Linear interpolate from a to b based on a float.

pub fn normalize(self) -> Vector3

Normalize the vector. Returns a zero vector if the result would be infinity or NAN.

pub fn normalize_length(self) -> (Vector3, FloatVector)

Normalize the vector. Returns a zero vector if the result would be infinity or NAN. Also returns the length of the vector prior to normalization.

pub fn sqr_magnitude(self) -> FloatVector

The square magnitude of the vector. Equal to Dot(self, self).

pub fn magnitude(self) -> FloatVector

The magnitude of the vector. Equal to Sqrt(Dot(self, self)).

pub fn xxxx(self) -> Vector4

pub fn yyyy(self) -> Vector4

pub fn zzzz(self) -> Vector4

pub fn xxx(self) -> Vector3

pub fn xxy(self) -> Vector3

pub fn xxz(self) -> Vector3

pub fn xyx(self) -> Vector3

pub fn xyy(self) -> Vector3

pub fn xyz(self) -> Vector3

pub fn xzx(self) -> Vector3

pub fn xzy(self) -> Vector3

pub fn xzz(self) -> Vector3

pub fn yxx(self) -> Vector3

pub fn yxy(self) -> Vector3

pub fn yxz(self) -> Vector3

pub fn yyx(self) -> Vector3

pub fn yyy(self) -> Vector3

pub fn yyz(self) -> Vector3

pub fn yzx(self) -> Vector3

pub fn yzy(self) -> Vector3

pub fn yzz(self) -> Vector3

pub fn zxx(self) -> Vector3

pub fn zxy(self) -> Vector3

pub fn zxz(self) -> Vector3

pub fn zyx(self) -> Vector3

pub fn zyy(self) -> Vector3

pub fn zyz(self) -> Vector3

pub fn zzx(self) -> Vector3

pub fn zzy(self) -> Vector3

pub fn zzz(self) -> Vector3

Trait Implementations

impl SIMDVector3 for Vector3

fn data(self) -> __m128

fn data_i(self) -> __m128i

impl Clone for Vector3

fn clone(&self) -> Vector3

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<Vector3> for Vector2

fn from(v: Vector3) -> Vector2

Performs the conversion.

impl From<f32> for Vector3

fn from(v: f32) -> Vector3

Performs the conversion.

impl From<FloatVector> for Vector3

fn from(v: FloatVector) -> Vector3

Performs the conversion.

impl From<Vector2> for Vector3

fn from(v: Vector2) -> Vector3

Performs the conversion.

impl From<Vector4> for Vector3

fn from(v: Vector4) -> Vector3

Performs the conversion.

impl From<Vector3Int> for Vector3

fn from(v: Vector3Int) -> Vector3

Performs the conversion.

impl From<Vector3> for Vector3Int

fn from(v: Vector3) -> Vector3Int

Performs the conversion.

impl From<Vector3> for Vector4

fn from(v: Vector3) -> Vector4

Performs the conversion.

impl PartialEq<Vector3> for Vector3

fn eq(&self, other: &Vector3) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Copy for Vector3

impl Debug for Vector3

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Into<FloatVector>> Div<T> for Vector3

type Output = Vector3

The resulting type after applying the / operator.

fn div(self, _rhs: T) -> Vector3

Performs the / operation.

impl Div<Vector3> for FloatVector

type Output = Vector3

The resulting type after applying the / operator.

fn div(self: FloatVector, _rhs: Vector3) -> Vector3

Performs the / operation.

impl Add<Vector3> for Vector3

type Output = Vector3

The resulting type after applying the + operator.

fn add(self, _rhs: Vector3) -> Vector3

Performs the + operation.

impl Sub<Vector3> for Vector3

type Output = Vector3

The resulting type after applying the - operator.

fn sub(self, _rhs: Vector3) -> Vector3

Performs the - operation.

impl Mul<Vector3> for Quaternion

type Output = Vector3

The resulting type after applying the * operator.

fn mul(self, _rhs: Vector3) -> Vector3

Performs the * operation.

impl<T: Into<FloatVector>> Mul<T> for Vector3

type Output = Vector3

The resulting type after applying the * operator.

fn mul(self, _rhs: T) -> Vector3

Performs the * operation.

impl Mul<Vector3> for FloatVector

type Output = Vector3

The resulting type after applying the * operator.

fn mul(self: FloatVector, _rhs: Vector3) -> Vector3

Performs the * operation.

impl Neg for Vector3

type Output = Vector3

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl AddAssign<Vector3> for Vector3

fn add_assign(&mut self, other: Vector3)

Performs the += operation.

impl SubAssign<Vector3> for Vector3

fn sub_assign(&mut self, other: Vector3)

Performs the -= operation.

impl<T: Into<FloatVector>> MulAssign<T> for Vector3

fn mul_assign(&mut self, _rhs: T)

Performs the *= operation.

impl<T: Into<FloatVector>> DivAssign<T> for Vector3

fn div_assign(&mut self, _rhs: T)

Performs the /= operation.