Struct hektor::Vec3

#[repr(C)]
pub struct Vec3 { /* fields omitted */ }

A 3-dimensional vector.

This is three f32 values, x, y, and z.

Internally, this data type is actually just a Vec4. The w coordinate value is simply ignored during calculations. Doing it like this is a slight waste of space, but gives much faster operation.

Methods

impl Vec3

Accessors

pub fn x(self) -> f32

Gets the x component of this vector.

pub fn y(self) -> f32

Gets the y component of this vector.

pub fn z(self) -> f32

Gets the z component of this vector.

pub fn x_mut(&mut self) -> &mut f32

&mut to the x component of this vector.

pub fn y_mut(&mut self) -> &mut f32

&mut to the y component of this vector.

pub fn z_mut(&mut self) -> &mut f32

&mut to the z component of this vector.

impl Vec3

Constructors

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

Makes a new Vec3

pub fn splat(v: f32) -> Self

Splats the given value across all components.

pub fn to_vec4(self, w: f32) -> Vec4

Extends this 4d vec into a 4d vec with the w given.

pub fn to_vec2(self) -> Vec2

Reduces this 3d vec to a 2d vec by simply forgetting the z value.

impl Vec3

Operations

pub fn dot(self, rhs: Self) -> f32

Dot product.

This is the sum of the component-wise multiplication of the two values. Order doesn't matter. Positive dot product means the vectors are pointing in the same general direction, zero dot product means they're perpendicular, and negative dot product means they have opposite general direction.

pub fn length(self) -> f32

The length / magnitude of the vector.

• sqrt(x^2 + y^2 + z^2)

pub fn length2(self) -> f32

The squared length / magnitude of the vector.

• x^2 + y^2 + z^2

pub fn normalize(self) -> Self

Generates a new vector where the length is 1.0

Or, well, as close as it can get. Floating point, and all that.

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

Determines a 3D vector that's at a right angle to the two input vectors.

• The length of the output is equal to the area of the planar section formed by the two inputs.
• The direction of the output is right-handed perpendicular to the two inputs.

impl Vec3

pub fn xx(self) -> Vec2

Swizzle: obtains the xx combination

pub fn xxx(self) -> Self

Swizzle: obtains the xxx combination

pub fn xxy(self) -> Self

Swizzle: obtains the xxy combination

pub fn xxz(self) -> Self

Swizzle: obtains the xxz combination

pub fn xy(self) -> Vec2

Swizzle: obtains the xy combination

pub fn xyx(self) -> Self

Swizzle: obtains the xyx combination

pub fn xyy(self) -> Self

Swizzle: obtains the xyy combination

pub fn xyz(self) -> Self

Swizzle: obtains the xyz combination

pub fn xz(self) -> Vec2

Swizzle: obtains the xz combination

pub fn xzx(self) -> Self

Swizzle: obtains the xzx combination

pub fn xzy(self) -> Self

Swizzle: obtains the xzy combination

pub fn xzz(self) -> Self

Swizzle: obtains the xzz combination

pub fn yx(self) -> Vec2

Swizzle: obtains the yx combination

pub fn yxx(self) -> Self

Swizzle: obtains the yxx combination

pub fn yxy(self) -> Self

Swizzle: obtains the yxy combination

pub fn yxz(self) -> Self

Swizzle: obtains the yxz combination

pub fn yy(self) -> Vec2

Swizzle: obtains the yy combination

pub fn yyx(self) -> Self

Swizzle: obtains the yyx combination

pub fn yyy(self) -> Self

Swizzle: obtains the yyy combination

pub fn yyz(self) -> Self

Swizzle: obtains the yyz combination

pub fn yz(self) -> Vec2

Swizzle: obtains the yz combination

pub fn yzx(self) -> Self

Swizzle: obtains the yzx combination

pub fn yzy(self) -> Self

Swizzle: obtains the yzy combination

pub fn yzz(self) -> Self

Swizzle: obtains the yzz combination

pub fn zx(self) -> Vec2

Swizzle: obtains the zx combination

pub fn zxx(self) -> Self

