Struct Vec3 

#[repr(C)]
pub struct Vec3 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

A 3-dimensional vector with f32 components.

Vec3 is the workhorse for positions, directions, and scales throughout the engine. It supports the usual arithmetic operators plus dot, cross, length, and normalize.

Examples

use khora_core::math::Vec3;

// Component-wise arithmetic and scalar multiplication.
let a = Vec3::new(1.0, 2.0, 3.0);
let b = Vec3::new(4.0, 5.0, 6.0);
assert_eq!(a + b, Vec3::new(5.0, 7.0, 9.0));
assert_eq!(a * 2.0, Vec3::new(2.0, 4.0, 6.0));

// Dot product and the right-handed cross product of the basis axes.
assert_eq!(Vec3::X.dot(Vec3::Y), 0.0);
assert_eq!(Vec3::X.cross(Vec3::Y), Vec3::Z);

// Normalizing yields a unit-length direction.
let dir = Vec3::new(0.0, 3.0, 0.0).normalize();
assert_eq!(dir, Vec3::Y);

Fields

x: f32

The x component of the vector.

y: f32

The y component of the vector.

z: f32

The z component of the vector.

Implementations

impl Vec3

pub const ZERO: Vec3

A vector with all components set to 0.0.

pub const ONE: Vec3

A vector with all components set to 1.0.

pub const X: Vec3

The unit vector pointing along the positive X-axis.

pub const Y: Vec3

The unit vector pointing along the positive Y-axis.

pub const Z: Vec3

The unit vector pointing along the positive Z-axis.

pub const NEG_X: Vec3

The unit vector pointing along the negative X-axis.

pub const NEG_Y: Vec3

The unit vector pointing along the negative Y-axis.

pub const NEG_Z: Vec3

The unit vector pointing along the negative Z-axis.

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

Creates a new Vec3 with the specified components.

pub const fn abs(self) -> Vec3

Returns a new vector with the absolute value of each component.

pub fn max_element(self) -> f32

Returns the largest component of the vector (signed).

Useful for major-axis selection in cubemap sampling and bounding-box checks. Note that this is not the absolute maximum — for that, call .abs().max_element().

pub fn min_element(self) -> f32

Returns the smallest component of the vector (signed).

pub fn length_squared(&self) -> f32

Calculates the squared length (magnitude) of the vector.

pub fn length(&self) -> f32

Calculates the length (magnitude) of the vector.

pub fn normalize(&self) -> Vec3

Returns a normalized version of the vector with a length of 1.

pub fn dot(&self, other: Vec3) -> f32

Calculates the dot product of this vector and another.

pub fn cross(&self, other: Vec3) -> Vec3

Computes the cross product of this vector and another.

pub fn distance_squared(&self, other: Vec3) -> f32

Calculates the squared distance between this vector and another.

pub fn distance(&self, other: Vec3) -> f32

Calculates the distance between this vector and another.

pub fn lerp(start: Vec3, end: Vec3, t: f32) -> Vec3

Performs a linear interpolation between two vectors.

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

Retrieves a component of the vector by its index.

Panics

Panics if index is not 0, 1, or 2.

Trait Implementations

impl Add for Vec3

fn add(self, rhs: Vec3) -> <Vec3 as Add>::Output

Adds two vectors component-wise.

type Output = Vec3

The resulting type after applying the + operator.

impl<'__de, __Context> BorrowDecode<'__de, __Context> for Vec3

fn borrow_decode<__D>(decoder: &mut __D) -> Result<Vec3, DecodeError>

where __D: BorrowDecoder<'__de, Context = __Context>,

Attempt to decode this type with the given BorrowDecode.

impl Clone for Vec3

fn clone(&self) -> Vec3

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Vec3

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for Vec3

fn decode<__D>(decoder: &mut __D) -> Result<Vec3, DecodeError>

where __D: Decoder<Context = __Context>,

Attempt to decode this type with the given Decode.

impl Default for Vec3

fn default() -> Vec3

Returns Vec3::ZERO.

impl<'de> Deserialize<'de> for Vec3

fn deserialize<__D>( __deserializer: __D, ) -> Result<Vec3, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<f32> for Vec3

fn div(self, rhs: f32) -> <Vec3 as Div<f32>>::Output

Divides the vector by a scalar.

type Output = Vec3

The resulting type after applying the / operator.

impl Encode for Vec3

fn encode<__E>(&self, encoder: &mut __E) -> Result<(), EncodeError>

where __E: Encoder,

Encode a given type.

impl Index<usize> for Vec3

fn index(&self, index: usize) -> &<Vec3 as Index<usize>>::Output

Allows accessing a vector component by index.

Panics

Panics if index is not 0, 1, or 2.

type Output = f32

The returned type after indexing.

impl IndexMut<usize> for Vec3

fn index_mut(&mut self, index: usize) -> &mut <Vec3 as Index<usize>>::Output

Allows mutably accessing a vector component by index.

Panics

Panics if index is not 0, 1, or 2.

impl Mul<Vec3> for Mat3

fn mul(self, v: Vec3) -> <Mat3 as Mul<Vec3>>::Output

Transforms a Vec3 by this matrix.

type Output = Vec3

The resulting type after applying the * operator.

impl Mul<Vec3> for Quaternion

fn mul(self, rhs: Vec3) -> <Quaternion as Mul<Vec3>>::Output

Rotates a Vec3 by this quaternion.

type Output = Vec3

The resulting type after applying the * operator.

impl Mul<f32> for Vec3

fn mul(self, rhs: f32) -> <Vec3 as Mul<f32>>::Output

Multiplies the vector by a scalar.

type Output = Vec3

The resulting type after applying the * operator.

impl Mul for Vec3

fn mul(self, rhs: Vec3) -> <Vec3 as Mul>::Output

Multiplies two vectors component-wise.

type Output = Vec3

The resulting type after applying the * operator.

impl Neg for Vec3

fn neg(self) -> <Vec3 as Neg>::Output

Negates the vector.

type Output = Vec3

The resulting type after applying the - operator.

impl PartialEq for Vec3

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Vec3

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Vec3

fn sub(self, rhs: Vec3) -> <Vec3 as Sub>::Output

Subtracts two vectors component-wise.

type Output = Vec3

The resulting type after applying the - operator.

impl Zeroable for Vec3

fn zeroed() -> Self

Calls zeroed.

impl Copy for Vec3

impl Pod for Vec3

impl StructuralPartialEq for Vec3