Struct trackball::Bound

pub struct Bound<N: Copy + RealField> {
    pub transform: Isometry3<N>,
    pub min_target: Point3<N>,
    pub max_target: Point3<N>,
    pub min_eye: Point3<N>,
    pub max_eye: Point3<N>,
    pub min_up: Point3<N>,
    pub max_up: Point3<N>,
    pub min_distance: N,
    pub max_distance: N,
    pub hysteresis: N,
}

Orthogonal boundary conditions implementing Clamp.

Implements Default and can be created with Bound::default().

Fields

transform: Isometry3<N>

Isometry in world space of bound inversely transforming target and eye positions.

min_target: Point3<N>

Minimum components of target position in world space. Default splats N::MIN.

max_target: Point3<N>

Maximum components of target position in world space. Default splats N::MAX.

min_eye: Point3<N>

Minimum components of eye position in world space. Default splats N::MIN.

max_eye: Point3<N>

Maximum components of eye position in world space. Default splats N::MAX.

min_up: Point3<N>

Minimum components of up axis in world space following yaw. Default splats N::MIN.

max_up: Point3<N>

Maximum components of up axis in world space following yaw. Default splats N::MAX.

min_distance: N

Minimum distance of eye from target. Default is N::zero().

max_distance: N

Maximum distance of eye from target. Default is N::MAX.

hysteresis: N

Epsilon allowing clamped Delta to more likely pass revalidation.

Default is AbsDiffEq::default_epsilon().sqrt().

Trait Implementations

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

type Archived = Bound<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: Copy + RealField> Clamp<N> for Bound<N>

fn loops(&self) -> usize

Using lower loop limit for flat boundary conditions.

fn target(&self, frame: &Frame<N>) -> Option<Plane<N>>

Find any boundary plane exceeded by target position.

fn eye(&self, frame: &Frame<N>) -> Option<Plane<N>>

Find any boundary plane exceeded by eye position.

fn up(&self, frame: &Frame<N>) -> Option<Plane<N>>

Find any boundary plane exceeded by up position.

fn compute( &self, frame: &Frame<N>, scope: &Scope<N>, delta: &Delta<N> ) -> Option<(Delta<N>, usize)>

Computes clamped Delta wrt abstract boundary conditions of Frame and Scope.

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

fn clone(&self) -> Bound<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 Bound<N>

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

Formats the value using the given formatter.

impl<N: Copy + RealField> Default for Bound<N>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, N> Deserialize<'de> for Bound<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<Bound<N>, De> for Bound<N>

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

Deserializes using the given deserializer

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

fn eq(&self, other: &Bound<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<Ser: Fallible + ?Sized, N: Copy + RealField> Serialize<Ser> for Bound<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 Bound<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 + Copy + RealField> Copy for Bound<N>

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

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

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