Struct truck_geometry::base::cgmath::Decomposed
pub struct Decomposed<V, R>where
V: VectorSpace,{
pub scale: <V as VectorSpace>::Scalar,
pub rot: R,
pub disp: V,
}
Expand description
A generic transformation consisting of a rotation, displacement vector and scale amount.
Fields§
§scale: <V as VectorSpace>::Scalar
§rot: R
§disp: V
Trait Implementations§
§impl<S, R, E> AbsDiffEq<Decomposed<S, R>> for Decomposed<S, R>where
S: VectorSpace + AbsDiffEq<S, Epsilon = E>,
E: BaseFloat,
<S as VectorSpace>::Scalar: AbsDiffEq<<S as VectorSpace>::Scalar, Epsilon = E>,
R: AbsDiffEq<R, Epsilon = E>,
impl<S, R, E> AbsDiffEq<Decomposed<S, R>> for Decomposed<S, R>where
S: VectorSpace + AbsDiffEq<S, Epsilon = E>,
E: BaseFloat,
<S as VectorSpace>::Scalar: AbsDiffEq<<S as VectorSpace>::Scalar, Epsilon = E>,
R: AbsDiffEq<R, Epsilon = E>,
§fn default_epsilon() -> E
fn default_epsilon() -> E
The default tolerance to use when testing values that are close together. Read more
§fn abs_diff_eq(&self, other: &Decomposed<S, R>, epsilon: E) -> bool
fn abs_diff_eq(&self, other: &Decomposed<S, R>, epsilon: E) -> 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
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
The inverse of
AbsDiffEq::abs_diff_eq
.§impl<V, R> Clone for Decomposed<V, R>where
V: Clone + VectorSpace,
R: Clone,
<V as VectorSpace>::Scalar: Clone,
impl<V, R> Clone for Decomposed<V, R>where
V: Clone + VectorSpace,
R: Clone,
<V as VectorSpace>::Scalar: Clone,
§fn clone(&self) -> Decomposed<V, R>
fn clone(&self) -> Decomposed<V, R>
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source
. Read more§impl<V, R> Debug for Decomposed<V, R>where
V: Debug + VectorSpace,
R: Debug,
<V as VectorSpace>::Scalar: Debug,
impl<V, R> Debug for Decomposed<V, R>where
V: Debug + VectorSpace,
R: Debug,
<V as VectorSpace>::Scalar: Debug,
§impl<'a, S, R> Deserialize<'a> for Decomposed<S, R>where
S: VectorSpace + Deserialize<'a>,
<S as VectorSpace>::Scalar: Deserialize<'a>,
R: Deserialize<'a>,
impl<'a, S, R> Deserialize<'a> for Decomposed<S, R>where
S: VectorSpace + Deserialize<'a>,
<S as VectorSpace>::Scalar: Deserialize<'a>,
R: Deserialize<'a>,
§fn deserialize<D>(
deserializer: D
) -> Result<Decomposed<S, R>, <D as Deserializer<'a>>::Error>where
D: Deserializer<'a>,
fn deserialize<D>(
deserializer: D
) -> Result<Decomposed<S, R>, <D as Deserializer<'a>>::Error>where
D: Deserializer<'a>,
Deserialize this value from the given Serde deserializer. Read more
§impl<S, R> From<Decomposed<Vector2<S>, R>> for Matrix3<S>where
S: BaseFloat,
R: Rotation2<Scalar = S>,
impl<S, R> From<Decomposed<Vector2<S>, R>> for Matrix3<S>where
S: BaseFloat,
R: Rotation2<Scalar = S>,
§fn from(dec: Decomposed<Vector2<S>, R>) -> Matrix3<S>
fn from(dec: Decomposed<Vector2<S>, R>) -> Matrix3<S>
Converts to this type from the input type.
§impl<S, R> From<Decomposed<Vector3<S>, R>> for Matrix4<S>where
S: BaseFloat,
R: Rotation3<Scalar = S>,
impl<S, R> From<Decomposed<Vector3<S>, R>> for Matrix4<S>where
S: BaseFloat,
R: Rotation3<Scalar = S>,
§fn from(dec: Decomposed<Vector3<S>, R>) -> Matrix4<S>
fn from(dec: Decomposed<Vector3<S>, R>) -> Matrix4<S>
Converts to this type from the input type.
§impl<P, R> Mul<Decomposed<<P as EuclideanSpace>::Diff, R>> for Decomposed<<P as EuclideanSpace>::Diff, R>where
P: EuclideanSpace,
R: Rotation<Space = P>,
<P as EuclideanSpace>::Scalar: BaseFloat,
<P as EuclideanSpace>::Diff: VectorSpace,
impl<P, R> Mul<Decomposed<<P as EuclideanSpace>::Diff, R>> for Decomposed<<P as EuclideanSpace>::Diff, R>where
P: EuclideanSpace,
R: Rotation<Space = P>,
<P as EuclideanSpace>::Scalar: BaseFloat,
<P as EuclideanSpace>::Diff: VectorSpace,
§fn mul(
self,
rhs: Decomposed<<P as EuclideanSpace>::Diff, R>
) -> <Decomposed<<P as EuclideanSpace>::Diff, R> as Mul<Decomposed<<P as EuclideanSpace>::Diff, R>>>::Output
fn mul(
self,
rhs: Decomposed<<P as EuclideanSpace>::Diff, R>
) -> <Decomposed<<P as EuclideanSpace>::Diff, R> as Mul<Decomposed<<P as EuclideanSpace>::Diff, R>>>::Output
Multiplies the two transforms together.
The result should be as if the two transforms were converted
to matrices, then multiplied, then converted back with
a (currently nonexistent) function that tries to convert
a matrix into a Decomposed
.
§type Output = Decomposed<<P as EuclideanSpace>::Diff, R>
type Output = Decomposed<<P as EuclideanSpace>::Diff, R>
The resulting type after applying the
*
operator.§impl<P, R> One for Decomposed<<P as EuclideanSpace>::Diff, R>where
P: EuclideanSpace,
R: Rotation<Space = P>,
<P as EuclideanSpace>::Scalar: BaseFloat,
impl<P, R> One for Decomposed<<P as EuclideanSpace>::Diff, R>where
P: EuclideanSpace,
R: Rotation<Space = P>,
<P as EuclideanSpace>::Scalar: BaseFloat,
§fn one() -> Decomposed<<P as EuclideanSpace>::Diff, R>
fn one() -> Decomposed<<P as EuclideanSpace>::Diff, R>
§impl<V, R> PartialEq<Decomposed<V, R>> for Decomposed<V, R>where
V: PartialEq<V> + VectorSpace,
R: PartialEq<R>,
<V as VectorSpace>::Scalar: PartialEq<<V as VectorSpace>::Scalar>,
impl<V, R> PartialEq<Decomposed<V, R>> for Decomposed<V, R>where
V: PartialEq<V> + VectorSpace,
R: PartialEq<R>,
<V as VectorSpace>::Scalar: PartialEq<<V as VectorSpace>::Scalar>,
§fn eq(&self, other: &Decomposed<V, R>) -> bool
fn eq(&self, other: &Decomposed<V, R>) -> bool
This method tests for
self
and other
values to be equal, and is used
by ==
.§impl<S, R, E> RelativeEq<Decomposed<S, R>> for Decomposed<S, R>where
S: VectorSpace + RelativeEq<S, Epsilon = E>,
E: BaseFloat,
<S as VectorSpace>::Scalar: RelativeEq<<S as VectorSpace>::Scalar, Epsilon = E>,
R: RelativeEq<R, Epsilon = E>,
impl<S, R, E> RelativeEq<Decomposed<S, R>> for Decomposed<S, R>where
S: VectorSpace + RelativeEq<S, Epsilon = E>,
E: BaseFloat,
<S as VectorSpace>::Scalar: RelativeEq<<S as VectorSpace>::Scalar, Epsilon = E>,
R: RelativeEq<R, Epsilon = E>,
§fn default_max_relative() -> E
fn default_max_relative() -> E
The default relative tolerance for testing values that are far-apart. Read more
§fn relative_eq(
&self,
other: &Decomposed<S, R>,
epsilon: E,
max_relative: E
) -> bool
fn relative_eq(
&self,
other: &Decomposed<S, R>,
epsilon: E,
max_relative: E
) -> 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
fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
The inverse of
RelativeEq::relative_eq
.§impl<V, R> Serialize for Decomposed<V, R>where
V: Serialize + VectorSpace,
<V as VectorSpace>::Scalar: Serialize,
R: Serialize,
impl<V, R> Serialize for Decomposed<V, R>where
V: Serialize + VectorSpace,
<V as VectorSpace>::Scalar: Serialize,
R: Serialize,
§fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
Serialize this value into the given Serde serializer. Read more
§impl<P, R> Transform<P> for Decomposed<<P as EuclideanSpace>::Diff, R>where
P: EuclideanSpace,
R: Rotation<Space = P>,
<P as EuclideanSpace>::Scalar: BaseFloat,
<P as EuclideanSpace>::Diff: VectorSpace,
impl<P, R> Transform<P> for Decomposed<<P as EuclideanSpace>::Diff, R>where
P: EuclideanSpace,
R: Rotation<Space = P>,
<P as EuclideanSpace>::Scalar: BaseFloat,
<P as EuclideanSpace>::Diff: VectorSpace,
§fn look_at(
eye: P,
center: P,
up: <P as EuclideanSpace>::Diff
) -> Decomposed<<P as EuclideanSpace>::Diff, R>
fn look_at(
eye: P,
center: P,
up: <P as EuclideanSpace>::Diff
) -> Decomposed<<P as EuclideanSpace>::Diff, R>
👎Deprecated: Use look_at_rh or look_at_lh
Create a transformation that rotates a vector to look at
center
from
eye
, using up
for orientation.§fn look_at_lh(
eye: P,
center: P,
up: <P as EuclideanSpace>::Diff
) -> Decomposed<<P as EuclideanSpace>::Diff, R>
fn look_at_lh(
eye: P,
center: P,
up: <P as EuclideanSpace>::Diff
) -> Decomposed<<P as EuclideanSpace>::Diff, R>
Create a transformation that rotates a vector to look at
center
from
eye
, using up
for orientation.§fn look_at_rh(
eye: P,
center: P,
up: <P as EuclideanSpace>::Diff
) -> Decomposed<<P as EuclideanSpace>::Diff, R>
fn look_at_rh(
eye: P,
center: P,
up: <P as EuclideanSpace>::Diff
) -> Decomposed<<P as EuclideanSpace>::Diff, R>
Create a transformation that rotates a vector to look at
center
from
eye
, using up
for orientation.§fn transform_vector(
&self,
vec: <P as EuclideanSpace>::Diff
) -> <P as EuclideanSpace>::Diff
fn transform_vector(
&self,
vec: <P as EuclideanSpace>::Diff
) -> <P as EuclideanSpace>::Diff
Transform a vector using this transform.
§fn inverse_transform_vector(
&self,
vec: <P as EuclideanSpace>::Diff
) -> Option<<P as EuclideanSpace>::Diff>
fn inverse_transform_vector(
&self,
vec: <P as EuclideanSpace>::Diff
) -> Option<<P as EuclideanSpace>::Diff>
Inverse transform a vector using this transform
§fn transform_point(&self, point: P) -> P
fn transform_point(&self, point: P) -> P
Transform a point using this transform.
§fn concat(
&self,
other: &Decomposed<<P as EuclideanSpace>::Diff, R>
) -> Decomposed<<P as EuclideanSpace>::Diff, R>
fn concat(
&self,
other: &Decomposed<<P as EuclideanSpace>::Diff, R>
) -> Decomposed<<P as EuclideanSpace>::Diff, R>
Combine this transform with another, yielding a new transformation
which has the effects of both.
§fn inverse_transform(
&self
) -> Option<Decomposed<<P as EuclideanSpace>::Diff, R>>
fn inverse_transform(
&self
) -> Option<Decomposed<<P as EuclideanSpace>::Diff, R>>
Create a transform that “un-does” this one.
§fn concat_self(&mut self, other: &Self)
fn concat_self(&mut self, other: &Self)
Combine this transform with another, in-place.
§impl<S, R> Transform2 for Decomposed<Vector2<S>, R>where
S: BaseFloat,
R: Rotation2<Scalar = S>,
impl<S, R> Transform2 for Decomposed<Vector2<S>, R>where
S: BaseFloat,
R: Rotation2<Scalar = S>,
§impl<S, R> Transform3 for Decomposed<Vector3<S>, R>where
S: BaseFloat,
R: Rotation3<Scalar = S>,
impl<S, R> Transform3 for Decomposed<Vector3<S>, R>where
S: BaseFloat,
R: Rotation3<Scalar = S>,
§impl<S, R, E> UlpsEq<Decomposed<S, R>> for Decomposed<S, R>where
S: VectorSpace + UlpsEq<S, Epsilon = E>,
E: BaseFloat,
<S as VectorSpace>::Scalar: UlpsEq<<S as VectorSpace>::Scalar, Epsilon = E>,
R: UlpsEq<R, Epsilon = E>,
impl<S, R, E> UlpsEq<Decomposed<S, R>> for Decomposed<S, R>where
S: VectorSpace + UlpsEq<S, Epsilon = E>,
E: BaseFloat,
<S as VectorSpace>::Scalar: UlpsEq<<S as VectorSpace>::Scalar, Epsilon = E>,
R: UlpsEq<R, Epsilon = E>,
§fn default_max_ulps() -> u32
fn default_max_ulps() -> u32
The default ULPs to tolerate when testing values that are far-apart. Read more
§fn ulps_eq(&self, other: &Decomposed<S, R>, epsilon: E, max_ulps: u32) -> bool
fn ulps_eq(&self, other: &Decomposed<S, R>, epsilon: E, max_ulps: u32) -> bool
A test for equality that uses units in the last place (ULP) if the values are far apart.