Skip to main content

Vec4

aphyn

Struct Vec4 

#[repr(C)]
pub struct Vec4<T> {
    pub x: T,
    pub y: T,
    pub z: T,
    pub w: T,
}

Fields§

§x: T§y: T§z: T§w: T

Implementations§

§

impl<T> Vec4<T>

pub const fn new(x: T, y: T, z: T, w: T) -> Vec4<T>

pub const fn as_array(&self) -> &[T; 4]

pub const fn as_array_mut(&mut self) -> &mut [T; 4]

pub const fn from_array_ref(a: &[T; 4]) -> &Vec4<T>

pub const fn from_array_mut(a: &mut [T; 4]) -> &mut Vec4<T>

pub const fn into_array(self) -> [T; 4]

pub const fn from_array(a: [T; 4]) -> Vec4<T>

pub fn from_fn(f: impl FnMut(usize) -> T) -> Vec4<T>

pub fn map<U>(self, f: impl Fn(T) -> U) -> Vec4<U>

pub fn zip<U, R>(self, rhs: Vec4<U>, f: impl Fn(&T, &U) -> R) -> Vec4<R>

§

impl<T> Vec4<T>
where T: Copy,

pub const fn splat(v: T) -> Vec4<T>

pub fn zip_copied<U, R>(self, rhs: Vec4<U>, f: impl Fn(T, U) -> R) -> Vec4<R>
where U: Copy,

§

impl<T> Vec4<T>
where T: Clone,

pub fn splat_cloned(v: &T) -> Vec4<T>

§

impl<T> Vec4<T>
where T: Primitive,

pub const fn into_array_const(self) -> [T; 4]

pub const fn from_array_const(a: [T; 4]) -> Vec4<T>

§

impl<T> Vec4<T>
where T: Number,

pub fn sum(self) -> T

pub fn dot(self, rhs: Vec4<T>) -> T

pub fn length_sq(self) -> T

pub fn length(self) -> f64

pub fn normalized(self) -> Vec4<T>

pub fn lerp(self, b: Vec4<T>, t: T) -> Vec4<T>

pub fn lerp_separately(self, b: Vec4<T>, t: Vec4<T>) -> Vec4<T>

pub fn inv_lerp(self, b: Vec4<T>, x: Vec4<T>) -> T

§

impl Vec4<bool>

pub const fn all(self) -> bool

pub const fn any(self) -> bool

§

impl<T> Vec4<T>
where T: Copy,

pub fn xx(&self) -> Vec2<T>

pub fn xy(&self) -> Vec2<T>

pub fn xz(&self) -> Vec2<T>

pub fn xw(&self) -> Vec2<T>

pub fn xn(&self, y: T) -> Vec2<T>

pub fn yx(&self) -> Vec2<T>

pub fn yy(&self) -> Vec2<T>

pub fn yz(&self) -> Vec2<T>

pub fn yw(&self) -> Vec2<T>

pub fn yn(&self, y: T) -> Vec2<T>

pub fn zx(&self) -> Vec2<T>

pub fn zy(&self) -> Vec2<T>

pub fn zz(&self) -> Vec2<T>

pub fn zw(&self) -> Vec2<T>

pub fn zn(&self, y: T) -> Vec2<T>

pub fn wx(&self) -> Vec2<T>

pub fn wy(&self) -> Vec2<T>

pub fn wz(&self) -> Vec2<T>

pub fn ww(&self) -> Vec2<T>

pub fn wn(&self, y: T) -> Vec2<T>

pub fn nx(&self, x: T) -> Vec2<T>

pub fn ny(&self, x: T) -> Vec2<T>

pub fn nz(&self, x: T) -> Vec2<T>

pub fn nw(&self, x: T) -> Vec2<T>

§

impl<T> Vec4<T>
where T: Copy,

pub fn xxx(&self) -> Vec3<T>

pub fn xxy(&self) -> Vec3<T>

pub fn xxz(&self) -> Vec3<T>

pub fn xxw(&self) -> Vec3<T>

pub fn xxn(&self, z: T) -> Vec3<T>

pub fn xyx(&self) -> Vec3<T>

pub fn xyy(&self) -> Vec3<T>

pub fn xyz(&self) -> Vec3<T>

pub fn xyw(&self) -> Vec3<T>

pub fn xyn(&self, z: T) -> Vec3<T>

pub fn xzx(&self) -> Vec3<T>

pub fn xzy(&self) -> Vec3<T>

pub fn xzz(&self) -> Vec3<T>

pub fn xzw(&self) -> Vec3<T>

pub fn xzn(&self, z: T) -> Vec3<T>

pub fn xwx(&self) -> Vec3<T>

pub fn xwy(&self) -> Vec3<T>

pub fn xwz(&self) -> Vec3<T>

pub fn xww(&self) -> Vec3<T>

pub fn xwn(&self, z: T) -> Vec3<T>

pub fn xnx(&self, y: T) -> Vec3<T>

pub fn xny(&self, y: T) -> Vec3<T>

pub fn xnz(&self, y: T) -> Vec3<T>

pub fn xnw(&self, y: T) -> Vec3<T>

pub fn xnn(&self, y: T, z: T) -> Vec3<T>

pub fn yxx(&self) -> Vec3<T>

pub fn yxy(&self) -> Vec3<T>

pub fn yxz(&self) -> Vec3<T>

pub fn yxw(&self) -> Vec3<T>

pub fn yxn(&self, z: T) -> Vec3<T>

pub fn yyx(&self) -> Vec3<T>

pub fn yyy(&self) -> Vec3<T>

pub fn yyz(&self) -> Vec3<T>

pub fn yyw(&self) -> Vec3<T>

pub fn yyn(&self, z: T) -> Vec3<T>

pub fn yzx(&self) -> Vec3<T>

pub fn yzy(&self) -> Vec3<T>

pub fn yzz(&self) -> Vec3<T>

pub fn yzw(&self) -> Vec3<T>

pub fn yzn(&self, z: T) -> Vec3<T>

pub fn ywx(&self) -> Vec3<T>

pub fn ywy(&self) -> Vec3<T>

pub fn ywz(&self) -> Vec3<T>

pub fn yww(&self) -> Vec3<T>

pub fn ywn(&self, z: T) -> Vec3<T>

pub fn ynx(&self, y: T) -> Vec3<T>

pub fn yny(&self, y: T) -> Vec3<T>

pub fn ynz(&self, y: T) -> Vec3<T>

pub fn ynw(&self, y: T) -> Vec3<T>

pub fn ynn(&self, y: T, z: T) -> Vec3<T>

pub fn zxx(&self) -> Vec3<T>

pub fn zxy(&self) -> Vec3<T>

pub fn zxz(&self) -> Vec3<T>

pub fn zxw(&self) -> Vec3<T>

pub fn zxn(&self, z: T) -> Vec3<T>

pub fn zyx(&self) -> Vec3<T>

pub fn zyy(&self) -> Vec3<T>

pub fn zyz(&self) -> Vec3<T>

pub fn zyw(&self) -> Vec3<T>

pub fn zyn(&self, z: T) -> Vec3<T>

pub fn zzx(&self) -> Vec3<T>

pub fn zzy(&self) -> Vec3<T>

pub fn zzz(&self) -> Vec3<T>

