Struct acgmath::Decomposed
[−]
[src]
pub struct Decomposed<V: VectorSpace, R> { pub scale: V::Scalar, pub rot: R, pub disp: V, }
A generic transformation consisting of a rotation, displacement vector and scale amount.
Fields
scale: V::Scalar
rot: R
disp: V
Trait Implementations
impl<V: VectorSpace, R> Serialize for Decomposed<V, R> where
V: Serialize,
V::Scalar: Serialize,
R: Serialize,
[src]
V: Serialize,
V::Scalar: Serialize,
R: Serialize,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
S: Serializer,
Serialize this value into the given Serde serializer. Read more
impl<S: VectorSpace, R> Deserialize for Decomposed<S, R> where
S: Deserialize,
S::Scalar: Deserialize,
R: Deserialize,
[src]
S: Deserialize,
S::Scalar: Deserialize,
R: Deserialize,
fn deserialize<D>(deserializer: D) -> Result<Decomposed<S, R>, D::Error> where
D: Deserializer,
D: Deserializer,
Deserialize this value from the given Serde deserializer. Read more
impl<V: Copy + VectorSpace, R: Copy> Copy for Decomposed<V, R> where
V::Scalar: Copy,
[src]
V::Scalar: Copy,
impl<V: Clone + VectorSpace, R: Clone> Clone for Decomposed<V, R> where
V::Scalar: Clone,
[src]
V::Scalar: Clone,
fn clone(&self) -> Decomposed<V, R>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<V: Debug + VectorSpace, R: Debug> Debug for Decomposed<V, R> where
V::Scalar: Debug,
[src]
V::Scalar: Debug,
impl<P: EuclideanSpace, R: Rotation<P>> Transform<P> for Decomposed<P::Diff, R> where
<P as EuclideanSpace>::Scalar: BaseFloat,
<P as EuclideanSpace>::Diff: VectorSpace,
[src]
<P as EuclideanSpace>::Scalar: BaseFloat,
<P as EuclideanSpace>::Diff: VectorSpace,
fn one() -> Decomposed<P::Diff, R>
Create an identity transformation. That is, a transformation which does nothing. Read more
fn look_at(eye: P, center: P, up: P::Diff) -> Decomposed<P::Diff, R>
Create a transformation that rotates a vector to look at center
from eye
, using up
for orientation. Read more
fn transform_vector(&self, vec: P::Diff) -> P::Diff
Transform a vector using this transform.
fn transform_point(&self, point: P) -> P
Transform a point using this transform.
fn concat(&self, other: &Decomposed<P::Diff, R>) -> Decomposed<P::Diff, R>
Combine this transform with another, yielding a new transformation which has the effects of both. Read more
fn inverse_transform(&self) -> Option<Decomposed<P::Diff, R>>
Create a transform that "un-does" this one.
fn concat_self(&mut self, other: &Self)
Combine this transform with another, in-place.
impl<S: BaseFloat, R: Rotation2<S>> Transform2<S> for Decomposed<Vector2<S>, R>
[src]
impl<S: BaseFloat, R: Rotation3<S>> Transform3<S> for Decomposed<Vector3<S>, R>
[src]
impl<S: VectorSpace, R, E: BaseFloat> ApproxEq for Decomposed<S, R> where
S: ApproxEq<Epsilon = E>,
S::Scalar: ApproxEq<Epsilon = E>,
R: ApproxEq<Epsilon = E>,
[src]
S: ApproxEq<Epsilon = E>,
S::Scalar: ApproxEq<Epsilon = E>,
R: ApproxEq<Epsilon = E>,
type Epsilon = E
Used for specifying relative comparisons.
fn default_epsilon() -> E
The default tolerance to use when testing values that are close together. Read more
fn default_max_relative() -> E
The default relative tolerance for testing values that are far-apart. Read more
fn default_max_ulps() -> u32
The default ULPs to tolerate when testing values that are far-apart. Read more
fn relative_eq(&self, other: &Self, epsilon: E, max_relative: E) -> bool
A test for equality that uses a relative comparison if the values are far apart.
fn ulps_eq(&self, other: &Self, epsilon: E, max_ulps: u32) -> bool
A test for equality that uses units in the last place (ULP) if the values are far apart.
fn relative_ne(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
The inverse of ApproxEq::relative_eq
.
fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool
The inverse of ApproxEq::ulps_eq
.