[−][src]Struct ultraviolet::int::Vec3u

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

A set of three coordinates which may be interpreted as a point or vector in 3d space, or as a homogeneous 2d vector or point.

Generally this distinction between a point and vector is more of a pain than it is worth to distinguish on a type level, however when converting to and from homogeneous coordinates it is quite important.

Fields

x: u32y: u32z: u32

Methods

`impl Vec3u`[src]

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

`pub fn broadcast(val: u32) -> Self`[src]

`pub fn unit_x() -> Self`[src]

`pub fn unit_y() -> Self`[src]

`pub fn unit_z() -> Self`[src]

`pub fn cross(&self, other: Vec3u) -> Self`[src]

`pub fn into_homogeneous_point(self) -> Vec4u`[src]

Create a homogeneous 3d point from this vector interpreted as a point, meaning the homogeneous component will start with a value of 1.

`pub fn into_homogeneous_vector(self) -> Vec4u`[src]

Create a homogeneous 3d vector from this vector, meaning the homogeneous component will always have a value of 0.

`pub fn from_homogeneous_point(v: Vec4u) -> Self`[src]

Create a 3d point from a homogeneous 3d point, performing division by the homogeneous component. This should not be used for homogeneous 3d vectors, which will have 0 as their homogeneous component.

`pub fn from_homogeneous_vector(v: Vec4u) -> Self`[src]

Create a 3d vector from homogeneous 2d vector, which simply discards the homogeneous component.

`pub fn dot(&self, other: Vec3u) -> u32`[src]

`pub fn reflect(&mut self, normal: Vec3u)`[src]

`pub fn reflected(&self, normal: Vec3u) -> Self`[src]

`pub fn mag(&self) -> u32`[src]

`pub fn mag_sq(&self) -> u32`[src]

`pub fn mul_add(&self, mul: Vec3u, add: Vec3u) -> Self`[src]

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

`pub fn clamp(&mut self, min: Self, max: Self)`[src]

`pub fn clamped(self, min: Self, max: Self) -> Self`[src]

`pub fn map<F>(&self, f: F) -> Self where F: Fn(u32) -> u32,` [src]

`pub fn apply<F>(&mut self, f: F) where F: Fn(u32) -> u32,` [src]

`pub fn max_by_component(self, other: Self) -> Self`[src]

`pub fn min_by_component(self, other: Self) -> Self`[src]

`pub fn component_max(&self) -> u32`[src]

`pub fn component_min(&self) -> u32`[src]

`pub fn zero() -> Self`[src]

`pub fn one() -> Self`[src]

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

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

`pub fn layout() -> Layout`[src]

`pub fn as_slice(&self) -> &[u32]`[src]

`pub fn as_array(&self) -> [u32; 3]`[src]

`pub fn as_byte_slice(&self) -> &[u8]`[src]

`pub fn as_mut_slice(&mut self) -> &mut [u32]`[src]

`pub fn as_mut_byte_slice(&mut self) -> &mut [u8]`[src]

`pub fn as_ptr(&self) -> *const u32`[src]

Returns a constant unsafe pointer to the underlying data in the underlying type. This function is safe because all types here are repr(C) and can be represented as their underlying type.

Safety

It is up to the caller to correctly use this pointer and its bounds.

`pub fn as_mut_ptr(&mut self) -> *mut u32`[src]

Returns a mutable unsafe pointer to the underlying data in the underlying type. This function is safe because all types here are repr(C) and can be represented as their underlying type.