Struct QVec3 

pub struct QVec3<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8>(/* private fields */);

Three components of one dimension, stored in SI base units.

Implementations

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> QVec3<L, M, T, I, K, N, J>

pub const ZERO: QVec3<L, M, T, I, K, N, J>

The zero vector, in whatever dimension this is.

pub fn from_si(v: DVec3) -> QVec3<L, M, T, I, K, N, J>

Wrap a vector already in SI base units.

pub fn to_si(self) -> DVec3

The components in SI base units.

pub fn new( x: Qty<L, M, T, I, K, N, J>, y: Qty<L, M, T, I, K, N, J>, z: Qty<L, M, T, I, K, N, J>, ) -> QVec3<L, M, T, I, K, N, J>

From three quantities of the same dimension.

pub fn splat(v: Qty<L, M, T, I, K, N, J>) -> QVec3<L, M, T, I, K, N, J>

The same quantity in all three components.

pub fn x(self) -> Qty<L, M, T, I, K, N, J>

The x component, carrying the dimension with it.

pub fn y(self) -> Qty<L, M, T, I, K, N, J>

The y component, carrying the dimension with it.

pub fn z(self) -> Qty<L, M, T, I, K, N, J>

The z component, carrying the dimension with it.

pub fn length(self) -> Qty<L, M, T, I, K, N, J>

Magnitude, which keeps the dimension.

pub fn normalize(self) -> DVec3

Which way it points — a pure number, because a direction is a length over a length. Zero-length vectors give zero rather than a NaN.

pub fn along(self, direction: DVec3) -> Qty<L, M, T, I, K, N, J>

The component along a unit direction. Projection does not change the dimension, which is why this one is expressible and dot is not.

pub fn perpendicular_to(self, direction: DVec3) -> QVec3<L, M, T, I, K, N, J>

The part of this vector perpendicular to a unit direction.

pub fn is_finite(self) -> bool

Whether every component is neither infinite nor NaN.

pub fn lerp( self, other: QVec3<L, M, T, I, K, N, J>, t: f64, ) -> QVec3<L, M, T, I, K, N, J>

Straight-line interpolation, t = 0 here and t = 1 there.

Not clamped, so t outside the unit interval extrapolates. Useful for a strobe sampling between two recorded states, and wrong for anything that should not leave the segment.

impl QVec3<1, 0, 0, 0, 0, 0, 0>

pub fn mm(x: f64, y: f64, z: f64) -> QVec3<1, 0, 0, 0, 0, 0, 0>

Millimetres.

pub fn m(x: f64, y: f64, z: f64) -> QVec3<1, 0, 0, 0, 0, 0, 0>

Metres.

pub fn in_mm(self) -> DVec3

As millimetres.

impl QVec3<1, 0, -1, 0, 0, 0, 0>

pub fn mm_per_s(x: f64, y: f64, z: f64) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Millimetres per second.

pub fn m_per_s(x: f64, y: f64, z: f64) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Metres per second.

Trait Implementations

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Add for QVec3<L, M, T, I, K, N, J>

type Output = QVec3<L, M, T, I, K, N, J>

The resulting type after applying the + operator.

fn add(self, rhs: QVec3<L, M, T, I, K, N, J>) -> QVec3<L, M, T, I, K, N, J>

Performs the + operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> AddAssign for QVec3<L, M, T, I, K, N, J>

fn add_assign(&mut self, rhs: QVec3<L, M, T, I, K, N, J>)

Performs the += operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Clone for QVec3<L, M, T, I, K, N, J>

fn clone(&self) -> QVec3<L, M, T, I, K, N, J>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Copy for QVec3<L, M, T, I, K, N, J>

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Debug for QVec3<L, M, T, I, K, N, J>

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

Formats the value using the given formatter.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Default for QVec3<L, M, T, I, K, N, J>

fn default() -> QVec3<L, M, T, I, K, N, J>

Returns the “default value” for a type.

impl<'de, const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Deserialize<'de> for QVec3<L, M, T, I, K, N, J>

fn deserialize<D>( d: D, ) -> Result<QVec3<L, M, T, I, K, N, J>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 0, 0, 0, 0, 0, 0>

type Output = QVec3<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 0, -1, 0, 0, 0, 0>

type Output = QVec3<1, 0, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 0, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 1, -1, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, 0, 0, 0, 0, 0>> for QVec3<1, 1, -1, 0, 0, 0, 0>

type Output = QVec3<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 1, 0, 0, 0, 0, 0>) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, 0, 0, 0, 0, 0>> for QVec3<1, 1, -2, 0, 0, 0, 0>

