Struct Plane

#[repr(C)]
pub struct Plane { /* private fields */ }

A value type that represents a plane in 3D space with the equation: a*x + b*y + c*z + d = 0.

Points can implicitly deref into Vec4 to allow for easily using points in places where vectors are expected.

Implementations

impl Plane

pub const fn new(a: f32, b: f32, c: f32, d: f32) -> Self

Creates a new plane with the given coefficients.

Parameters

• a - The first component of the plane
• b - The second component of the plane
• c - The third component of the plane
• d - The fourth component of the plane

pub const fn from_normal_distance(normal: &Vec3, distance: f32) -> Self

Create a new plane from a normal and distance

Parameters

• normal - The normal of the plane
• distance - The distance of the plane

pub fn from_point_and_normal(point: &Point3, normal: &Vec3) -> Self

Create a new plane from a point and normal

Parameters

• point - The point on the plane
• normal - The normal of the plane

pub fn from_points_clockwise(p0: &Point3, p1: &Point3, p2: &Point3) -> Self

Create a new plane from three points in counter-clockwise order.

Parameters

• p0 - The first point
• p1 - The second point
• p2 - The third point

pub fn from_points_counter_clockwise( p0: &Point3, p1: &Point3, p2: &Point3, ) -> Self

Create a new plane from three points in counter-clockwise order. This is the same as from_points_clockwise but with the points in a different order.

Parameters

• p0 - The first point
• p1 - The second point
• p2 - The third point

impl Plane

pub const fn a(&self) -> f32

Gets the ‘a’ component of the plane

pub const fn b(&self) -> f32

Gets the ‘b’ component of the plane

pub const fn c(&self) -> f32

Gets the ‘c’ component of the plane

pub const fn d(&self) -> f32

Gets the ‘d’ component of the plane

pub const fn ab(&self) -> &Vec2

Gets the ‘a’ and ‘b’ components of the plane as a 2D vector

pub const fn bc(&self) -> &Vec2

Gets the ‘b’ and ‘c’ components of the plane as a 2D vector

pub const fn cd(&self) -> &Vec2

Gets the ‘c’ and ‘d’ components of the plane as a 2D vector

pub const fn abc(&self) -> &Vec3

Gets the ‘a’, ‘b’, and ‘c’ components of the plane as a 3D vector

pub const fn bcd(&self) -> &Vec3

Gets the ‘b’, ‘c’, and ‘d’ components of the plane as a 3D vector

pub const fn abcd(&self) -> &Vec4

Gets the ‘a’, ‘b’, ‘c’, and ‘d’ components of the plane as a 4D vector

pub const fn normal(&self) -> &Vec3

Gets the normal of this plane

pub fn a_mut(&mut self) -> &mut f32

Gets the ‘a’ component of the plane

pub fn b_mut(&mut self) -> &mut f32

Gets the ‘b’ component of the plane

pub fn c_mut(&mut self) -> &mut f32

Gets the ‘c’ component of the plane

pub fn d_mut(&mut self) -> &mut f32

Gets the ‘d’ component of the plane

pub fn ab_mut(&mut self) -> &mut Vec2

Gets the ‘a’ and ‘b’ components of the plane as a 2D vector

pub fn bc_mut(&mut self) -> &mut Vec2

Gets the ‘b’ and ‘c’ components of the plane as a 2D vector

pub fn cd_mut(&mut self) -> &mut Vec2

Gets the ‘c’ and ‘d’ components of the plane as a 2D vector

pub fn abc_mut(&mut self) -> &mut Vec3

Gets the ‘a’, ‘b’, and ‘c’ components of the plane as a 3D vector

pub fn bcd_mut(&mut self) -> &mut Vec3

Gets the ‘b’, ‘c’, and ‘d’ components of the plane as a 3D vector

pub fn abcd_mut(&mut self) -> &mut Vec4

Gets the ‘a’, ‘b’, ‘c’, and ‘d’ components of the plane as a 4D vector

pub fn set_a(&mut self, a: f32)

Sets the ‘a’ component of the plane

Parameters

• a - The new value of the ‘a’ component

pub fn set_b(&mut self, b: f32)

Sets the ‘b’ component of the plane

Parameters

• b - The new value of the ‘b’ component

pub fn set_c(&mut self, c: f32)

Sets the ‘c’ component of the plane

Parameters

• c - The new value of the ‘c’ component

pub fn set_d(&mut self, d: f32)

