Struct trackball::Plane

#[repr(C)]
pub struct Plane<N: Copy + RealField> {
    pub normal: Unit<Vector3<N>>,
    pub bias: N,
}

Plane encoding position with singed bias along unit normal.

Realizes plane equation a*x+b*y+c*z+d=0 with unit normal [x, y, z] and signed bias d.

Fields

normal: Unit<Vector3<N>>

Plane unit normal.

bias: N

Signed bias along unit normal.

Implementations

impl<N: Copy + RealField> Plane<N>

pub fn new(normal: Unit<Vector3<N>>, distance: N) -> Self

Plane from unit normal and signed distance from the origin.

use trackball::{
    nalgebra::{Point3, Vector3},
    Plane,
};

// Plane intersecting y-axis at `5.0`.
let plane = Plane::new(Vector3::y_axis(), 5.0);

// Origin projected onto plane where plane intersects y-axis.
let point = plane.project_point(&Point3::origin());
assert_eq!(point, Point3::new(0.0, 5.0, 0.0));

// Bias is negated distance.
assert_eq!(plane.distance(), 5.0);
assert_eq!(plane.bias, -5.0);

// Plane intersecting y-axis at `-5.0`.
let plane = Plane::new(Vector3::y_axis(), -5.0);

// Origin projected onto plane where plane intersects y-axis.
let point = plane.project_point(&Point3::origin());
assert_eq!(point, Point3::new(0.0, -5.0, 0.0));

// Bias is negated distance.
assert_eq!(plane.distance(), -5.0);
assert_eq!(plane.bias, 5.0);

pub fn with_point(normal: Unit<Vector3<N>>, point: &Point3<N>) -> Self

Plane from unit normal with point in plane.

pub fn distance(&self) -> N

Signed orthogonal distance from the origin.

pub fn distance_from(&self, point: &Point3<N>) -> N

Signed orthogonal distance from point.

pub fn project_point(&self, point: &Point3<N>) -> Point3<N>

Projects point onto plane.

pub fn project_axis(&self, axis: &Unit<Vector3<N>>) -> Unit<Vector3<N>>

Projects axis onto plane.

pub fn project_vector(&self, vector: &Vector3<N>) -> Vector3<N>

Projects vector onto plane.

pub fn angle_between(&self, a: &Vector3<N>, b: &Vector3<N>) -> N

Singed angle from a to b where both vectors are in the plane.

pub fn rotate_by(self, rot: &UnitQuaternion<N>) -> Self

Rotates plane.

pub fn translate_by(self, vec: &Vector3<N>) -> Self

Translates plane.

pub fn transform_by(self, iso: &Isometry3<N>) -> Self

Transforms plane by direct isometry, i.e., rotation followed by translation.

use core::f64::{
    consts::FRAC_PI_2,
    EPSILON,
};
use trackball::{
    approx::AbsDiffEq,
    nalgebra::{Isometry3, Vector3},
    Plane,
};

// Plane intersecting y-axis at `5.0`.
let plane = Plane::new(Vector3::y_axis(), 5.0)
    .transform_by(&Isometry3::new(
        // Translation by after rotation.
        Vector3::new(-5.0, 0.0, 0.0),
        // Rotation by 90 degrees before translation.
        Vector3::new(0.0, 0.0, FRAC_PI_2),
    ));
// Plane intersecting x-axis at `-10.0`.
assert!(plane.abs_diff_eq(&Plane::new(-Vector3::x_axis(), 10.0), EPSILON));

pub fn cast<M: Copy + RealField>(self) -> Plane<M>

where N: SubsetOf<M>,

Casts components to another type, e.g., between f32 and f64.

Trait Implementations

impl<N: Copy + RealField + AbsDiffEq> AbsDiffEq for Plane<N>

where N::Epsilon: Copy,

type Epsilon = <N as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> N::Epsilon

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

fn abs_diff_eq(&self, other: &Self, epsilon: N::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 AbsDiffEq::abs_diff_eq.

impl<N: Copy + RealField> Archive for Plane<N>

type Archived = Plane<N>

The archived representation of this type.

type Resolver = ()

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve(&self, _: usize, (): Self::Resolver, out: *mut Self::Archived)

Creates the archived version of this value at the given position and writes it to the given output.

impl<N: Clone + Copy + RealField> Clone for Plane<N>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug + Copy + RealField> Debug for Plane<N>

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

Formats the value using the given formatter.

impl<'de, N> Deserialize<'de> for Plane<N>

where N: Deserialize<'de> + Copy + RealField,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<De: Fallible + ?Sized, N: Copy + RealField> Deserialize<Plane<N>, De> for Plane<N>

fn deserialize(&self, _: &mut De) -> Result<Self, De::Error>

Deserializes using the given deserializer

impl<N: Copy + RealField> From<Plane<N>> for Reflection3<N>

fn from(plane: Plane<N>) -> Self

Converts to this type from the input type.

impl<N: Copy + RealField> From<Reflection<N, Const<3>, ArrayStorage<N, 3, 1>>> for Plane<N>

fn from(reflection: Reflection3<N>) -> Self

Converts to this type from the input type.

impl<N: PartialEq + Copy + RealField> PartialEq for Plane<N>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<N: Copy + RealField + RelativeEq> RelativeEq for Plane<N>

where N::Epsilon: Copy,

fn default_max_relative() -> N::Epsilon

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

fn relative_eq( &self, other: &Self, epsilon: N::Epsilon, max_relative: N::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 RelativeEq::relative_eq.

impl<Ser: Fallible + ?Sized, N: Copy + RealField> Serialize<Ser> for Plane<N>

fn serialize(&self, _: &mut Ser) -> Result<Self::Resolver, Ser::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<N> Serialize for Plane<N>

where N: Serialize + Copy + RealField,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<N: Copy + RealField + UlpsEq> UlpsEq for Plane<N>

where N::Epsilon: Copy,

fn default_max_ulps() -> u32

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

fn ulps_eq(&self, other: &Self, epsilon: N::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 UlpsEq::ulps_eq.

impl<N: Copy + Copy + RealField> Copy for Plane<N>

impl<N: Eq + Copy + RealField> Eq for Plane<N>

impl<N: Copy + RealField> StructuralEq for Plane<N>

impl<N: Copy + RealField> StructuralPartialEq for Plane<N>