type Output = QVec3<1, 0, -2, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 1, 0, 0, 0, 0, 0>) -> QVec3<1, 0, -2, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, -1, 0, 0, 0, 0>> for QVec3<1, 1, -2, 0, 0, 0, 0>

type Output = QVec3<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 1, -1, 0, 0, 0, 0>) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Performs the / operation.

impl Div<Qty<0, 1, -2, 0, 0, 0, 0>> for QVec3<1, 1, -2, 0, 0, 0, 0>

type Output = QVec3<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the / operator.

fn div(self, k: Qty<0, 1, -2, 0, 0, 0, 0>) -> QVec3<1, 0, 0, 0, 0, 0, 0>

Performs the / operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Div<f64> for QVec3<L, M, T, I, K, N, J>

type Output = QVec3<L, M, T, I, K, N, J>

The resulting type after applying the / operator.

fn div(self, k: f64) -> QVec3<L, M, T, I, K, N, J>

Performs the / operation.

impl Mul<QVec3<1, 0, 0, 0, 0, 0, 0>> for Qty<0, 1, -2, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, 0, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, -1, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = QVec3<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, -1, 0, 0, 0, 0>) -> QVec3<1, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, -1, 0, 0, 0, 0>> for Qty<0, 1, 0, 0, 0, 0, 0>

type Output = QVec3<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, -1, 0, 0, 0, 0>) -> QVec3<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, -1, 0, 0, 0, 0>> for Qty<0, 1, -1, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, -1, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, -2, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = QVec3<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, -2, 0, 0, 0, 0>) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 0, -2, 0, 0, 0, 0>> for Qty<0, 1, 0, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 0, -2, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<QVec3<1, 1, -2, 0, 0, 0, 0>> for Qty<0, 0, 1, 0, 0, 0, 0>

type Output = QVec3<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, v: QVec3<1, 1, -2, 0, 0, 0, 0>) -> QVec3<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 0, -1, 0, 0, 0, 0>

type Output = QVec3<1, 0, 0, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 0, 0, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 0, -2, 0, 0, 0, 0>

type Output = QVec3<1, 0, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 0, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 0, 1, 0, 0, 0, 0>> for QVec3<1, 1, -2, 0, 0, 0, 0>

type Output = QVec3<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 0, 1, 0, 0, 0, 0>) -> QVec3<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, 0, 0, 0, 0, 0>> for QVec3<1, 0, -1, 0, 0, 0, 0>

type Output = QVec3<1, 1, -1, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 1, 0, 0, 0, 0, 0>) -> QVec3<1, 1, -1, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, 0, 0, 0, 0, 0>> for QVec3<1, 0, -2, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 1, 0, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, -1, 0, 0, 0, 0>> for QVec3<1, 0, -1, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 1, -1, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl Mul<Qty<0, 1, -2, 0, 0, 0, 0>> for QVec3<1, 0, 0, 0, 0, 0, 0>

type Output = QVec3<1, 1, -2, 0, 0, 0, 0>

The resulting type after applying the * operator.

fn mul(self, k: Qty<0, 1, -2, 0, 0, 0, 0>) -> QVec3<1, 1, -2, 0, 0, 0, 0>

Performs the * operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Mul<f64> for QVec3<L, M, T, I, K, N, J>

type Output = QVec3<L, M, T, I, K, N, J>

The resulting type after applying the * operator.

fn mul(self, k: f64) -> QVec3<L, M, T, I, K, N, J>

Performs the * operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Neg for QVec3<L, M, T, I, K, N, J>

type Output = QVec3<L, M, T, I, K, N, J>

The resulting type after applying the - operator.

fn neg(self) -> QVec3<L, M, T, I, K, N, J>

Performs the unary - operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> PartialEq for QVec3<L, M, T, I, K, N, J>

fn eq(&self, other: &QVec3<L, M, T, I, K, N, J>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Serialize for QVec3<L, M, T, I, K, N, J>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> StructuralPartialEq for QVec3<L, M, T, I, K, N, J>

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> Sub for QVec3<L, M, T, I, K, N, J>

type Output = QVec3<L, M, T, I, K, N, J>

The resulting type after applying the - operator.

fn sub(self, rhs: QVec3<L, M, T, I, K, N, J>) -> QVec3<L, M, T, I, K, N, J>

Performs the - operation.

impl<const L: i8, const M: i8, const T: i8, const I: i8, const K: i8, const N: i8, const J: i8> SubAssign for QVec3<L, M, T, I, K, N, J>

fn sub_assign(&mut self, rhs: QVec3<L, M, T, I, K, N, J>)

Performs the -= operation.