Sets the ‘d’ component of the plane

Parameters

• d - The new value of the ‘d’ component

pub fn set_ab(&mut self, ab: &Vec2)

Gets the ‘a’ and ‘b’ components of the plane

Parameters

• ab - The new value of the ‘a’ and ‘b’ components

pub fn set_bc(&mut self, bc: &Vec2)

Gets the ‘b’ and ‘c’ components of the plane

Parameters

• bc - The new value of the ‘b’ and ‘c’ components

pub fn set_cd(&mut self, cd: &Vec2)

Gets the ‘c’ and ‘d’ components of the plane

Parameters

• cd - The new value of the ‘c’ and ‘d’ components

pub fn set_abc(&mut self, abc: &Vec3)

Gets the ‘a’, ‘b’, and ‘c’ components of the plane

Parameters

• abc - The new value of the ‘a’, ‘b’, and ‘c’ components

pub fn set_bcd(&mut self, bcd: &Vec3)

Gets the ‘b’, ‘c’, and ‘d’ components of the plane

Parameters

• bcd - The new value of the ‘b’, ‘c’, and ‘d’ components

pub fn set(&mut self, abcd: &Vec4)

Gets the ‘a’, ‘b’, ‘c’, and ‘d’ components of the plane

Parameters

• abcd - The new value of the ‘a’, ‘b’, ‘c’, and ‘d’ components

impl Plane

pub const fn as_vec4(&self) -> &Vec4

Gets the normal of this plane

pub fn as_mut_vec4(&mut self) -> &mut Vec4

Gets the normal of this plane

impl Plane

pub fn distance_to_point(&self, point: &Point3) -> f32

Gets the distance to the point from this plane

Parameters

• point - The point to get the distance to

pub fn contains_point(&self, point: &Point3) -> bool

Checks if the plane contains the point within the default epsilon.

Parameters

• point - The point to check

pub fn is_point_over_plane(&self, point: &Point3) -> bool

Checks if the point exists over the plane

Parameters

• point - The point to check

pub fn is_point_under_plane(&self, point: &Point3) -> bool

Checks if the point exists under the plane

Parameters

• point - The point to check

pub fn nearest_point(&self, point: &Point3) -> Point3

Gets the nearest point on the plane to the given point

Parameters

• point - The point to get the nearest point to

impl Plane

pub fn inverted(&self) -> Self

Computes and returns the plane that is this plane’s inverse.

Methods from Deref<Target = Vec4>

pub fn as_slice(&self) -> &[f32]

Returns this Vec4 as a slice of f32.

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

Returns this Vec4 as a mutable slice of f32.

pub fn as_ptr(&self) -> *const f32

Returns this vector as a ptr of f32.

pub fn as_mut_ptr(&mut self) -> *mut f32

Returns this vector as a mutable ptr of f32.

pub fn iter(&self) -> impl Iterator<Item = &f32>

Returns an iterator over the vector.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut f32>

Returns a mutable iterator over the vector.

pub fn x(&self) -> f32

Returns the X-coordinate of this 4-component vector.

pub fn y(&self) -> f32

Returns the Y-coordinate of this 4-component vector.

pub fn z(&self) -> f32

Returns the Z-coordinate of this 4-component vector.

pub fn w(&self) -> f32

Returns the W-coordinate of this 4-component vector.

pub fn xy(&self) -> &Vec2

Returns the xy coordinates of this vector as a Vec2.

pub fn yz(&self) -> &Vec2

Returns the yz coordinates of this vector as a Vec2.

pub fn zw(&self) -> &Vec2

Returns the zw coordinates of this vector as a Vec2.

pub fn xyz(&self) -> &Vec3

Returns the xyz coordinates of this vector as a Vec2.

pub fn yzw(&self) -> &Vec3

Returns the yz coordinates of this vector as a Vec2.

pub fn x_mut(&mut self) -> &mut f32

Returns a mutable reference to the X-coordinate of this 3-component vector.

pub fn y_mut(&mut self) -> &mut f32

Returns a mutable reference to the Y-coordinate of this 3-component vector.

pub fn z_mut(&mut self) -> &mut f32

Returns a mutable reference to the Z-coordinate of this 3-component vector.

pub fn w_mut(&mut self) -> &mut f32

Returns a mutable reference to the W-coordinate of this 3-component vector.

pub fn xy_mut(&mut self) -> &mut Vec2

