pub struct Vec3<T> {
pub x: T,
pub y: T,
pub z: T,
}
Expand description
A three-component Euclidean vector useful for linear algebra computation in game development and 3D rendering.
Fields§
§x: T
The X/first component of the vector.
y: T
The Y/second component of the vector.
z: T
The Z/third component of the vector.
Implementations§
source§impl<T> Vec3<T>where
T: Copy + Debug + PartialEq + Default + Sub<Output = T> + Mul<Output = T> + Add<Output = T> + Neg<Output = T> + PartialOrd,
impl<T> Vec3<T>where T: Copy + Debug + PartialEq + Default + Sub<Output = T> + Mul<Output = T> + Add<Output = T> + Neg<Output = T> + PartialOrd,
sourcepub fn new(x: T, y: T, z: T) -> Vec3<T>
pub fn new(x: T, y: T, z: T) -> Vec3<T>
Constructs a new Vec3<T>
from three initial values.
Examples
use gamemath::Vec3;
let v = Vec3::new(1.0, 5.0, 23.0);
assert_eq!(v.x, 1.0);
assert_eq!(v.y, 5.0);
assert_eq!(v.z, 23.0);
sourcepub fn dot(&self, right: Vec3<T>) -> T
pub fn dot(&self, right: Vec3<T>) -> T
Calculates the dot/scalar product of two Vec3<T>
s.
The calling object is considered the left value and the argument object is considered the right value.
Examples
use gamemath::Vec3;
let v1 = Vec3::new(1.0, 2.0, 3.0);
let v2 = Vec3::new(4.0, 5.0, 6.0);
assert_eq!(v1.dot(v2), 32.0);
assert_eq!(v2.dot(v1), 32.0);
sourcepub fn cross(&self, right: Vec3<T>) -> Vec3<T>
pub fn cross(&self, right: Vec3<T>) -> Vec3<T>
Calculates the cross/vector product of two Vec3<T>
s.
The calling object is considered the left value and the argument object is considered the right value.
Examples
use gamemath::Vec3;
let v1 = Vec3::new(1.0, 2.0, 3.0);
let v2 = Vec3::new(4.0, 5.0, 6.0);
assert_eq!(v1.cross(v2), Vec3::new(-3.0, 6.0, -3.0));
assert_eq!(v2.cross(v1), Vec3::new(3.0, -6.0, 3.0));
sourcepub fn fill(&mut self, value: T)
pub fn fill(&mut self, value: T)
Fills all components of the calling Vec3<T>
with the provided value.
Examples
use gamemath::Vec3;
let mut v = Vec3::new(0.0, 0.0, 0.0);
v.fill(6.0);
assert_eq!(v, Vec3::new(6.0, 6.0, 6.0));
sourcepub fn length_squared(&self) -> T
pub fn length_squared(&self) -> T
Calculates the squared length/magnitude/norm of a Vec3<T>
.
This saves an expensive square root calculation compared to calculating the actual length,
and comparing two squared lengths can therefore often be cheaper than, and yield the same
result as, computing two real lengths.
Also useful for data types that does not implement a square root function, i.e. non-floating-point data types.
Examples
use gamemath::Vec3;
let v = Vec3::new(1.0, 2.0, 3.0);
assert_eq!(v.length_squared(), 14.0);
sourcepub fn manhattan_distance(&self, right: Vec3<T>) -> T
pub fn manhattan_distance(&self, right: Vec3<T>) -> T
Calculates and returns the manhattan distance between the two points pointed to by two
Vec3<T>
objects.
Examples
use gamemath::Vec3;
let v1 = Vec3::new(1.0, 2.0, 3.0);
let v2 = Vec3::new(2.0, 4.0, 6.0);
assert_eq!(v1.manhattan_distance(v2), 6.0);
source§impl Vec3<f32>
impl Vec3<f32>
sourcepub fn length(&self) -> f32
pub fn length(&self) -> f32
Calculates the real length/magnitude/norm of a Vec3<f32>
.
This results in an expensive square root calculation, and you might want to consider using
a squared length instead when possible.
Examples
use gamemath::Vec3;
let v = Vec3::new(1.0_f32, 4.0_f32, 8.0_f32);
assert_eq!(v.length(), 9.0_f32);
sourcepub fn normalized(&self) -> Vec3<f32>
pub fn normalized(&self) -> Vec3<f32>
Calculates and returns the unit vector representation of a Vec3<f32>
.
This results in an an expensive square root calculation.
Examples
use gamemath::Vec3;
let v = Vec3::new(9.0_f32, 12.0_f32, 20.0_f32);
assert_eq!(v.normalized(), Vec3::new(0.36_f32, 0.48_f32, 0.8_f32));
sourcepub fn normalize(&mut self)
pub fn normalize(&mut self)
Normalizes a Vec3<f32>
into its unit vector representation.
This results in an an expensive square root calculation.
Examples
use gamemath::Vec3;
let mut v = Vec3::new(9.0_f32, 12.0_f32, 20.0_f32);
v.normalize();
assert_eq!(v, Vec3::new(0.36_f32, 0.48_f32, 0.8_f32));
source§impl Vec3<f64>
impl Vec3<f64>
sourcepub fn length(&self) -> f64
pub fn length(&self) -> f64
Calculates the real length/magnitude/norm of a Vec3<f64>
.
This results in an expensive square root calculation, and you might want to consider using
a squared length instead when possible.
Examples
use gamemath::Vec3;
let v = Vec3::new(1.0_f64, 4.0_f64, 8.0_f64);
assert_eq!(v.length(), 9.0_f64);
sourcepub fn normalized(&self) -> Vec3<f64>
pub fn normalized(&self) -> Vec3<f64>
Calculates and returns the unit vector representation of a Vec3<f64>
.
This results in an an expensive square root calculation.
Examples
use gamemath::Vec3;
let v = Vec3::new(9.0_f64, 12.0_f64, 20.0_f64);
assert_eq!(v.normalized(), Vec3::new(0.36_f64, 0.48_f64, 0.8_f64));
sourcepub fn normalize(&mut self)
pub fn normalize(&mut self)
Normalizes a Vec3<f64>
into its unit vector representation.
This results in an an expensive square root calculation.
Examples
use gamemath::Vec3;
let mut v = Vec3::new(9.0_f64, 12.0_f64, 20.0_f64);
v.normalize();
assert_eq!(v, Vec3::new(0.36_f64, 0.48_f64, 0.8_f64));
Trait Implementations§
source§impl<T: AddAssign> AddAssign for Vec3<T>
impl<T: AddAssign> AddAssign for Vec3<T>
source§fn add_assign(&mut self, right: Vec3<T>)
fn add_assign(&mut self, right: Vec3<T>)
+=
operation. Read moresource§impl<T: MulAssign + Copy> MulAssign<T> for Vec3<T>
impl<T: MulAssign + Copy> MulAssign<T> for Vec3<T>
source§fn mul_assign(&mut self, right: T)
fn mul_assign(&mut self, right: T)
*=
operation. Read moresource§impl<T: PartialEq> PartialEq for Vec3<T>
impl<T: PartialEq> PartialEq for Vec3<T>
source§impl<T: SubAssign> SubAssign for Vec3<T>
impl<T: SubAssign> SubAssign for Vec3<T>
source§fn sub_assign(&mut self, right: Vec3<T>)
fn sub_assign(&mut self, right: Vec3<T>)
-=
operation. Read more