pub fn zzw(&self) -> Vec3<T>

pub fn zzn(&self, z: T) -> Vec3<T>

pub fn zwx(&self) -> Vec3<T>

pub fn zwy(&self) -> Vec3<T>

pub fn zwz(&self) -> Vec3<T>

pub fn zww(&self) -> Vec3<T>

pub fn zwn(&self, z: T) -> Vec3<T>

pub fn znx(&self, y: T) -> Vec3<T>

pub fn zny(&self, y: T) -> Vec3<T>

pub fn znz(&self, y: T) -> Vec3<T>

pub fn znw(&self, y: T) -> Vec3<T>

pub fn znn(&self, y: T, z: T) -> Vec3<T>

pub fn wxx(&self) -> Vec3<T>

pub fn wxy(&self) -> Vec3<T>

pub fn wxz(&self) -> Vec3<T>

pub fn wxw(&self) -> Vec3<T>

pub fn wxn(&self, z: T) -> Vec3<T>

pub fn wyx(&self) -> Vec3<T>

pub fn wyy(&self) -> Vec3<T>

pub fn wyz(&self) -> Vec3<T>

pub fn wyw(&self) -> Vec3<T>

pub fn wyn(&self, z: T) -> Vec3<T>

pub fn wzx(&self) -> Vec3<T>

pub fn wzy(&self) -> Vec3<T>

pub fn wzz(&self) -> Vec3<T>

pub fn wzw(&self) -> Vec3<T>

pub fn wzn(&self, z: T) -> Vec3<T>

pub fn wwx(&self) -> Vec3<T>

pub fn wwy(&self) -> Vec3<T>

pub fn wwz(&self) -> Vec3<T>

pub fn www(&self) -> Vec3<T>

pub fn wwn(&self, z: T) -> Vec3<T>

pub fn wnx(&self, y: T) -> Vec3<T>

pub fn wny(&self, y: T) -> Vec3<T>

pub fn wnz(&self, y: T) -> Vec3<T>

pub fn wnw(&self, y: T) -> Vec3<T>

pub fn wnn(&self, y: T, z: T) -> Vec3<T>

pub fn nxx(&self, x: T) -> Vec3<T>

pub fn nxy(&self, x: T) -> Vec3<T>

pub fn nxz(&self, x: T) -> Vec3<T>

pub fn nxw(&self, x: T) -> Vec3<T>

pub fn nxn(&self, x: T, z: T) -> Vec3<T>

pub fn nyx(&self, x: T) -> Vec3<T>

pub fn nyy(&self, x: T) -> Vec3<T>

pub fn nyz(&self, x: T) -> Vec3<T>

pub fn nyw(&self, x: T) -> Vec3<T>

pub fn nyn(&self, x: T, z: T) -> Vec3<T>

pub fn nzx(&self, x: T) -> Vec3<T>

pub fn nzy(&self, x: T) -> Vec3<T>

pub fn nzz(&self, x: T) -> Vec3<T>

pub fn nzw(&self, x: T) -> Vec3<T>

pub fn nzn(&self, x: T, z: T) -> Vec3<T>

pub fn nwx(&self, x: T) -> Vec3<T>

pub fn nwy(&self, x: T) -> Vec3<T>

pub fn nwz(&self, x: T) -> Vec3<T>

pub fn nww(&self, x: T) -> Vec3<T>

pub fn nwn(&self, x: T, z: T) -> Vec3<T>

pub fn nnx(&self, x: T, y: T) -> Vec3<T>

pub fn nny(&self, x: T, y: T) -> Vec3<T>

pub fn nnz(&self, x: T, y: T) -> Vec3<T>

pub fn nnw(&self, x: T, y: T) -> Vec3<T>

§

impl<T> Vec4<T>
where T: Copy,

pub fn xxxx(&self) -> Vec4<T>

pub fn xxxy(&self) -> Vec4<T>

pub fn xxxz(&self) -> Vec4<T>

pub fn xxxw(&self) -> Vec4<T>

pub fn xxxn(&self, w: T) -> Vec4<T>

pub fn xxyx(&self) -> Vec4<T>

pub fn xxyy(&self) -> Vec4<T>

pub fn xxyz(&self) -> Vec4<T>

pub fn xxyw(&self) -> Vec4<T>

pub fn xxyn(&self, w: T) -> Vec4<T>

pub fn xxzx(&self) -> Vec4<T>

pub fn xxzy(&self) -> Vec4<T>

pub fn xxzz(&self) -> Vec4<T>

pub fn xxzw(&self) -> Vec4<T>

pub fn xxzn(&self, w: T) -> Vec4<T>

pub fn xxwx(&self) -> Vec4<T>

pub fn xxwy(&self) -> Vec4<T>

pub fn xxwz(&self) -> Vec4<T>

pub fn xxww(&self) -> Vec4<T>

pub fn xxwn(&self, w: T) -> Vec4<T>

pub fn xxnx(&self, z: T) -> Vec4<T>

pub fn xxny(&self, z: T) -> Vec4<T>

pub fn xxnz(&self, z: T) -> Vec4<T>

pub fn xxnw(&self, z: T) -> Vec4<T>

pub fn xxnn(&self, z: T, w: T) -> Vec4<T>

pub fn xyxx(&self) -> Vec4<T>

pub fn xyxy(&self) -> Vec4<T>

pub fn xyxz(&self) -> Vec4<T>

pub fn xyxw(&self) -> Vec4<T>

pub fn xyxn(&self, w: T) -> Vec4<T>

pub fn xyyx(&self) -> Vec4<T>

pub fn xyyy(&self) -> Vec4<T>

pub fn xyyz(&self) -> Vec4<T>

pub fn xyyw(&self) -> Vec4<T>

pub fn xyyn(&self, w: T) -> Vec4<T>

pub fn xyzx(&self) -> Vec4<T>

pub fn xyzy(&self) -> Vec4<T>

pub fn xyzz(&self) -> Vec4<T>

pub fn xyzw(&self) -> Vec4<T>

pub fn xyzn(&self, w: T) -> Vec4<T>

pub fn xywx(&self) -> Vec4<T>

pub fn xywy(&self) -> Vec4<T>

pub fn xywz(&self) -> Vec4<T>

pub fn xyww(&self) -> Vec4<T>

pub fn xywn(&self, w: T) -> Vec4<T>

pub fn xynx(&self, z: T) -> Vec4<T>

pub fn xyny(&self, z: T) -> Vec4<T>

pub fn xynz(&self, z: T) -> Vec4<T>

pub fn xynw(&self, z: T) -> Vec4<T>

pub fn xynn(&self, z: T, w: T) -> Vec4<T>

pub fn xzxx(&self) -> Vec4<T>

pub fn xzxy(&self) -> Vec4<T>

pub fn xzxz(&self) -> Vec4<T>

pub fn xzxw(&self) -> Vec4<T>

pub fn xzxn(&self, w: T) -> Vec4<T>

pub fn xzyx(&self) -> Vec4<T>

pub fn xzyy(&self) -> Vec4<T>

pub fn xzyz(&self) -> Vec4<T>

pub fn xzyw(&self) -> Vec4<T>

pub fn xzyn(&self, w: T) -> Vec4<T>

pub fn xzzx(&self) -> Vec4<T>