Swizzle: obtains the zxx combination

pub fn zxy(self) -> Self

Swizzle: obtains the zxy combination

pub fn zxz(self) -> Self

Swizzle: obtains the zxz combination

pub fn zy(self) -> Vec2

Swizzle: obtains the zy combination

pub fn zyx(self) -> Self

Swizzle: obtains the zyx combination

pub fn zyy(self) -> Self

Swizzle: obtains the zyy combination

pub fn zyz(self) -> Self

Swizzle: obtains the zyz combination

pub fn zz(self) -> Vec2

Swizzle: obtains the zz combination

pub fn zzx(self) -> Self

Swizzle: obtains the zzx combination

pub fn zzy(self) -> Self

Swizzle: obtains the zzy combination

pub fn zzz(self) -> Self

Swizzle: obtains the zzz combination

Trait Implementations

impl UpperExp for Vec3

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

UpperExp formats like Display, but with the upper exponent.

Passes the formatter along to the fields, so you can use any normal f32 UpperExp format arguments that you like.

impl Debug for Vec3

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

Passes the formatter along to the fields, so you can use any normal f32 Debug format arguments that you like.

impl LowerExp for Vec3

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

LowerExp formats like Display, but with the lower exponent.

Passes the formatter along to the fields, so you can use any normal f32 LowerExp format arguments that you like.

impl Display for Vec3

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

Display formats without labels like a 3-tuple.

Passes the formatter along to the fields, so you can use any normal f32 Display format arguments that you like.

impl Sub<Vec3> for Vec3

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl Sub<f32> for Vec3

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self

Performs the - operation.

impl Sub<Vec3> for f32

type Output = Vec3

The resulting type after applying the - operator.

fn sub(self, rhs: Vec3) -> Vec3

Performs the - operation.

impl PartialEq<Vec3> for Vec3

fn eq(&self, rhs: &Self) -> 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 Add<Vec3> for Vec3

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl Add<f32> for Vec3

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self

Performs the + operation.

impl Add<Vec3> for f32

type Output = Vec3

The resulting type after applying the + operator.

fn add(self, rhs: Vec3) -> Vec3

Performs the + operation.

impl Mul<f32> for Vec3

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self

Performs the * operation.

impl Mul<Vec3> for f32

type Output = Vec3

The resulting type after applying the * operator.

fn mul(self, rhs: Vec3) -> Vec3

Performs the * operation.

impl Mul<Vec3> for Vec3

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Non-mathematical component-wise multiplication (GLSL-style)

impl Mul<Vec3> for Mat3

type Output = Vec3

The resulting type after applying the * operator.

fn mul(self, v3: Vec3) -> Vec3

Performs the * operation.

impl Neg for Vec3

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl AddAssign<Vec3> for Vec3

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AddAssign<f32> for Vec3

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl SubAssign<Vec3> for Vec3

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl SubAssign<f32> for Vec3

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl MulAssign<f32> for Vec3

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign<Vec3> for Vec3

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Index<usize> for Vec3

type Output = f32

The returned type after indexing.

fn index(&self, index: usize) -> &f32

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Vec3

fn index_mut(&mut self, index: usize) -> &mut f32

Performs the mutable indexing (container[index]) operation.

impl Copy for Vec3

impl AsRef<[f32; 3]> for Vec3

fn as_ref(&self) -> &[f32; 3]

Performs the conversion.

impl AsMut<[f32; 3]> for Vec3

fn as_mut(&mut self) -> &mut [f32; 3]

Performs the conversion.

impl From<[f32; 3]> for Vec3

fn from([x, y, z]: [f32; 3]) -> Self

Performs the conversion.

impl From<Vec3> for [f32; 3]

fn from(Vec3 { v4: v4 }: Vec3) -> Self

Performs the conversion.

impl Clone for Vec3

fn clone(&self) -> Vec3

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Vec3

fn default() -> Vec3

Returns the "default value" for a type.

impl Pod for Vec3

impl Zeroable for Vec3

fn zeroed() -> Self

Calls zeroed.