[−][src]Struct hektor::Vec4

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

A 4-dimensional vector.

This is four f32 values, x, y, z, and w.

This type is 16-byte aligned. When possible using Stable Rust it's a SIMD type with explicit SIMD operation. Otherwise it's an array of [f32; 4] and we just pray to Ferris to please auto-vectorize the code as best as possible.

Methods

`impl Vec4`[src]

Accessors

`pub fn x(self) -> f32`[src]

Gets the x component of this vector.

`pub fn y(self) -> f32`[src]

Gets the y component of this vector.

`pub fn z(self) -> f32`[src]

Gets the z component of this vector.

`pub fn w(self) -> f32`[src]

Gets the w component of this vector.

`pub fn x_mut(&mut self) -> &mut f32`[src]

&mut to the x component of this vector.

`pub fn y_mut(&mut self) -> &mut f32`[src]

&mut to the y component of this vector.

`pub fn z_mut(&mut self) -> &mut f32`[src]

&mut to the z component of this vector.

`pub fn w_mut(&mut self) -> &mut f32`[src]

&mut to the w component of this vector.

`impl Vec4`[src]

Constructors

`pub fn new(x: f32, y: f32, z: f32, w: f32) -> Self`[src]

Makes a new Vec4

`pub fn splat(v: f32) -> Self`[src]

Splats the given value across all components.

`pub fn to_vec3(self) -> Vec3`[src]

Reduces this 4d vec to a 3d vec by simply forgetting the w value.

`impl Vec4`[src]

Operations