pub fn xzzy(&self) -> Vec4<T>

pub fn xzzz(&self) -> Vec4<T>

pub fn xzzw(&self) -> Vec4<T>

pub fn xzzn(&self, w: T) -> Vec4<T>

pub fn xzwx(&self) -> Vec4<T>

pub fn xzwy(&self) -> Vec4<T>

pub fn xzwz(&self) -> Vec4<T>

pub fn xzww(&self) -> Vec4<T>

pub fn xzwn(&self, w: T) -> Vec4<T>

pub fn xznx(&self, z: T) -> Vec4<T>

pub fn xzny(&self, z: T) -> Vec4<T>

pub fn xznz(&self, z: T) -> Vec4<T>

pub fn xznw(&self, z: T) -> Vec4<T>

pub fn xznn(&self, z: T, w: T) -> Vec4<T>

pub fn xwxx(&self) -> Vec4<T>

pub fn xwxy(&self) -> Vec4<T>

pub fn xwxz(&self) -> Vec4<T>

pub fn xwxw(&self) -> Vec4<T>

pub fn xwxn(&self, w: T) -> Vec4<T>

pub fn xwyx(&self) -> Vec4<T>

pub fn xwyy(&self) -> Vec4<T>

pub fn xwyz(&self) -> Vec4<T>

pub fn xwyw(&self) -> Vec4<T>

pub fn xwyn(&self, w: T) -> Vec4<T>

pub fn xwzx(&self) -> Vec4<T>

pub fn xwzy(&self) -> Vec4<T>

pub fn xwzz(&self) -> Vec4<T>

pub fn xwzw(&self) -> Vec4<T>

pub fn xwzn(&self, w: T) -> Vec4<T>

pub fn xwwx(&self) -> Vec4<T>

pub fn xwwy(&self) -> Vec4<T>

pub fn xwwz(&self) -> Vec4<T>

pub fn xwww(&self) -> Vec4<T>

pub fn xwwn(&self, w: T) -> Vec4<T>

pub fn xwnx(&self, z: T) -> Vec4<T>

pub fn xwny(&self, z: T) -> Vec4<T>

pub fn xwnz(&self, z: T) -> Vec4<T>

pub fn xwnw(&self, z: T) -> Vec4<T>

pub fn xwnn(&self, z: T, w: T) -> Vec4<T>

pub fn xnxx(&self, y: T) -> Vec4<T>

pub fn xnxy(&self, y: T) -> Vec4<T>

pub fn xnxz(&self, y: T) -> Vec4<T>

pub fn xnxw(&self, y: T) -> Vec4<T>

pub fn xnxn(&self, y: T, w: T) -> Vec4<T>

pub fn xnyx(&self, y: T) -> Vec4<T>

pub fn xnyy(&self, y: T) -> Vec4<T>

pub fn xnyz(&self, y: T) -> Vec4<T>

pub fn xnyw(&self, y: T) -> Vec4<T>

pub fn xnyn(&self, y: T, w: T) -> Vec4<T>

pub fn xnzx(&self, y: T) -> Vec4<T>

pub fn xnzy(&self, y: T) -> Vec4<T>

pub fn xnzz(&self, y: T) -> Vec4<T>

pub fn xnzw(&self, y: T) -> Vec4<T>

pub fn xnzn(&self, y: T, w: T) -> Vec4<T>

pub fn xnwx(&self, y: T) -> Vec4<T>

pub fn xnwy(&self, y: T) -> Vec4<T>

pub fn xnwz(&self, y: T) -> Vec4<T>

pub fn xnww(&self, y: T) -> Vec4<T>

pub fn xnwn(&self, y: T, w: T) -> Vec4<T>

pub fn xnnx(&self, y: T, z: T) -> Vec4<T>

pub fn xnny(&self, y: T, z: T) -> Vec4<T>

pub fn xnnz(&self, y: T, z: T) -> Vec4<T>

pub fn xnnw(&self, y: T, z: T) -> Vec4<T>

pub fn xnnn(&self, y: T, z: T, w: T) -> Vec4<T>

pub fn yxxx(&self) -> Vec4<T>

pub fn yxxy(&self) -> Vec4<T>

pub fn yxxz(&self) -> Vec4<T>

pub fn yxxw(&self) -> Vec4<T>

pub fn yxxn(&self, w: T) -> Vec4<T>

pub fn yxyx(&self) -> Vec4<T>

pub fn yxyy(&self) -> Vec4<T>

pub fn yxyz(&self) -> Vec4<T>

pub fn yxyw(&self) -> Vec4<T>

pub fn yxyn(&self, w: T) -> Vec4<T>

pub fn yxzx(&self) -> Vec4<T>

pub fn yxzy(&self) -> Vec4<T>

pub fn yxzz(&self) -> Vec4<T>

pub fn yxzw(&self) -> Vec4<T>

pub fn yxzn(&self, w: T) -> Vec4<T>

pub fn yxwx(&self) -> Vec4<T>

pub fn yxwy(&self) -> Vec4<T>

pub fn yxwz(&self) -> Vec4<T>

pub fn yxww(&self) -> Vec4<T>

pub fn yxwn(&self, w: T) -> Vec4<T>

pub fn yxnx(&self, z: T) -> Vec4<T>

pub fn yxny(&self, z: T) -> Vec4<T>

pub fn yxnz(&self, z: T) -> Vec4<T>

pub fn yxnw(&self, z: T) -> Vec4<T>

pub fn yxnn(&self, z: T, w: T) -> Vec4<T>

pub fn yyxx(&self) -> Vec4<T>

pub fn yyxy(&self) -> Vec4<T>

pub fn yyxz(&self) -> Vec4<T>

pub fn yyxw(&self) -> Vec4<T>

pub fn yyxn(&self, w: T) -> Vec4<T>

pub fn yyyx(&self) -> Vec4<T>

pub fn yyyy(&self) -> Vec4<T>

pub fn yyyz(&self) -> Vec4<T>

pub fn yyyw(&self) -> Vec4<T>

pub fn yyyn(&self, w: T) -> Vec4<T>

pub fn yyzx(&self) -> Vec4<T>

pub fn yyzy(&self) -> Vec4<T>

pub fn yyzz(&self) -> Vec4<T>

pub fn yyzw(&self) -> Vec4<T>

pub fn yyzn(&self, w: T) -> Vec4<T>

pub fn yywx(&self) -> Vec4<T>

pub fn yywy(&self) -> Vec4<T>

pub fn yywz(&self) -> Vec4<T>

pub fn yyww(&self) -> Vec4<T>

pub fn yywn(&self, w: T) -> Vec4<T>

pub fn yynx(&self, z: T) -> Vec4<T>

pub fn yyny(&self, z: T) -> Vec4<T>

pub fn yynz(&self, z: T) -> Vec4<T>

pub fn yynw(&self, z: T) -> Vec4<T>

pub fn yynn(&self, z: T, w: T) -> Vec4<T>

pub fn yzxx(&self) -> Vec4<T>

pub fn yzxy(&self) -> Vec4<T>

pub fn yzxz(&self) -> Vec4<T>

pub fn yzxw(&self) -> Vec4<T>

pub fn yzxn(&self, w: T) -> Vec4<T>

pub fn yzyx(&self) -> Vec4<T>