Returns a mutable reference to the xy coordinates of this vector.

pub fn yz_mut(&mut self) -> &mut Vec2

Returns a mutable reference to the yz coordinates of this vector.

pub fn zw_mut(&mut self) -> &mut Vec2

Returns a mutable reference to the zw coordinates of this vector.

pub fn xyz_mut(&mut self) -> &mut Vec3

Returns a mutable reference to the yz coordinates of this vector.

pub fn yzw_mut(&mut self) -> &mut Vec3

Returns a mutable reference to the zw coordinates of this vector.

pub fn square_magnitude(&self) -> f32

Computes the square magnitude of this two-component vector.

pub fn magnitude(&self) -> f32

Computes the magnitude of this vector.

Where possible, consider using Vec4::square_magnitude as this will avoid the need to compute the square-root.

pub fn is_normalized(&self) -> bool

Queries whether this vector is normalized (e.g. has a magnitude of 1).

pub fn normalize(&mut self)

Normalizes this vector.

pub fn normalized(&self) -> Vector4

Returns normalized vector.

pub fn is_finite(&self) -> bool

Returns whether all components of this Vec are finite.

Example

Basic use:

let finite = Vector4::UNIT_X;
let not_finite = Vector4::new(f32::INFINITY, 3.0, 0.0, -1.0);

assert!(finite.is_finite());
assert!(!not_finite.is_finite());

pub fn is_infinite(&self) -> bool

Returns whether any component of this vec are infinite.

This is the inverse operation of is_finite.

Example

Basic use:

let finite = Vector4::UNIT_X;
let not_finite = Vector4::new(f32::INFINITY, 3.0, 0.0, -1.0);

assert!(!finite.is_infinite());
assert!(not_finite.is_infinite());

pub fn is_nan(&self) -> bool

Returns whether any component of this vec are nan.

pub fn abs(&self) -> Vector4

Computes the absolute value of self

pub fn min(&self, rhs: &Vec4) -> Vector4

Computes the minimum of each vector.

Parameters

• lhs - the left vector
• rhs - the right vector

pub fn max(&self, rhs: &Vec4) -> Vector4

Computes the maximum of each vector.

Parameters

• lhs - the left vector
• rhs - the right vector

pub fn set_x(&mut self, x: f32)

Sets the x-component

Parameters

• x - the X-component

pub fn set_y(&mut self, y: f32)

Sets the y-component

Parameters

• y - the Y-component

pub fn set_z(&mut self, z: f32)

Sets the z-component

Parameters

• z - theZ-component

pub fn set_w(&mut self, w: f32)

Sets the w-component

Parameters

• w - the W-component

pub fn set_xy(&mut self, xy: &Vec2)

Sets the X and Y components of this vector

Parameters

• xy - the X and Y components of the Vec4

pub fn set_yz(&mut self, yz: &Vec2)

Sets the Y and Z components of this vector

Parameters

• yz - the Y and Z components of the Vec4

pub fn set_zw(&mut self, zw: &Vec2)

Sets the Z and W components of this vector

Parameters

• zw - the Z and W components of the Vec4

pub fn set_xyz(&mut self, xyz: &Vec3)

Sets the X, Y, and Z components of this vector

Parameters

• xyz - the X, Y, and Z components of the Vec4`

pub fn set_yzw(&mut self, yzw: &Vec3)

Sets the Y, Z and W components of this vector

Parameters

• yzw - the Y, Z, and W components of the Vec4

pub fn set(&mut self, other: &Vec4)

Sets all the components of this vector the values from other.

Parameters

• other - the other Vec3 to set.

Trait Implementations

impl AsMut<Vec4> for Plane

fn as_mut(&mut self) -> &mut Vec4

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Vec4> for Plane

fn as_ref(&self) -> &Vec4

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Plane

fn clone(&self) -> Plane

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Plane

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

Formats the value using the given formatter.

impl Default for Plane

fn default() -> Plane

Returns the “default value” for a type.

impl Deref for Plane

type Target = Vec4

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Plane

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Encloses<Point3> for Plane

fn encloses(&self, point: &Point3) -> bool

Determines if this object encloses another object.

impl Intersects for Plane

fn intersects(&self, other: &Self) -> bool

Determines if this object intersects with another object.

impl PartialEq for Plane

fn eq(&self, other: &Plane) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Plane

fn partial_cmp(&self, other: &Plane) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Plane

impl StructuralPartialEq for Plane