`pub fn dot(self, rhs: Self) -> f32`[src]

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`[src]

The length / magnitude of the vector.

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

`pub fn length2(self) -> f32`[src]

The squared length / magnitude of the vector.

x^2 + y^2 + z^2 + w^2

`pub fn normalize(self) -> Self`[src]

Generates a new vector where the length is 1.0

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

`impl Vec4`[src]

`pub fn ww(self) -> Vec2`[src]

Swizzle: obtains the ww combination

`pub fn www(self) -> Vec3`[src]

Swizzle: obtains the www combination

`pub fn wwww(self) -> Self`[src]

Swizzle: obtains the wwww combination

`pub fn wwwx(self) -> Self`[src]

Swizzle: obtains the wwwx combination

`pub fn wwwy(self) -> Self`[src]

Swizzle: obtains the wwwy combination

`pub fn wwwz(self) -> Self`[src]

Swizzle: obtains the wwwz combination

`pub fn wwx(self) -> Vec3`[src]

Swizzle: obtains the wwx combination

`pub fn wwxw(self) -> Self`[src]

Swizzle: obtains the wwxw combination

`pub fn wwxx(self) -> Self`[src]

Swizzle: obtains the wwxx combination

`pub fn wwxy(self) -> Self`[src]

Swizzle: obtains the wwxy combination

`pub fn wwxz(self) -> Self`[src]

Swizzle: obtains the wwxz combination

`pub fn wwy(self) -> Vec3`[src]

Swizzle: obtains the wwy combination

`pub fn wwyw(self) -> Self`[src]

Swizzle: obtains the wwyw combination

`pub fn wwyx(self) -> Self`[src]

Swizzle: obtains the wwyx combination

`pub fn wwyy(self) -> Self`[src]

Swizzle: obtains the wwyy combination

`pub fn wwyz(self) -> Self`[src]

Swizzle: obtains the wwyz combination

`pub fn wwz(self) -> Vec3`[src]

Swizzle: obtains the wwz combination

`pub fn wwzw(self) -> Self`[src]

Swizzle: obtains the wwzw combination

`pub fn wwzx(self) -> Self`[src]

Swizzle: obtains the wwzx combination

`pub fn wwzy(self) -> Self`[src]

Swizzle: obtains the wwzy combination

`pub fn wwzz(self) -> Self`[src]

Swizzle: obtains the wwzz combination

`pub fn wx(self) -> Vec2`[src]

Swizzle: obtains the wx combination

`pub fn wxw(self) -> Vec3`[src]

Swizzle: obtains the wxw combination

`pub fn wxww(self) -> Self`[src]

Swizzle: obtains the wxww combination

`pub fn wxwx(self) -> Self`[src]

Swizzle: obtains the wxwx combination

`pub fn wxwy(self) -> Self`[src]

Swizzle: obtains the wxwy combination

`pub fn wxwz(self) -> Self`[src]

Swizzle: obtains the wxwz combination

`pub fn wxx(self) -> Vec3`[src]

Swizzle: obtains the wxx combination

`pub fn wxxw(self) -> Self`[src]

Swizzle: obtains the wxxw combination

`pub fn wxxx(self) -> Self`[src]

Swizzle: obtains the wxxx combination

`pub fn wxxy(self) -> Self`[src]

Swizzle: obtains the wxxy combination

`pub fn wxxz(self) -> Self`[src]

Swizzle: obtains the wxxz combination

`pub fn wxy(self) -> Vec3`[src]

Swizzle: obtains the wxy combination

`pub fn wxyw(self) -> Self`[src]

Swizzle: obtains the wxyw combination

`pub fn wxyx(self) -> Self`[src]

Swizzle: obtains the wxyx combination

`pub fn wxyy(self) -> Self`[src]

Swizzle: obtains the wxyy combination

`pub fn wxyz(self) -> Self`[src]

Swizzle: obtains the wxyz combination

`pub fn wxz(self) -> Vec3`[src]

Swizzle: obtains the wxz combination

`pub fn wxzw(self) -> Self`[src]

Swizzle: obtains the wxzw combination

`pub fn wxzx(self) -> Self`[src]

Swizzle: obtains the wxzx combination

`pub fn wxzy(self) -> Self`[src]

Swizzle: obtains the wxzy combination

`pub fn wxzz(self) -> Self`[src]

Swizzle: obtains the wxzz combination

`pub fn wy(self) -> Vec2`[src]

Swizzle: obtains the wy combination

`pub fn wyw(self) -> Vec3`[src]

Swizzle: obtains the wyw combination

`pub fn wyww(self) -> Self`[src]

Swizzle: obtains the wyww combination

`pub fn wywx(self) -> Self`[src]

Swizzle: obtains the wywx combination

`pub fn wywy(self) -> Self`[src]

Swizzle: obtains the wywy combination

`pub fn wywz(self) -> Self`[src]

Swizzle: obtains the wywz combination

`pub fn wyx(self) -> Vec3`[src]

Swizzle: obtains the wyx combination

`pub fn wyxw(self) -> Self`[src]

Swizzle: obtains the wyxw combination

`pub fn wyxx(self) -> Self`[src]

Swizzle: obtains the wyxx combination

`pub fn wyxy(self) -> Self`[src]

Swizzle: obtains the wyxy combination

`pub fn wyxz(self) -> Self`[src]

Swizzle: obtains the wyxz combination

`pub fn wyy(self) -> Vec3`[src]

Swizzle: obtains the wyy combination

`pub fn wyyw(self) -> Self`[src]

Swizzle: obtains the wyyw combination

`pub fn wyyx(self) -> Self`[src]

Swizzle: obtains the wyyx combination

`pub fn wyyy(self) -> Self`[src]

Swizzle: obtains the wyyy combination

`pub fn wyyz(self) -> Self`[src]

Swizzle: obtains the wyyz combination

`pub fn wyz(self) -> Vec3`[src]

Swizzle: obtains the wyz combination

`pub fn wyzw(self) -> Self`[src]

Swizzle: obtains the wyzw combination

`pub fn wyzx(self) -> Self`[src]

Swizzle: obtains the wyzx combination

`pub fn wyzy(self) -> Self`[src]

Swizzle: obtains the wyzy combination

`pub fn wyzz(self) -> Self`[src]

Swizzle: obtains the wyzz combination

`pub fn wz(self) -> Vec2`[src]

Swizzle: obtains the wz combination

`pub fn wzw(self) -> Vec3`[src]

Swizzle: obtains the wzw combination

`pub fn wzww(self) -> Self`[src]

Swizzle: obtains the wzww combination

`pub fn wzwx(self) -> Self`[src]

Swizzle: obtains the wzwx combination

`pub fn wzwy(self) -> Self`[src]

Swizzle: obtains the wzwy combination

`pub fn wzwz(self) -> Self`[src]

Swizzle: obtains the wzwz combination

`pub fn wzx(self) -> Vec3`[src]

Swizzle: obtains the wzx combination

`pub fn wzxw(self) -> Self`[src]

Swizzle: obtains the wzxw combination

`pub fn wzxx(self) -> Self`[src]

Swizzle: obtains the wzxx combination

`pub fn wzxy(self) -> Self`[src]

Swizzle: obtains the wzxy combination

`pub fn wzxz(self) -> Self`[src]

Swizzle: obtains the wzxz combination

`pub fn wzy(self) -> Vec3`[src]

Swizzle: obtains the wzy combination

`pub fn wzyw(self) -> Self`[src]

Swizzle: obtains the wzyw combination

`pub fn wzyx(self) -> Self`[src]

Swizzle: obtains the wzyx combination

`pub fn wzyy(self) -> Self`[src]

Swizzle: obtains the wzyy combination

`pub fn wzyz(self) -> Self`[src]

Swizzle: obtains the wzyz combination

`pub fn wzz(self) -> Vec3`[src]

Swizzle: obtains the wzz combination

`pub fn wzzw(self) -> Self`[src]

Swizzle: obtains the wzzw combination

`pub fn wzzx(self) -> Self`[src]

Swizzle: obtains the wzzx combination

`pub fn wzzy(self) -> Self`[src]

Swizzle: obtains the wzzy combination

`pub fn wzzz(self) -> Self`[src]

Swizzle: obtains the wzzz combination

`pub fn xw(self) -> Vec2`[src]

Swizzle: obtains the xw combination

`pub fn xww(self) -> Vec3`[src]

Swizzle: obtains the xww combination

`pub fn xwww(self) -> Self`[src]

Swizzle: obtains the xwww combination

`pub fn xwwx(self) -> Self`[src]

Swizzle: obtains the xwwx combination

`pub fn xwwy(self) -> Self`[src]

Swizzle: obtains the xwwy combination

`pub fn xwwz(self) -> Self`[src]

Swizzle: obtains the xwwz combination

`pub fn xwx(self) -> Vec3`[src]

Swizzle: obtains the xwx combination

`pub fn xwxw(self) -> Self`[src]

Swizzle: obtains the xwxw combination

`pub fn xwxx(self) -> Self`[src]

Swizzle: obtains the xwxx combination

`pub fn xwxy(self) -> Self`[src]

Swizzle: obtains the xwxy combination

`pub fn xwxz(self) -> Self`[src]

Swizzle: obtains the xwxz combination

`pub fn xwy(self) -> Vec3`[src]

Swizzle: obtains the xwy combination

`pub fn xwyw(self) -> Self`[src]

Swizzle: obtains the xwyw combination

`pub fn xwyx(self) -> Self`[src]

Swizzle: obtains the xwyx combination

`pub fn xwyy(self) -> Self`[src]

Swizzle: obtains the xwyy combination

`pub fn xwyz(self) -> Self`[src]

Swizzle: obtains the xwyz combination

`pub fn xwz(self) -> Vec3`[src]

Swizzle: obtains the xwz combination

`pub fn xwzw(self) -> Self`[src]

Swizzle: obtains the xwzw combination

`pub fn xwzx(self) -> Self`[src]

Swizzle: obtains the xwzx combination

`pub fn xwzy(self) -> Self`[src]

Swizzle: obtains the xwzy combination

`pub fn xwzz(self) -> Self`[src]

Swizzle: obtains the xwzz combination

`pub fn xx(self) -> Vec2`[src]

Swizzle: obtains the xx combination

`pub fn xxw(self) -> Vec3`[src]

Swizzle: obtains the xxw combination

`pub fn xxww(self) -> Self`[src]

Swizzle: obtains the xxww combination

`pub fn xxwx(self) -> Self`[src]

Swizzle: obtains the xxwx combination

`pub fn xxwy(self) -> Self`[src]

Swizzle: obtains the xxwy combination

`pub fn xxwz(self) -> Self`[src]

Swizzle: obtains the xxwz combination

`pub fn xxx(self) -> Vec3`[src]

Swizzle: obtains the xxx combination

`pub fn xxxw(self) -> Self`[src]

Swizzle: obtains the xxxw combination

`pub fn xxxx(self) -> Self`[src]

Swizzle: obtains the xxxx combination

`pub fn xxxy(self) -> Self`[src]

Swizzle: obtains the xxxy combination

`pub fn xxxz(self) -> Self`[src]

Swizzle: obtains the xxxz combination

`pub fn xxy(self) -> Vec3`[src]

Swizzle: obtains the xxy combination

`pub fn xxyw(self) -> Self`[src]

Swizzle: obtains the xxyw combination

`pub fn xxyx(self) -> Self`[src]

Swizzle: obtains the xxyx combination

`pub fn xxyy(self) -> Self`[src]

Swizzle: obtains the xxyy combination

`pub fn xxyz(self) -> Self`[src]

Swizzle: obtains the xxyz combination

`pub fn xxz(self) -> Vec3`[src]

Swizzle: obtains the xxz combination

`pub fn xxzw(self) -> Self`[src]

Swizzle: obtains the xxzw combination

`pub fn xxzx(self) -> Self`[src]

Swizzle: obtains the xxzx combination

`pub fn xxzy(self) -> Self`[src]

Swizzle: obtains the xxzy combination

`pub fn xxzz(self) -> Self`[src]

Swizzle: obtains the xxzz combination

`pub fn xy(self) -> Vec2`[src]

Swizzle: obtains the xy combination

`pub fn xyw(self) -> Vec3`[src]

Swizzle: obtains the xyw combination

`pub fn xyww(self) -> Self`[src]

Swizzle: obtains the xyww combination

`pub fn xywx(self) -> Self`[src]

Swizzle: obtains the xywx combination

`pub fn xywy(self) -> Self`[src]

Swizzle: obtains the xywy combination

`pub fn xywz(self) -> Self`[src]

Swizzle: obtains the xywz combination

`pub fn xyx(self) -> Vec3`[src]

Swizzle: obtains the xyx combination

`pub fn xyxw(self) -> Self`[src]

Swizzle: obtains the xyxw combination

`pub fn xyxx(self) -> Self`[src]

Swizzle: obtains the xyxx combination

`pub fn xyxy(self) -> Self`[src]

Swizzle: obtains the xyxy combination

`pub fn xyxz(self) -> Self`[src]

Swizzle: obtains the xyxz combination

`pub fn xyy(self) -> Vec3`[src]

Swizzle: obtains the xyy combination

`pub fn xyyw(self) -> Self`[src]

Swizzle: obtains the xyyw combination

`pub fn xyyx(self) -> Self`[src]

Swizzle: obtains the xyyx combination

`pub fn xyyy(self) -> Self`[src]

Swizzle: obtains the xyyy combination

`pub fn xyyz(self) -> Self`[src]

Swizzle: obtains the xyyz combination

`pub fn xyz(self) -> Vec3`[src]

Swizzle: obtains the xyz combination

`pub fn xyzw(self) -> Self`[src]

Swizzle: obtains the xyzw combination

`pub fn xyzx(self) -> Self`[src]

Swizzle: obtains the xyzx combination

`pub fn xyzy(self) -> Self`[src]

Swizzle: obtains the xyzy combination

`pub fn xyzz(self) -> Self`[src]

Swizzle: obtains the xyzz combination

`pub fn xz(self) -> Vec2`[src]

Swizzle: obtains the xz combination

`pub fn xzw(self) -> Vec3`[src]

Swizzle: obtains the xzw combination

`pub fn xzww(self) -> Self`[src]

Swizzle: obtains the xzww combination

`pub fn xzwx(self) -> Self`[src]

Swizzle: obtains the xzwx combination

`pub fn xzwy(self) -> Self`[src]

Swizzle: obtains the xzwy combination

`pub fn xzwz(self) -> Self`[src]

Swizzle: obtains the xzwz combination

`pub fn xzx(self) -> Vec3`[src]

Swizzle: obtains the xzx combination

`pub fn xzxw(self) -> Self`[src]

Swizzle: obtains the xzxw combination

`pub fn xzxx(self) -> Self`[src]

Swizzle: obtains the xzxx combination

`pub fn xzxy(self) -> Self`[src]

Swizzle: obtains the xzxy combination

`pub fn xzxz(self) -> Self`[src]

Swizzle: obtains the xzxz combination

`pub fn xzy(self) -> Vec3`[src]

Swizzle: obtains the xzy combination

`pub fn xzyw(self) -> Self`[src]

Swizzle: obtains the xzyw combination

`pub fn xzyx(self) -> Self`[src]

Swizzle: obtains the xzyx combination

`pub fn xzyy(self) -> Self`[src]

Swizzle: obtains the xzyy combination

`pub fn xzyz(self) -> Self`[src]

Swizzle: obtains the xzyz combination

`pub fn xzz(self) -> Vec3`[src]

Swizzle: obtains the xzz combination

`pub fn xzzw(self) -> Self`[src]

Swizzle: obtains the xzzw combination

`pub fn xzzx(self) -> Self`[src]

Swizzle: obtains the xzzx combination

`pub fn xzzy(self) -> Self`[src]

Swizzle: obtains the xzzy combination

`pub fn xzzz(self) -> Self`[src]

Swizzle: obtains the xzzz combination

`pub fn yw(self) -> Vec2`[src]

Swizzle: obtains the yw combination

`pub fn yww(self) -> Vec3`[src]

Swizzle: obtains the yww combination

`pub fn ywww(self) -> Self`[src]

Swizzle: obtains the ywww combination

`pub fn ywwx(self) -> Self`[src]

Swizzle: obtains the ywwx combination

`pub fn ywwy(self) -> Self`[src]

Swizzle: obtains the ywwy combination

`pub fn ywwz(self) -> Self`[src]

Swizzle: obtains the ywwz combination

`pub fn ywx(self) -> Vec3`[src]

Swizzle: obtains the ywx combination

`pub fn ywxw(self) -> Self`[src]

Swizzle: obtains the ywxw combination

`pub fn ywxx(self) -> Self`[src]

Swizzle: obtains the ywxx combination

`pub fn ywxy(self) -> Self`[src]

Swizzle: obtains the ywxy combination

`pub fn ywxz(self) -> Self`[src]

Swizzle: obtains the ywxz combination

`pub fn ywy(self) -> Vec3`[src]

Swizzle: obtains the ywy combination

`pub fn ywyw(self) -> Self`[src]

Swizzle: obtains the ywyw combination

`pub fn ywyx(self) -> Self`[src]

Swizzle: obtains the ywyx combination

`pub fn ywyy(self) -> Self`[src]

Swizzle: obtains the ywyy combination

`pub fn ywyz(self) -> Self`[src]

Swizzle: obtains the ywyz combination

`pub fn ywz(self) -> Vec3`[src]

Swizzle: obtains the ywz combination

`pub fn ywzw(self) -> Self`[src]

Swizzle: obtains the ywzw combination

`pub fn ywzx(self) -> Self`[src]

Swizzle: obtains the ywzx combination

`pub fn ywzy(self) -> Self`[src]

Swizzle: obtains the ywzy combination

`pub fn ywzz(self) -> Self`[src]

Swizzle: obtains the ywzz combination

`pub fn yx(self) -> Vec2`[src]

Swizzle: obtains the yx combination

`pub fn yxw(self) -> Vec3`[src]

Swizzle: obtains the yxw combination

`pub fn yxww(self) -> Self`[src]

Swizzle: obtains the yxww combination

`pub fn yxwx(self) -> Self`[src]

Swizzle: obtains the yxwx combination

`pub fn yxwy(self) -> Self`[src]

Swizzle: obtains the yxwy combination

`pub fn yxwz(self) -> Self`[src]

Swizzle: obtains the yxwz combination

`pub fn yxx(self) -> Vec3`[src]

Swizzle: obtains the yxx combination

`pub fn yxxw(self) -> Self`[src]

Swizzle: obtains the yxxw combination

`pub fn yxxx(self) -> Self`[src]

Swizzle: obtains the yxxx combination

`pub fn yxxy(self) -> Self`[src]

Swizzle: obtains the yxxy combination

`pub fn yxxz(self) -> Self`[src]

Swizzle: obtains the yxxz combination

`pub fn yxy(self) -> Vec3`[src]

Swizzle: obtains the yxy combination

`pub fn yxyw(self) -> Self`[src]

Swizzle: obtains the yxyw combination

`pub fn yxyx(self) -> Self`[src]

Swizzle: obtains the yxyx combination

`pub fn yxyy(self) -> Self`[src]

Swizzle: obtains the yxyy combination

`pub fn yxyz(self) -> Self`[src]

Swizzle: obtains the yxyz combination

`pub fn yxz(self) -> Vec3`[src]

Swizzle: obtains the yxz combination

`pub fn yxzw(self) -> Self`[src]

Swizzle: obtains the yxzw combination

`pub fn yxzx(self) -> Self`[src]

Swizzle: obtains the yxzx combination

`pub fn yxzy(self) -> Self`[src]

Swizzle: obtains the yxzy combination

`pub fn yxzz(self) -> Self`[src]

Swizzle: obtains the yxzz combination

`pub fn yy(self) -> Vec2`[src]

Swizzle: obtains the yy combination

`pub fn yyw(self) -> Vec3`[src]

Swizzle: obtains the yyw combination

`pub fn yyww(self) -> Self`[src]

Swizzle: obtains the yyww combination

`pub fn yywx(self) -> Self`[src]

Swizzle: obtains the yywx combination

`pub fn yywy(self) -> Self`[src]

Swizzle: obtains the yywy combination

`pub fn yywz(self) -> Self`[src]

Swizzle: obtains the yywz combination

`pub fn yyx(self) -> Vec3`[src]

Swizzle: obtains the yyx combination

`pub fn yyxw(self) -> Self`[src]

Swizzle: obtains the yyxw combination

`pub fn yyxx(self) -> Self`[src]

Swizzle: obtains the yyxx combination

`pub fn yyxy(self) -> Self`[src]

Swizzle: obtains the yyxy combination

`pub fn yyxz(self) -> Self`[src]

Swizzle: obtains the yyxz combination

`pub fn yyy(self) -> Vec3`[src]

Swizzle: obtains the yyy combination

`pub fn yyyw(self) -> Self`[src]

Swizzle: obtains the yyyw combination

`pub fn yyyx(self) -> Self`[src]

Swizzle: obtains the yyyx combination

`pub fn yyyy(self) -> Self`[src]

Swizzle: obtains the yyyy combination

`pub fn yyyz(self) -> Self`[src]

Swizzle: obtains the yyyz combination

`pub fn yyz(self) -> Vec3`[src]

Swizzle: obtains the yyz combination

`pub fn yyzw(self) -> Self`[src]

Swizzle: obtains the yyzw combination

`pub fn yyzx(self) -> Self`[src]

Swizzle: obtains the yyzx combination

`pub fn yyzy(self) -> Self`[src]

Swizzle: obtains the yyzy combination

`pub fn yyzz(self) -> Self`[src]

Swizzle: obtains the yyzz combination

`pub fn yz(self) -> Vec2`[src]

Swizzle: obtains the yz combination

`pub fn yzw(self) -> Vec3`[src]

Swizzle: obtains the yzw combination

`pub fn yzww(self) -> Self`[src]

Swizzle: obtains the yzww combination

`pub fn yzwx(self) -> Self`[src]

Swizzle: obtains the yzwx combination

`pub fn yzwy(self) -> Self`[src]

Swizzle: obtains the yzwy combination

`pub fn yzwz(self) -> Self`[src]

Swizzle: obtains the yzwz combination

`pub fn yzx(self) -> Vec3`[src]

Swizzle: obtains the yzx combination

`pub fn yzxw(self) -> Self`[src]

Swizzle: obtains the yzxw combination

`pub fn yzxx(self) -> Self`[src]

Swizzle: obtains the yzxx combination

`pub fn yzxy(self) -> Self`[src]

Swizzle: obtains the yzxy combination

`pub fn yzxz(self) -> Self`[src]

Swizzle: obtains the yzxz combination

`pub fn yzy(self) -> Vec3`[src]

Swizzle: obtains the yzy combination

`pub fn yzyw(self) -> Self`[src]

Swizzle: obtains the yzyw combination

`pub fn yzyx(self) -> Self`[src]

Swizzle: obtains the yzyx combination

`pub fn yzyy(self) -> Self`[src]

Swizzle: obtains the yzyy combination

`pub fn yzyz(self) -> Self`[src]

Swizzle: obtains the yzyz combination

`pub fn yzz(self) -> Vec3`[src]

Swizzle: obtains the yzz combination

`pub fn yzzw(self) -> Self`[src]

Swizzle: obtains the yzzw combination

`pub fn yzzx(self) -> Self`[src]

Swizzle: obtains the yzzx combination

`pub fn yzzy(self) -> Self`[src]

Swizzle: obtains the yzzy combination

`pub fn yzzz(self) -> Self`[src]

Swizzle: obtains the yzzz combination

`pub fn zw(self) -> Vec2`[src]

Swizzle: obtains the zw combination

`pub fn zww(self) -> Vec3`[src]

Swizzle: obtains the zww combination

`pub fn zwww(self) -> Self`[src]

Swizzle: obtains the zwww combination

`pub fn zwwx(self) -> Self`[src]

Swizzle: obtains the zwwx combination

`pub fn zwwy(self) -> Self`[src]

Swizzle: obtains the zwwy combination

`pub fn zwwz(self) -> Self`[src]

Swizzle: obtains the zwwz combination

`pub fn zwx(self) -> Vec3`[src]

Swizzle: obtains the zwx combination

`pub fn zwxw(self) -> Self`[src]

Swizzle: obtains the zwxw combination

`pub fn zwxx(self) -> Self`[src]

Swizzle: obtains the zwxx combination

`pub fn zwxy(self) -> Self`[src]

Swizzle: obtains the zwxy combination

`pub fn zwxz(self) -> Self`[src]

Swizzle: obtains the zwxz combination

`pub fn zwy(self) -> Vec3`[src]

Swizzle: obtains the zwy combination

`pub fn zwyw(self) -> Self`[src]

Swizzle: obtains the zwyw combination

`pub fn zwyx(self) -> Self`[src]

Swizzle: obtains the zwyx combination

`pub fn zwyy(self) -> Self`[src]

Swizzle: obtains the zwyy combination

`pub fn zwyz(self) -> Self`[src]

Swizzle: obtains the zwyz combination

`pub fn zwz(self) -> Vec3`[src]

Swizzle: obtains the zwz combination

`pub fn zwzw(self) -> Self`[src]

Swizzle: obtains the zwzw combination

`pub fn zwzx(self) -> Self`[src]

Swizzle: obtains the zwzx combination

`pub fn zwzy(self) -> Self`[src]

Swizzle: obtains the zwzy combination

`pub fn zwzz(self) -> Self`[src]

Swizzle: obtains the zwzz combination

`pub fn zx(self) -> Vec2`[src]

Swizzle: obtains the zx combination

`pub fn zxw(self) -> Vec3`[src]

Swizzle: obtains the zxw combination

`pub fn zxww(self) -> Self`[src]

Swizzle: obtains the zxww combination

`pub fn zxwx(self) -> Self`[src]

Swizzle: obtains the zxwx combination

`pub fn zxwy(self) -> Self`[src]

Swizzle: obtains the zxwy combination

`pub fn zxwz(self) -> Self`[src]

Swizzle: obtains the zxwz combination

`pub fn zxx(self) -> Vec3`[src]

Swizzle: obtains the zxx combination

`pub fn zxxw(self) -> Self`[src]

Swizzle: obtains the zxxw combination

`pub fn zxxx(self) -> Self`[src]

Swizzle: obtains the zxxx combination

`pub fn zxxy(self) -> Self`[src]

Swizzle: obtains the zxxy combination

`pub fn zxxz(self) -> Self`[src]

Swizzle: obtains the zxxz combination

`pub fn zxy(self) -> Vec3`[src]

Swizzle: obtains the zxy combination

`pub fn zxyw(self) -> Self`[src]

Swizzle: obtains the zxyw combination

`pub fn zxyx(self) -> Self`[src]

Swizzle: obtains the zxyx combination

`pub fn zxyy(self) -> Self`[src]

Swizzle: obtains the zxyy combination

`pub fn zxyz(self) -> Self`[src]

Swizzle: obtains the zxyz combination

`pub fn zxz(self) -> Vec3`[src]

Swizzle: obtains the zxz combination

`pub fn zxzw(self) -> Self`[src]

Swizzle: obtains the zxzw combination

`pub fn zxzx(self) -> Self`[src]

Swizzle: obtains the zxzx combination

`pub fn zxzy(self) -> Self`[src]

Swizzle: obtains the zxzy combination

`pub fn zxzz(self) -> Self`[src]

Swizzle: obtains the zxzz combination

`pub fn zy(self) -> Vec2`[src]

Swizzle: obtains the zy combination

`pub fn zyw(self) -> Vec3`[src]

Swizzle: obtains the zyw combination

`pub fn zyww(self) -> Self`[src]

Swizzle: obtains the zyww combination

`pub fn zywx(self) -> Self`[src]

Swizzle: obtains the zywx combination

`pub fn zywy(self) -> Self`[src]

Swizzle: obtains the zywy combination

`pub fn zywz(self) -> Self`[src]

Swizzle: obtains the zywz combination

`pub fn zyx(self) -> Vec3`[src]

Swizzle: obtains the zyx combination

`pub fn zyxw(self) -> Self`[src]

Swizzle: obtains the zyxw combination

`pub fn zyxx(self) -> Self`[src]

Swizzle: obtains the zyxx combination

`pub fn zyxy(self) -> Self`[src]

Swizzle: obtains the zyxy combination

`pub fn zyxz(self) -> Self`[src]

Swizzle: obtains the zyxz combination

`pub fn zyy(self) -> Vec3`[src]

Swizzle: obtains the zyy combination

`pub fn zyyw(self) -> Self`[src]

Swizzle: obtains the zyyw combination

`pub fn zyyx(self) -> Self`[src]

Swizzle: obtains the zyyx combination

`pub fn zyyy(self) -> Self`[src]

Swizzle: obtains the zyyy combination

`pub fn zyyz(self) -> Self`[src]

Swizzle: obtains the zyyz combination

`pub fn zyz(self) -> Vec3`[src]

Swizzle: obtains the zyz combination

`pub fn zyzw(self) -> Self`[src]

Swizzle: obtains the zyzw combination

`pub fn zyzx(self) -> Self`[src]

Swizzle: obtains the zyzx combination

`pub fn zyzy(self) -> Self`[src]

Swizzle: obtains the zyzy combination

`pub fn zyzz(self) -> Self`[src]

Swizzle: obtains the zyzz combination

`pub fn zz(self) -> Vec2`[src]

Swizzle: obtains the zz combination

`pub fn zzw(self) -> Vec3`[src]

Swizzle: obtains the zzw combination

`pub fn zzww(self) -> Self`[src]

Swizzle: obtains the zzww combination

`pub fn zzwx(self) -> Self`[src]

Swizzle: obtains the zzwx combination

`pub fn zzwy(self) -> Self`[src]

Swizzle: obtains the zzwy combination

`pub fn zzwz(self) -> Self`[src]

Swizzle: obtains the zzwz combination

`pub fn zzx(self) -> Vec3`[src]

Swizzle: obtains the zzx combination

`pub fn zzxw(self) -> Self`[src]

Swizzle: obtains the zzxw combination

`pub fn zzxx(self) -> Self`[src]

Swizzle: obtains the zzxx combination

`pub fn zzxy(self) -> Self`[src]

Swizzle: obtains the zzxy combination

`pub fn zzxz(self) -> Self`[src]

Swizzle: obtains the zzxz combination

`pub fn zzy(self) -> Vec3`[src]

Swizzle: obtains the zzy combination

`pub fn zzyw(self) -> Self`[src]

Swizzle: obtains the zzyw combination

`pub fn zzyx(self) -> Self`[src]

Swizzle: obtains the zzyx combination

`pub fn zzyy(self) -> Self`[src]

Swizzle: obtains the zzyy combination

`pub fn zzyz(self) -> Self`[src]

Swizzle: obtains the zzyz combination

`pub fn zzz(self) -> Vec3`[src]

Swizzle: obtains the zzz combination

`pub fn zzzw(self) -> Self`[src]

Swizzle: obtains the zzzw combination

`pub fn zzzx(self) -> Self`[src]

Swizzle: obtains the zzzx combination

`pub fn zzzy(self) -> Self`[src]

Swizzle: obtains the zzzy combination

`pub fn zzzz(self) -> Self`[src]

Swizzle: obtains the zzzz combination

Trait Implementations

`impl Display for Vec4`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

Display formats without labels like a 4-tuple.

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

`impl Debug for Vec4`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

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

`impl UpperExp for Vec4`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

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 LowerExp for Vec4`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

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 PartialEq<Vec4> for Vec4`[src]

`fn eq(&self, rhs: &Self) -> bool`[src]

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for !=.

`impl Add<Vec4> for Vec4`[src]

`type Output = Self`

The resulting type after applying the + operator.

`fn add(self, rhs: Self) -> Self`[src]

`impl Add<f32> for Vec4`[src]

`type Output = Self`

The resulting type after applying the + operator.

`fn add(self, rhs: f32) -> Self`[src]

`impl Add<Vec4> for f32`[src]

`type Output = Vec4`

The resulting type after applying the + operator.

`fn add(self, rhs: Vec4) -> Vec4`[src]

`impl Sub<Vec4> for Vec4`[src]

`type Output = Self`

The resulting type after applying the - operator.

`fn sub(self, rhs: Self) -> Self`[src]

`impl Sub<f32> for Vec4`[src]

`type Output = Self`

The resulting type after applying the - operator.

`fn sub(self, rhs: f32) -> Self`[src]

`impl Sub<Vec4> for f32`[src]

`type Output = Vec4`

The resulting type after applying the - operator.

`fn sub(self, rhs: Vec4) -> Vec4`[src]

`impl Mul<f32> for Vec4`[src]

`type Output = Self`

The resulting type after applying the * operator.

`fn mul(self, rhs: f32) -> Self`[src]

`impl Mul<Vec4> for f32`[src]

`type Output = Vec4`

The resulting type after applying the * operator.

`fn mul(self, rhs: Vec4) -> Vec4`[src]

`impl Mul<Vec4> for Vec4`[src]

`type Output = Self`

The resulting type after applying the * operator.

`fn mul(self, rhs: Self) -> Self`[src]

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

`impl Mul<Vec4> for Mat4`[src]

`type Output = Vec4`

The resulting type after applying the * operator.

`fn mul(self, v4: Vec4) -> Vec4`[src]

`impl Neg for Vec4`[src]

`type Output = Self`

The resulting type after applying the - operator.

`fn neg(self) -> Self`[src]

`impl AddAssign<Vec4> for Vec4`[src]

`fn add_assign(&mut self, rhs: Self)`[src]

`impl AddAssign<f32> for Vec4`[src]

`fn add_assign(&mut self, rhs: f32)`[src]

`impl SubAssign<Vec4> for Vec4`[src]

`fn sub_assign(&mut self, rhs: Self)`[src]

`impl SubAssign<f32> for Vec4`[src]

`fn sub_assign(&mut self, rhs: f32)`[src]

`impl MulAssign<f32> for Vec4`[src]

`fn mul_assign(&mut self, rhs: f32)`[src]

`impl MulAssign<Vec4> for Vec4`[src]

`fn mul_assign(&mut self, rhs: Self)`[src]

`impl Index<usize> for Vec4`[src]

`type Output = f32`

The returned type after indexing.

`fn index(&self, index: usize) -> &f32`[src]

`impl IndexMut<usize> for Vec4`[src]

`fn index_mut(&mut self, index: usize) -> &mut f32`[src]

`impl Copy for Vec4`[src]

`impl AsRef<[f32; 4]> for Vec4`[src]

`fn as_ref(&self) -> &[f32; 4]`[src]

`impl AsMut<[f32; 4]> for Vec4`[src]

`fn as_mut(&mut self) -> &mut [f32; 4]`[src]

`impl From<[f32; 4]> for Vec4`[src]

`fn from([x, y, z, w]: [f32; 4]) -> Self`[src]

`impl From<Vec4> for [f32; 4]`[src]

`fn from(v4: Vec4) -> Self`[src]

`impl Clone for Vec4`[src]

`fn clone(&self) -> Vec4`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from source. Read more

`impl Default for Vec4`[src]

`fn default() -> Vec4`[src]

`impl Pod for Vec4`[src]

`impl Zeroable for Vec4`[src]

`fn zeroed() -> Self`[src]

Calls zeroed. Read more

Auto Trait Implementations

`impl Unpin for Vec4`

`impl Sync for Vec4`

`impl Send for Vec4`

Blanket Implementations

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

[−][src]Struct hektor::Vec4

Methods

impl Vec4[src]

Accessors

pub fn x(self) -> f32[src]

pub fn y(self) -> f32[src]

pub fn z(self) -> f32[src]

pub fn w(self) -> f32[src]

pub fn x_mut(&mut self) -> &mut f32[src]

pub fn y_mut(&mut self) -> &mut f32[src]

pub fn z_mut(&mut self) -> &mut f32[src]

pub fn w_mut(&mut self) -> &mut f32[src]

impl Vec4[src]

Constructors

pub fn new(x: f32, y: f32, z: f32, w: f32) -> Self[src]

pub fn splat(v: f32) -> Self[src]

pub fn to_vec3(self) -> Vec3[src]

impl Vec4[src]

Operations

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

pub fn length(self) -> f32[src]

pub fn length2(self) -> f32[src]

pub fn normalize(self) -> Self[src]

impl Vec4[src]

pub fn ww(self) -> Vec2[src]

pub fn www(self) -> Vec3[src]

pub fn wwww(self) -> Self[src]

pub fn wwwx(self) -> Self[src]

pub fn wwwy(self) -> Self[src]

pub fn wwwz(self) -> Self[src]

pub fn wwx(self) -> Vec3[src]

pub fn wwxw(self) -> Self[src]

pub fn wwxx(self) -> Self[src]

pub fn wwxy(self) -> Self[src]

pub fn wwxz(self) -> Self[src]

pub fn wwy(self) -> Vec3[src]

pub fn wwyw(self) -> Self[src]

pub fn wwyx(self) -> Self[src]

pub fn wwyy(self) -> Self[src]

pub fn wwyz(self) -> Self[src]

pub fn wwz(self) -> Vec3[src]

pub fn wwzw(self) -> Self[src]

pub fn wwzx(self) -> Self[src]

pub fn wwzy(self) -> Self[src]

pub fn wwzz(self) -> Self[src]

pub fn wx(self) -> Vec2[src]

pub fn wxw(self) -> Vec3[src]

pub fn wxww(self) -> Self[src]

pub fn wxwx(self) -> Self[src]

pub fn wxwy(self) -> Self[src]

pub fn wxwz(self) -> Self[src]

pub fn wxx(self) -> Vec3[src]

pub fn wxxw(self) -> Self[src]

pub fn wxxx(self) -> Self[src]

pub fn wxxy(self) -> Self[src]

pub fn wxxz(self) -> Self[src]

pub fn wxy(self) -> Vec3[src]

pub fn wxyw(self) -> Self[src]

pub fn wxyx(self) -> Self[src]

pub fn wxyy(self) -> Self[src]

pub fn wxyz(self) -> Self[src]

pub fn wxz(self) -> Vec3[src]

pub fn wxzw(self) -> Self[src]

pub fn wxzx(self) -> Self[src]

pub fn wxzy(self) -> Self[src]

pub fn wxzz(self) -> Self[src]

pub fn wy(self) -> Vec2[src]

pub fn wyw(self) -> Vec3[src]

pub fn wyww(self) -> Self[src]

pub fn wywx(self) -> Self[src]

pub fn wywy(self) -> Self[src]

pub fn wywz(self) -> Self[src]

pub fn wyx(self) -> Vec3[src]

pub fn wyxw(self) -> Self[src]

pub fn wyxx(self) -> Self[src]

pub fn wyxy(self) -> Self[src]

pub fn wyxz(self) -> Self[src]

pub fn wyy(self) -> Vec3[src]

pub fn wyyw(self) -> Self[src]

pub fn wyyx(self) -> Self[src]

`impl Vec4`[src]

`pub fn x(self) -> f32`[src]

`pub fn y(self) -> f32`[src]

`pub fn z(self) -> f32`[src]

`pub fn w(self) -> f32`[src]

`pub fn x_mut(&mut self) -> &mut f32`[src]

`pub fn y_mut(&mut self) -> &mut f32`[src]

`pub fn z_mut(&mut self) -> &mut f32`[src]

`pub fn w_mut(&mut self) -> &mut f32`[src]

`impl Vec4`[src]

`pub fn new(x: f32, y: f32, z: f32, w: f32) -> Self`[src]

`pub fn splat(v: f32) -> Self`[src]

`pub fn to_vec3(self) -> Vec3`[src]

`impl Vec4`[src]

`pub fn dot(self, rhs: Self) -> f32`[src]

`pub fn length(self) -> f32`[src]

`pub fn length2(self) -> f32`[src]

`pub fn normalize(self) -> Self`[src]

`impl Vec4`[src]

`pub fn ww(self) -> Vec2`[src]

`pub fn www(self) -> Vec3`[src]

`pub fn wwww(self) -> Self`[src]

`pub fn wwwx(self) -> Self`[src]

`pub fn wwwy(self) -> Self`[src]

`pub fn wwwz(self) -> Self`[src]

`pub fn wwx(self) -> Vec3`[src]

`pub fn wwxw(self) -> Self`[src]

`pub fn wwxx(self) -> Self`[src]

`pub fn wwxy(self) -> Self`[src]

`pub fn wwxz(self) -> Self`[src]

`pub fn wwy(self) -> Vec3`[src]

`pub fn wwyw(self) -> Self`[src]

`pub fn wwyx(self) -> Self`[src]

`pub fn wwyy(self) -> Self`[src]

`pub fn wwyz(self) -> Self`[src]

`pub fn wwz(self) -> Vec3`[src]

`pub fn wwzw(self) -> Self`[src]

`pub fn wwzx(self) -> Self`[src]

`pub fn wwzy(self) -> Self`[src]

`pub fn wwzz(self) -> Self`[src]

`pub fn wx(self) -> Vec2`[src]

`pub fn wxw(self) -> Vec3`[src]

`pub fn wxww(self) -> Self`[src]

`pub fn wxwx(self) -> Self`[src]

`pub fn wxwy(self) -> Self`[src]

`pub fn wxwz(self) -> Self`[src]

`pub fn wxx(self) -> Vec3`[src]

`pub fn wxxw(self) -> Self`[src]

`pub fn wxxx(self) -> Self`[src]

`pub fn wxxy(self) -> Self`[src]

`pub fn wxxz(self) -> Self`[src]

`pub fn wxy(self) -> Vec3`[src]

`pub fn wxyw(self) -> Self`[src]

`pub fn wxyx(self) -> Self`[src]

`pub fn wxyy(self) -> Self`[src]

`pub fn wxyz(self) -> Self`[src]

`pub fn wxz(self) -> Vec3`[src]

`pub fn wxzw(self) -> Self`[src]

`pub fn wxzx(self) -> Self`[src]

`pub fn wxzy(self) -> Self`[src]

`pub fn wxzz(self) -> Self`[src]

`pub fn wy(self) -> Vec2`[src]

`pub fn wyw(self) -> Vec3`[src]

`pub fn wyww(self) -> Self`[src]

`pub fn wywx(self) -> Self`[src]

`pub fn wywy(self) -> Self`[src]

`pub fn wywz(self) -> Self`[src]

`pub fn wyx(self) -> Vec3`[src]

`pub fn wyxw(self) -> Self`[src]

`pub fn wyxx(self) -> Self`[src]

`pub fn wyxy(self) -> Self`[src]

`pub fn wyxz(self) -> Self`[src]

`pub fn wyy(self) -> Vec3`[src]

`pub fn wyyw(self) -> Self`[src]

`pub fn wyyx(self) -> Self`[src]

`pub fn wyyy(self) -> Self`[src]

`pub fn wyyz(self) -> Self`[src]

`pub fn wyz(self) -> Vec3`[src]

`pub fn wyzw(self) -> Self`[src]

`pub fn wyzx(self) -> Self`[src]