pub fn yzyy(&self) -> Vec4<T>

pub fn yzyz(&self) -> Vec4<T>

pub fn yzyw(&self) -> Vec4<T>

pub fn yzyn(&self, w: T) -> Vec4<T>

pub fn yzzx(&self) -> Vec4<T>

pub fn yzzy(&self) -> Vec4<T>

pub fn yzzz(&self) -> Vec4<T>

pub fn yzzw(&self) -> Vec4<T>

pub fn yzzn(&self, w: T) -> Vec4<T>

pub fn yzwx(&self) -> Vec4<T>

pub fn yzwy(&self) -> Vec4<T>

pub fn yzwz(&self) -> Vec4<T>

pub fn yzww(&self) -> Vec4<T>

pub fn yzwn(&self, w: T) -> Vec4<T>

pub fn yznx(&self, z: T) -> Vec4<T>

pub fn yzny(&self, z: T) -> Vec4<T>

pub fn yznz(&self, z: T) -> Vec4<T>

pub fn yznw(&self, z: T) -> Vec4<T>

pub fn yznn(&self, z: T, w: T) -> Vec4<T>

pub fn ywxx(&self) -> Vec4<T>

pub fn ywxy(&self) -> Vec4<T>

pub fn ywxz(&self) -> Vec4<T>

pub fn ywxw(&self) -> Vec4<T>

pub fn ywxn(&self, w: T) -> Vec4<T>

pub fn ywyx(&self) -> Vec4<T>

pub fn ywyy(&self) -> Vec4<T>

pub fn ywyz(&self) -> Vec4<T>

pub fn ywyw(&self) -> Vec4<T>

pub fn ywyn(&self, w: T) -> Vec4<T>

pub fn ywzx(&self) -> Vec4<T>

pub fn ywzy(&self) -> Vec4<T>

pub fn ywzz(&self) -> Vec4<T>

pub fn ywzw(&self) -> Vec4<T>

pub fn ywzn(&self, w: T) -> Vec4<T>

pub fn ywwx(&self) -> Vec4<T>

pub fn ywwy(&self) -> Vec4<T>

pub fn ywwz(&self) -> Vec4<T>

pub fn ywww(&self) -> Vec4<T>

pub fn ywwn(&self, w: T) -> Vec4<T>

pub fn ywnx(&self, z: T) -> Vec4<T>

pub fn ywny(&self, z: T) -> Vec4<T>

pub fn ywnz(&self, z: T) -> Vec4<T>

pub fn ywnw(&self, z: T) -> Vec4<T>

pub fn ywnn(&self, z: T, w: T) -> Vec4<T>

pub fn ynxx(&self, y: T) -> Vec4<T>

pub fn ynxy(&self, y: T) -> Vec4<T>

pub fn ynxz(&self, y: T) -> Vec4<T>

pub fn ynxw(&self, y: T) -> Vec4<T>

pub fn ynxn(&self, y: T, w: T) -> Vec4<T>

pub fn ynyx(&self, y: T) -> Vec4<T>

pub fn ynyy(&self, y: T) -> Vec4<T>

pub fn ynyz(&self, y: T) -> Vec4<T>

pub fn ynyw(&self, y: T) -> Vec4<T>

pub fn ynyn(&self, y: T, w: T) -> Vec4<T>

pub fn ynzx(&self, y: T) -> Vec4<T>

pub fn ynzy(&self, y: T) -> Vec4<T>

pub fn ynzz(&self, y: T) -> Vec4<T>

pub fn ynzw(&self, y: T) -> Vec4<T>

pub fn ynzn(&self, y: T, w: T) -> Vec4<T>

pub fn ynwx(&self, y: T) -> Vec4<T>

pub fn ynwy(&self, y: T) -> Vec4<T>

pub fn ynwz(&self, y: T) -> Vec4<T>

pub fn ynww(&self, y: T) -> Vec4<T>

pub fn ynwn(&self, y: T, w: T) -> Vec4<T>

pub fn ynnx(&self, y: T, z: T) -> Vec4<T>

pub fn ynny(&self, y: T, z: T) -> Vec4<T>

pub fn ynnz(&self, y: T, z: T) -> Vec4<T>

pub fn ynnw(&self, y: T, z: T) -> Vec4<T>

pub fn ynnn(&self, y: T, z: T, w: T) -> Vec4<T>

pub fn zxxx(&self) -> Vec4<T>

pub fn zxxy(&self) -> Vec4<T>

pub fn zxxz(&self) -> Vec4<T>

pub fn zxxw(&self) -> Vec4<T>

pub fn zxxn(&self, w: T) -> Vec4<T>

pub fn zxyx(&self) -> Vec4<T>

pub fn zxyy(&self) -> Vec4<T>

pub fn zxyz(&self) -> Vec4<T>

pub fn zxyw(&self) -> Vec4<T>

pub fn zxyn(&self, w: T) -> Vec4<T>

pub fn zxzx(&self) -> Vec4<T>

pub fn zxzy(&self) -> Vec4<T>

pub fn zxzz(&self) -> Vec4<T>

pub fn zxzw(&self) -> Vec4<T>

pub fn zxzn(&self, w: T) -> Vec4<T>

pub fn zxwx(&self) -> Vec4<T>

pub fn zxwy(&self) -> Vec4<T>

pub fn zxwz(&self) -> Vec4<T>

pub fn zxww(&self) -> Vec4<T>

pub fn zxwn(&self, w: T) -> Vec4<T>

pub fn zxnx(&self, z: T) -> Vec4<T>

pub fn zxny(&self, z: T) -> Vec4<T>

pub fn zxnz(&self, z: T) -> Vec4<T>

pub fn zxnw(&self, z: T) -> Vec4<T>

pub fn zxnn(&self, z: T, w: T) -> Vec4<T>

pub fn zyxx(&self) -> Vec4<T>

pub fn zyxy(&self) -> Vec4<T>

pub fn zyxz(&self) -> Vec4<T>

pub fn zyxw(&self) -> Vec4<T>

pub fn zyxn(&self, w: T) -> Vec4<T>

pub fn zyyx(&self) -> Vec4<T>

pub fn zyyy(&self) -> Vec4<T>

pub fn zyyz(&self) -> Vec4<T>

pub fn zyyw(&self) -> Vec4<T>

pub fn zyyn(&self, w: T) -> Vec4<T>

pub fn zyzx(&self) -> Vec4<T>

pub fn zyzy(&self) -> Vec4<T>

pub fn zyzz(&self) -> Vec4<T>

pub fn zyzw(&self) -> Vec4<T>

pub fn zyzn(&self, w: T) -> Vec4<T>

pub fn zywx(&self) -> Vec4<T>

pub fn zywy(&self) -> Vec4<T>

pub fn zywz(&self) -> Vec4<T>

pub fn zyww(&self) -> Vec4<T>

pub fn zywn(&self, w: T) -> Vec4<T>

pub fn zynx(&self, z: T) -> Vec4<T>

pub fn zyny(&self, z: T) -> Vec4<T>

pub fn zynz(&self, z: T) -> Vec4<T>

pub fn zynw(&self, z: T) -> Vec4<T>

pub fn zynn(&self, z: T, w: T) -> Vec4<T>

pub fn zzxx(&self) -> Vec4<T>

