Struct Plane

pub struct Plane<S> {
    pub n: Vector3<S>,
    pub d: S,
}

A 3-dimensional plane formed from the equation: A*x + B*y + C*z - D = 0.

Fields

• n: a unit vector representing the normal of the plane where:
  • n.x: corresponds to A in the plane equation
  • n.y: corresponds to B in the plane equation
  • n.z: corresponds to C in the plane equation
• d: the distance value, corresponding to D in the plane equation

Notes

The A*x + B*y + C*z - D = 0 form is preferred over the other common alternative, A*x + B*y + C*z + D = 0, because it tends to avoid superfluous negations (see Real Time Collision Detection, p. 55).

Fields

n: Vector3<S>

Plane normal

d: S

Plane distance value

Implementations

impl<S: BaseFloat> Plane<S>

pub fn new(n: Vector3<S>, d: S) -> Plane<S>

Construct a plane from a normal vector and a scalar distance. The plane will be perpendicular to n, and d units offset from the origin.

pub fn from_abcd(a: S, b: S, c: S, d: S) -> Plane<S>

Arguments

• a: the x component of the normal
• b: the y component of the normal
• c: the z component of the normal
• d: the plane’s distance value

pub fn from_vector4(v: Vector4<S>) -> Plane<S>

Construct a plane from the components of a four-dimensional vector

pub fn from_vector4_alt(v: Vector4<S>) -> Plane<S>

Construct a plane from the components of a four-dimensional vector Assuming alternative representation: A*x + B*y + C*z + D = 0

pub fn from_points(a: Point3<S>, b: Point3<S>, c: Point3<S>) -> Option<Plane<S>>

Constructs a plane that passes through the the three points a, b and c

pub fn from_point_normal(p: Point3<S>, n: Vector3<S>) -> Plane<S>

Construct a plane from a point and a normal vector. The plane will contain the point p and be perpendicular to n.

pub fn normalize(&self) -> Option<Plane<S>>

Normalize a plane.

Trait Implementations

impl<S> AbsDiffEq for Plane<S>

where S::Epsilon: Copy, S: BaseFloat + AbsDiffEq,

type Epsilon = <S as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> S::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of ApproxEq::abs_diff_eq.

impl<S: Clone> Clone for Plane<S>

fn clone(&self) -> Plane<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: BaseFloat> Continuous<(Plane<S>, Plane<S>)> for Plane<S>

See Real-Time Collision Detection, p. 212 - 214

type Result = Point3<S>

Result returned by the intersection test

fn intersection(&self, planes: &(Plane<S>, Plane<S>)) -> Option<Point3<S>>

Intersection test

impl<S: BaseFloat> Continuous<Plane<S>> for Plane<S>

See Real-Time Collision Detection, p. 210

type Result = Ray<S, Point3<S>, Vector3<S>>

Result returned by the intersection test

fn intersection(&self, p2: &Plane<S>) -> Option<Ray3<S>>

Intersection test

impl<S: BaseFloat> Continuous<Ray<S, Point3<S>, Vector3<S>>> for Plane<S>

type Result = Point3<S>

Result returned by the intersection test

fn intersection(&self, r: &Ray3<S>) -> Option<Point3<S>>

Intersection test

impl<S: BaseFloat> Debug for Plane<S>

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

Formats the value using the given formatter.

impl<S: BaseFloat> Discrete<(Plane<S>, Plane<S>)> for Plane<S>

fn intersects(&self, planes: &(Plane<S>, Plane<S>)) -> bool

Intersection test

impl<S: BaseFloat> Discrete<Plane<S>> for Plane<S>

fn intersects(&self, p2: &Plane<S>) -> bool

Intersection test

impl<S: BaseFloat> Discrete<Ray<S, Point3<S>, Vector3<S>>> for Plane<S>

fn intersects(&self, r: &Ray3<S>) -> bool

Intersection test

impl<S: PartialEq> PartialEq for Plane<S>

fn eq(&self, other: &Plane<S>) -> 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<S> RelativeEq for Plane<S>

where S::Epsilon: Copy, S: BaseFloat + RelativeEq,

fn default_max_relative() -> S::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of ApproxEq::relative_eq.

impl<S> UlpsEq for Plane<S>

where S::Epsilon: Copy, S: BaseFloat + UlpsEq,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.

impl<S: Copy> Copy for Plane<S>

impl<S> StructuralPartialEq for Plane<S>