pub fn zzxy(&self) -> Vec4<T>

pub fn zzxz(&self) -> Vec4<T>

pub fn zzxw(&self) -> Vec4<T>

pub fn zzxn(&self, w: T) -> Vec4<T>

pub fn zzyx(&self) -> Vec4<T>

pub fn zzyy(&self) -> Vec4<T>

pub fn zzyz(&self) -> Vec4<T>

pub fn zzyw(&self) -> Vec4<T>

pub fn zzyn(&self, w: T) -> Vec4<T>

pub fn zzzx(&self) -> Vec4<T>

pub fn zzzy(&self) -> Vec4<T>

pub fn zzzz(&self) -> Vec4<T>

pub fn zzzw(&self) -> Vec4<T>

pub fn zzzn(&self, w: T) -> Vec4<T>

pub fn zzwx(&self) -> Vec4<T>

pub fn zzwy(&self) -> Vec4<T>

pub fn zzwz(&self) -> Vec4<T>

pub fn zzww(&self) -> Vec4<T>

pub fn zzwn(&self, w: T) -> Vec4<T>

pub fn zznx(&self, z: T) -> Vec4<T>

pub fn zzny(&self, z: T) -> Vec4<T>

pub fn zznz(&self, z: T) -> Vec4<T>

pub fn zznw(&self, z: T) -> Vec4<T>

pub fn zznn(&self, z: T, w: T) -> Vec4<T>

pub fn zwxx(&self) -> Vec4<T>

pub fn zwxy(&self) -> Vec4<T>

pub fn zwxz(&self) -> Vec4<T>

pub fn zwxw(&self) -> Vec4<T>

pub fn zwxn(&self, w: T) -> Vec4<T>

pub fn zwyx(&self) -> Vec4<T>

pub fn zwyy(&self) -> Vec4<T>

pub fn zwyz(&self) -> Vec4<T>

pub fn zwyw(&self) -> Vec4<T>

pub fn zwyn(&self, w: T) -> Vec4<T>

pub fn zwzx(&self) -> Vec4<T>

pub fn zwzy(&self) -> Vec4<T>

pub fn zwzz(&self) -> Vec4<T>

pub fn zwzw(&self) -> Vec4<T>

pub fn zwzn(&self, w: T) -> Vec4<T>

pub fn zwwx(&self) -> Vec4<T>

pub fn zwwy(&self) -> Vec4<T>

pub fn zwwz(&self) -> Vec4<T>

pub fn zwww(&self) -> Vec4<T>

pub fn zwwn(&self, w: T) -> Vec4<T>

pub fn zwnx(&self, z: T) -> Vec4<T>

pub fn zwny(&self, z: T) -> Vec4<T>

pub fn zwnz(&self, z: T) -> Vec4<T>

pub fn zwnw(&self, z: T) -> Vec4<T>

pub fn zwnn(&self, z: T, w: T) -> Vec4<T>

pub fn znxx(&self, y: T) -> Vec4<T>

pub fn znxy(&self, y: T) -> Vec4<T>

pub fn znxz(&self, y: T) -> Vec4<T>

pub fn znxw(&self, y: T) -> Vec4<T>

pub fn znxn(&self, y: T, w: T) -> Vec4<T>

pub fn znyx(&self, y: T) -> Vec4<T>

pub fn znyy(&self, y: T) -> Vec4<T>

pub fn znyz(&self, y: T) -> Vec4<T>

pub fn znyw(&self, y: T) -> Vec4<T>

pub fn znyn(&self, y: T, w: T) -> Vec4<T>

pub fn znzx(&self, y: T) -> Vec4<T>

pub fn znzy(&self, y: T) -> Vec4<T>

pub fn znzz(&self, y: T) -> Vec4<T>

pub fn znzw(&self, y: T) -> Vec4<T>

pub fn znzn(&self, y: T, w: T) -> Vec4<T>

pub fn znwx(&self, y: T) -> Vec4<T>

pub fn znwy(&self, y: T) -> Vec4<T>

pub fn znwz(&self, y: T) -> Vec4<T>

pub fn znww(&self, y: T) -> Vec4<T>

pub fn znwn(&self, y: T, w: T) -> Vec4<T>

pub fn znnx(&self, y: T, z: T) -> Vec4<T>

pub fn znny(&self, y: T, z: T) -> Vec4<T>

pub fn znnz(&self, y: T, z: T) -> Vec4<T>

pub fn znnw(&self, y: T, z: T) -> Vec4<T>

pub fn znnn(&self, y: T, z: T, w: T) -> Vec4<T>

pub fn wxxx(&self) -> Vec4<T>

pub fn wxxy(&self) -> Vec4<T>

pub fn wxxz(&self) -> Vec4<T>

pub fn wxxw(&self) -> Vec4<T>

pub fn wxxn(&self, w: T) -> Vec4<T>

pub fn wxyx(&self) -> Vec4<T>

pub fn wxyy(&self) -> Vec4<T>

pub fn wxyz(&self) -> Vec4<T>

pub fn wxyw(&self) -> Vec4<T>

pub fn wxyn(&self, w: T) -> Vec4<T>

pub fn wxzx(&self) -> Vec4<T>

pub fn wxzy(&self) -> Vec4<T>

pub fn wxzz(&self) -> Vec4<T>

pub fn wxzw(&self) -> Vec4<T>

pub fn wxzn(&self, w: T) -> Vec4<T>

pub fn wxwx(&self) -> Vec4<T>

pub fn wxwy(&self) -> Vec4<T>

pub fn wxwz(&self) -> Vec4<T>

pub fn wxww(&self) -> Vec4<T>

pub fn wxwn(&self, w: T) -> Vec4<T>

pub fn wxnx(&self, z: T) -> Vec4<T>

pub fn wxny(&self, z: T) -> Vec4<T>

pub fn wxnz(&self, z: T) -> Vec4<T>

pub fn wxnw(&self, z: T) -> Vec4<T>

pub fn wxnn(&self, z: T, w: T) -> Vec4<T>

pub fn wyxx(&self) -> Vec4<T>

pub fn wyxy(&self) -> Vec4<T>

pub fn wyxz(&self) -> Vec4<T>

pub fn wyxw(&self) -> Vec4<T>

pub fn wyxn(&self, w: T) -> Vec4<T>

pub fn wyyx(&self) -> Vec4<T>

pub fn wyyy(&self) -> Vec4<T>

pub fn wyyz(&self) -> Vec4<T>

pub fn wyyw(&self) -> Vec4<T>

pub fn wyyn(&self, w: T) -> Vec4<T>

pub fn wyzx(&self) -> Vec4<T>

pub fn wyzy(&self) -> Vec4<T>

pub fn wyzz(&self) -> Vec4<T>

pub fn wyzw(&self) -> Vec4<T>

pub fn wyzn(&self, w: T) -> Vec4<T>

pub fn wywx(&self) -> Vec4<T>

pub fn wywy(&self) -> Vec4<T>

pub fn wywz(&self) -> Vec4<T>

pub fn wyww(&self) -> Vec4<T>

pub fn wywn(&self, w: T) -> Vec4<T>

pub fn wynx(&self, z: T) -> Vec4<T>

pub fn wyny(&self, z: T) -> Vec4<T>

pub fn wynz(&self, z: T) -> Vec4<T>

pub fn wynw(&self, z: T) -> Vec4<T>

pub fn wynn(&self, z: T, w: T) -> Vec4<T>

pub fn wzxx(&self) -> Vec4<T>

pub fn wzxy(&self) -> Vec4<T>

pub fn wzxz(&self) -> Vec4<T>

pub fn wzxw(&self) -> Vec4<T>

pub fn wzxn(&self, w: T) -> Vec4<T>

pub fn wzyx(&self) -> Vec4<T>

pub fn wzyy(&self) -> Vec4<T>

pub fn wzyz(&self) -> Vec4<T>

pub fn wzyw(&self) -> Vec4<T>

pub fn wzyn(&self, w: T) -> Vec4<T>

pub fn wzzx(&self) -> Vec4<T>

pub fn wzzy(&self) -> Vec4<T>

pub fn wzzz(&self) -> Vec4<T>

pub fn wzzw(&self) -> Vec4<T>

pub fn wzzn(&self, w: T) -> Vec4<T>

pub fn wzwx(&self) -> Vec4<T>

pub fn wzwy(&self) -> Vec4<T>

pub fn wzwz(&self) -> Vec4<T>

pub fn wzww(&self) -> Vec4<T>

pub fn wzwn(&self, w: T) -> Vec4<T>

pub fn wznx(&self, z: T) -> Vec4<T>

pub fn wzny(&self, z: T) -> Vec4<T>

pub fn wznz(&self, z: T) -> Vec4<T>

pub fn wznw(&self, z: T) -> Vec4<T>

pub fn wznn(&self, z: T, w: T) -> Vec4<T>

pub fn wwxx(&self) -> Vec4<T>

pub fn wwxy(&self) -> Vec4<T>

pub fn wwxz(&self) -> Vec4<T>

pub fn wwxw(&self) -> Vec4<T>

pub fn wwxn(&self, w: T) -> Vec4<T>

pub fn wwyx(&self) -> Vec4<T>

pub fn wwyy(&self) -> Vec4<T>

pub fn wwyz(&self) -> Vec4<T>

pub fn wwyw(&self) -> Vec4<T>

pub fn wwyn(&self, w: T) -> Vec4<T>

pub fn wwzx(&self) -> Vec4<T>

pub fn wwzy(&self) -> Vec4<T>

pub fn wwzz(&self) -> Vec4<T>

pub fn wwzw(&self) -> Vec4<T>

pub fn wwzn(&self, w: T) -> Vec4<T>

pub fn wwwx(&self) -> Vec4<T>

pub fn wwwy(&self) -> Vec4<T>

pub fn wwwz(&self) -> Vec4<T>

pub fn wwww(&self) -> Vec4<T>

pub fn wwwn(&self, w: T) -> Vec4<T>

pub fn wwnx(&self, z: T) -> Vec4<T>

pub fn wwny(&self, z: T) -> Vec4<T>

pub fn wwnz(&self, z: T) -> Vec4<T>

pub fn wwnw(&self, z: T) -> Vec4<T>

pub fn wwnn(&self, z: T, w: T) -> Vec4<T>

pub fn wnxx(&self, y: T) -> Vec4<T>

pub fn wnxy(&self, y: T) -> Vec4<T>

pub fn wnxz(&self, y: T) -> Vec4<T>

pub fn wnxw(&self, y: T) -> Vec4<T>

pub fn wnxn(&self, y: T, w: T) -> Vec4<T>

pub fn wnyx(&self, y: T) -> Vec4<T>

pub fn wnyy(&self, y: T) -> Vec4<T>

pub fn wnyz(&self, y: T) -> Vec4<T>

pub fn wnyw(&self, y: T) -> Vec4<T>

pub fn wnyn(&self, y: T, w: T) -> Vec4<T>

pub fn wnzx(&self, y: T) -> Vec4<T>

pub fn wnzy(&self, y: T) -> Vec4<T>

pub fn wnzz(&self, y: T) -> Vec4<T>

pub fn wnzw(&self, y: T) -> Vec4<T>

pub fn wnzn(&self, y: T, w: T) -> Vec4<T>

pub fn wnwx(&self, y: T) -> Vec4<T>

pub fn wnwy(&self, y: T) -> Vec4<T>

pub fn wnwz(&self, y: T) -> Vec4<T>

pub fn wnww(&self, y: T) -> Vec4<T>

pub fn wnwn(&self, y: T, w: T) -> Vec4<T>

pub fn wnnx(&self, y: T, z: T) -> Vec4<T>

pub fn wnny(&self, y: T, z: T) -> Vec4<T>

pub fn wnnz(&self, y: T, z: T) -> Vec4<T>

pub fn wnnw(&self, y: T, z: T) -> Vec4<T>

pub fn wnnn(&self, y: T, z: T, w: T) -> Vec4<T>

pub fn nxxx(&self, x: T) -> Vec4<T>

pub fn nxxy(&self, x: T) -> Vec4<T>

pub fn nxxz(&self, x: T) -> Vec4<T>

pub fn nxxw(&self, x: T) -> Vec4<T>

pub fn nxxn(&self, x: T, w: T) -> Vec4<T>

pub fn nxyx(&self, x: T) -> Vec4<T>

pub fn nxyy(&self, x: T) -> Vec4<T>

pub fn nxyz(&self, x: T) -> Vec4<T>

pub fn nxyw(&self, x: T) -> Vec4<T>

pub fn nxyn(&self, x: T, w: T) -> Vec4<T>

pub fn nxzx(&self, x: T) -> Vec4<T>

pub fn nxzy(&self, x: T) -> Vec4<T>

pub fn nxzz(&self, x: T) -> Vec4<T>

pub fn nxzw(&self, x: T) -> Vec4<T>

pub fn nxzn(&self, x: T, w: T) -> Vec4<T>

pub fn nxwx(&self, x: T) -> Vec4<T>

pub fn nxwy(&self, x: T) -> Vec4<T>

pub fn nxwz(&self, x: T) -> Vec4<T>

pub fn nxww(&self, x: T) -> Vec4<T>

pub fn nxwn(&self, x: T, w: T) -> Vec4<T>

pub fn nxnx(&self, x: T, z: T) -> Vec4<T>

pub fn nxny(&self, x: T, z: T) -> Vec4<T>

pub fn nxnz(&self, x: T, z: T) -> Vec4<T>

pub fn nxnw(&self, x: T, z: T) -> Vec4<T>

pub fn nxnn(&self, x: T, z: T, w: T) -> Vec4<T>

pub fn nyxx(&self, x: T) -> Vec4<T>

pub fn nyxy(&self, x: T) -> Vec4<T>

pub fn nyxz(&self, x: T) -> Vec4<T>

pub fn nyxw(&self, x: T) -> Vec4<T>

pub fn nyxn(&self, x: T, w: T) -> Vec4<T>

pub fn nyyx(&self, x: T) -> Vec4<T>

pub fn nyyy(&self, x: T) -> Vec4<T>

pub fn nyyz(&self, x: T) -> Vec4<T>

pub fn nyyw(&self, x: T) -> Vec4<T>

pub fn nyyn(&self, x: T, w: T) -> Vec4<T>

pub fn nyzx(&self, x: T) -> Vec4<T>

pub fn nyzy(&self, x: T) -> Vec4<T>

pub fn nyzz(&self, x: T) -> Vec4<T>

pub fn nyzw(&self, x: T) -> Vec4<T>

pub fn nyzn(&self, x: T, w: T) -> Vec4<T>

pub fn nywx(&self, x: T) -> Vec4<T>

pub fn nywy(&self, x: T) -> Vec4<T>

pub fn nywz(&self, x: T) -> Vec4<T>

pub fn nyww(&self, x: T) -> Vec4<T>

pub fn nywn(&self, x: T, w: T) -> Vec4<T>

pub fn nynx(&self, x: T, z: T) -> Vec4<T>

pub fn nyny(&self, x: T, z: T) -> Vec4<T>

pub fn nynz(&self, x: T, z: T) -> Vec4<T>

pub fn nynw(&self, x: T, z: T) -> Vec4<T>

pub fn nynn(&self, x: T, z: T, w: T) -> Vec4<T>

pub fn nzxx(&self, x: T) -> Vec4<T>

pub fn nzxy(&self, x: T) -> Vec4<T>

pub fn nzxz(&self, x: T) -> Vec4<T>

pub fn nzxw(&self, x: T) -> Vec4<T>

pub fn nzxn(&self, x: T, w: T) -> Vec4<T>

pub fn nzyx(&self, x: T) -> Vec4<T>

pub fn nzyy(&self, x: T) -> Vec4<T>

pub fn nzyz(&self, x: T) -> Vec4<T>

pub fn nzyw(&self, x: T) -> Vec4<T>

pub fn nzyn(&self, x: T, w: T) -> Vec4<T>

pub fn nzzx(&self, x: T) -> Vec4<T>

pub fn nzzy(&self, x: T) -> Vec4<T>

pub fn nzzz(&self, x: T) -> Vec4<T>

pub fn nzzw(&self, x: T) -> Vec4<T>

pub fn nzzn(&self, x: T, w: T) -> Vec4<T>

pub fn nzwx(&self, x: T) -> Vec4<T>

pub fn nzwy(&self, x: T) -> Vec4<T>

pub fn nzwz(&self, x: T) -> Vec4<T>

pub fn nzww(&self, x: T) -> Vec4<T>

pub fn nzwn(&self, x: T, w: T) -> Vec4<T>

pub fn nznx(&self, x: T, z: T) -> Vec4<T>

pub fn nzny(&self, x: T, z: T) -> Vec4<T>

pub fn nznz(&self, x: T, z: T) -> Vec4<T>

pub fn nznw(&self, x: T, z: T) -> Vec4<T>

pub fn nznn(&self, x: T, z: T, w: T) -> Vec4<T>

pub fn nwxx(&self, x: T) -> Vec4<T>

pub fn nwxy(&self, x: T) -> Vec4<T>

pub fn nwxz(&self, x: T) -> Vec4<T>

pub fn nwxw(&self, x: T) -> Vec4<T>

pub fn nwxn(&self, x: T, w: T) -> Vec4<T>

pub fn nwyx(&self, x: T) -> Vec4<T>

pub fn nwyy(&self, x: T) -> Vec4<T>

pub fn nwyz(&self, x: T) -> Vec4<T>

pub fn nwyw(&self, x: T) -> Vec4<T>

pub fn nwyn(&self, x: T, w: T) -> Vec4<T>

pub fn nwzx(&self, x: T) -> Vec4<T>

pub fn nwzy(&self, x: T) -> Vec4<T>

pub fn nwzz(&self, x: T) -> Vec4<T>

pub fn nwzw(&self, x: T) -> Vec4<T>

pub fn nwzn(&self, x: T, w: T) -> Vec4<T>

pub fn nwwx(&self, x: T) -> Vec4<T>

pub fn nwwy(&self, x: T) -> Vec4<T>

pub fn nwwz(&self, x: T) -> Vec4<T>

pub fn nwww(&self, x: T) -> Vec4<T>

pub fn nwwn(&self, x: T, w: T) -> Vec4<T>

pub fn nwnx(&self, x: T, z: T) -> Vec4<T>

pub fn nwny(&self, x: T, z: T) -> Vec4<T>

pub fn nwnz(&self, x: T, z: T) -> Vec4<T>

pub fn nwnw(&self, x: T, z: T) -> Vec4<T>

pub fn nwnn(&self, x: T, z: T, w: T) -> Vec4<T>

pub fn nnxx(&self, x: T, y: T) -> Vec4<T>

pub fn nnxy(&self, x: T, y: T) -> Vec4<T>

pub fn nnxz(&self, x: T, y: T) -> Vec4<T>

pub fn nnxw(&self, x: T, y: T) -> Vec4<T>

pub fn nnxn(&self, x: T, y: T, w: T) -> Vec4<T>

pub fn nnyx(&self, x: T, y: T) -> Vec4<T>

pub fn nnyy(&self, x: T, y: T) -> Vec4<T>

pub fn nnyz(&self, x: T, y: T) -> Vec4<T>

pub fn nnyw(&self, x: T, y: T) -> Vec4<T>

pub fn nnyn(&self, x: T, y: T, w: T) -> Vec4<T>

pub fn nnzx(&self, x: T, y: T) -> Vec4<T>

pub fn nnzy(&self, x: T, y: T) -> Vec4<T>

pub fn nnzz(&self, x: T, y: T) -> Vec4<T>

pub fn nnzw(&self, x: T, y: T) -> Vec4<T>

pub fn nnzn(&self, x: T, y: T, w: T) -> Vec4<T>

pub fn nnwx(&self, x: T, y: T) -> Vec4<T>

pub fn nnwy(&self, x: T, y: T) -> Vec4<T>

pub fn nnwz(&self, x: T, y: T) -> Vec4<T>

pub fn nnww(&self, x: T, y: T) -> Vec4<T>

pub fn nnwn(&self, x: T, y: T, w: T) -> Vec4<T>

pub fn nnnx(&self, x: T, y: T, z: T) -> Vec4<T>

pub fn nnny(&self, x: T, y: T, z: T) -> Vec4<T>

pub fn nnnz(&self, x: T, y: T, z: T) -> Vec4<T>

pub fn nnnw(&self, x: T, y: T, z: T) -> Vec4<T>

§

impl<T> Vec4<T>
where T: Primitive,

pub const X: Vec4<T>

pub const Y: Vec4<T>

pub const Z: Vec4<T>

pub const W: Vec4<T>

Trait Implementations§

§

impl<T, U> Add<Vec4<U>> for Vec4<T>
where T: Add<U>,

§

type Output = Vec4<<T as Add<U>>::Output>

The resulting type after applying the + operator.
§

fn add(self, rhs: Vec4<U>) -> <Vec4<T> as Add<Vec4<U>>>::Output

Performs the + operation. Read more
§

impl<T, U> AddAssign<Vec4<U>> for Vec4<T>
where T: AddAssign<U>,

§

fn add_assign(&mut self, rhs: Vec4<U>)

Performs the += operation. Read more
§

impl<T> AllBitVariationsValid for Vec4<T>
where T: AllBitVariationsValid,

§

impl<T> AllBitsInit for Vec4<T>
where T: AllBitsInit,

§

impl<T> Clone for Vec4<T>
where T: Clone,

§

fn clone(&self) -> Vec4<T>

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
§

impl<T> Copy for Vec4<T>
where T: Copy,

§

impl<T> Debug for Vec4<T>
where T: Debug,

§

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

Formats the value using the given formatter. Read more
§

impl<T> Default for Vec4<T>
where T: Default,

§

fn default() -> Vec4<T>

Returns the “default value” for a type. Read more
§

impl<'de, T> Deserialize<'de> for Vec4<T>
where T: Deserialize<'de>,

§

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

Deserialize this value from the given Serde deserializer. Read more
§

impl<T> Div for Vec4<T>
where T: Div,

§

type Output = Vec4<<T as Div>::Output>

The resulting type after applying the / operator.
§

fn div(self, rhs: Vec4<T>) -> <Vec4<T> as Div>::Output

Performs the / operation. Read more
§

impl<T> Div<T> for Vec4<T>
where T: Div + Copy,

§

type Output = Vec4<<T as Div>::Output>

The resulting type after applying the / operator.
§

fn div(self, rhs: T) -> <Vec4<T> as Div<T>>::Output

Performs the / operation. Read more
§

impl<T> DivAssign for Vec4<T>
where T: DivAssign,

§

fn div_assign(&mut self, rhs: Vec4<T>)

Performs the /= operation. Read more
§

impl<T> DivAssign<T> for Vec4<T>
where T: DivAssign + Copy,

§

fn div_assign(&mut self, rhs: T)

Performs the /= operation. Read more
§

impl<T> Eq for Vec4<T>
where T: Eq,

§

impl<T> From<[T; 4]> for Vec4<T>
where T: Primitive,

§

fn from(a: [T; 4]) -> Vec4<T>

Converts to this type from the input type.
§

impl<T> Hash for Vec4<T>
where T: Hash,

§

fn hash<__H>(&self, state: &mut __H)
where __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
§

impl<T> Index<usize> for Vec4<T>

§

type Output = T

The returned type after indexing.
§

fn index(&self, i: usize) -> &<Vec4<T> as Index<usize>>::Output

Performs the indexing (container[index]) operation. Read more
§

impl<T> IndexMut<usize> for Vec4<T>

§

fn index_mut(&mut self, i: usize) -> &mut <Vec4<T> as Index<usize>>::Output

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

impl<T> Mul for Vec4<T>
where T: Mul,

§

type Output = Vec4<<T as Mul>::Output>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<T> Mul<T> for Vec4<T>
where T: Mul + Copy,

§

type Output = Vec4<<T as Mul>::Output>

The resulting type after applying the * operator.
§

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

Performs the * operation. Read more
§

impl<T> Mul<Vec4<T>> for Mat<4, T>
where T: Number,

§

type Output = Vec4<T>

The resulting type after applying the * operator.
§

fn mul(self, rhs: Vec4<T>) -> <Mat<4, T> as Mul<Vec4<T>>>::Output

Performs the * operation. Read more
§

impl<T> MulAssign for Vec4<T>
where T: MulAssign,

§

fn mul_assign(&mut self, rhs: Vec4<T>)

Performs the *= operation. Read more
§

impl<T> MulAssign<T> for Vec4<T>
where T: MulAssign + Copy,

§

fn mul_assign(&mut self, rhs: T)

Performs the *= operation. Read more
§

impl<T> Neg for Vec4<T>
where T: Neg,

§

type Output = Vec4<<T as Neg>::Output>

The resulting type after applying the - operator.
§

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

Performs the unary - operation. Read more
§

impl<T> Ord for Vec4<T>
where T: Ord,

§

fn cmp(&self, other: &Vec4<T>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 (const: unstable) · Source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 (const: unstable) · Source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 (const: unstable) · Source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

Restrict a value to a certain interval. Read more
Source§

fn clamp_to<R>(self, range: R) -> Self
where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)
Restrict a value to a certain range. Read more
§

impl<T> PartialEq for Vec4<T>
where T: PartialEq,

§

fn eq(&self, other: &Vec4<T>) -> bool

Equality operator ==. Read more
1.0.0 (const: unstable) · Source§

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

Inequality operator !=. Read more
§

impl<T> PartialOrd for Vec4<T>
where T: PartialOrd,

§

fn partial_cmp(&self, other: &Vec4<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 (const: unstable) · Source§

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

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 (const: unstable) · Source§

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 (const: unstable) · Source§

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

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 (const: unstable) · Source§

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

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
§

impl<S, T> Serializable<S> for Vec4<T>
where S: SerializerCtxState<T>, Vec4<T>: Default,

§

fn serialize(&self, ctx: SerializerCtx<'_, S>, path: &str) -> SerializedValue

§

fn deserialize( &mut self, ctx: SerializerCtx<'_, S>, path: &str, value: &SerializedValue, )

§

impl<T> Serialize for Vec4<T>
where T: Serialize,

§

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. Read more
§

impl<T> StructuralPartialEq for Vec4<T>
where T: PartialEq,

§

impl<T, U> Sub<Vec4<U>> for Vec4<T>
where T: Sub<U>,

§

type Output = Vec4<<T as Sub<U>>::Output>

The resulting type after applying the - operator.
§

fn sub(self, rhs: Vec4<U>) -> <Vec4<T> as Sub<Vec4<U>>>::Output

Performs the - operation. Read more
§

impl<T, U> SubAssign<Vec4<U>> for Vec4<T>
where T: SubAssign<U>,

§

fn sub_assign(&mut self, rhs: Vec4<U>)

Performs the -= operation. Read more

Auto Trait Implementations§

§

impl<T> Forget for Vec4<T>

§

impl<T> Freeze for Vec4<T>
where T: Freeze,

§

impl<T> Move for Vec4<T>

§

impl<T> RefUnwindSafe for Vec4<T>
where T: RefUnwindSafe,

§

impl<T> Send for Vec4<T>
where T: Send,

§

impl<T> Sync for Vec4<T>
where T: Sync,

§

impl<T> Unpin for Vec4<T>
where T: Unpin,

§

impl<T> UnsafeUnpin for Vec4<T>
where T: UnsafeUnpin,

§

impl<T> UnwindSafe for Vec4<T>
where T: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
§

impl<Q, K> Comparable<K> for Q
where Q: Ord + ?Sized, K: Borrow<Q> + ?Sized,

§

fn compare(&self, key: &K) -> Ordering

Compare self to key and return their ordering.
Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync> ⓘ

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
§

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<S> FromSample<S> for S

§

fn from_sample_(s: S) -> S

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<R, P> ReadPrimitive<R> for P
where R: Read + ReadEndian<P>, P: Default,

Source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
Source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
Source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
§

impl<T> SameType for T

§

type Same = T

§

fn same_to_self(v: <T as SameType>::Same) -> T

§

fn self_to_same(v: T) -> <T as SameType>::Same

§

fn same_to_self_ref(v: &<T as SameType>::Same) -> &T

§

fn self_to_same_ref(v: &T) -> &<T as SameType>::Same

§

fn same_to_self_mut(v: &mut <T as SameType>::Same) -> &mut T

§

fn self_to_same_mut(v: &mut T) -> &mut <T as SameType>::Same

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

§

fn to_sample_(self) -> U

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<T> WasmNotSend for T
where T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where T: Sync,

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more