[−][src]Struct kludgine::prelude::Scale
A scaling factor between two different units of measurement.
This is effectively a type-safe float, intended to be used in combination with other types like
length::Length
to enforce conversion between systems of measurement at compile time.
Src
and Dst
represent the units before and after multiplying a value by a Scale
. They
may be types without values, such as empty enums. For example:
use euclid::Scale; use euclid::Length; enum Mm {}; enum Inch {}; let mm_per_inch: Scale<f32, Inch, Mm> = Scale::new(25.4); let one_foot: Length<f32, Inch> = Length::new(12.0); let one_foot_in_mm: Length<f32, Mm> = one_foot * mm_per_inch;
Implementations
impl<T, Src, Dst> Scale<T, Src, Dst>
[src]
pub const fn new(x: T) -> Scale<T, Src, Dst>
[src]
pub fn identity() -> Scale<T, Src, Dst> where
T: One,
[src]
T: One,
Creates an identity scale (1.0).
pub fn transform_point(
self,
point: Point2D<T, Src>
) -> Point2D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
[src]
self,
point: Point2D<T, Src>
) -> Point2D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
Returns the given point transformed by this scale.
Example
use euclid::{Scale, point2}; enum Mm {}; enum Cm {}; let to_mm: Scale<i32, Cm, Mm> = Scale::new(10); assert_eq!(to_mm.transform_point(point2(42, -42)), point2(420, -420));
pub fn transform_point3d(
self,
point: Point3D<T, Src>
) -> Point3D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
[src]
self,
point: Point3D<T, Src>
) -> Point3D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
Returns the given point transformed by this scale.
pub fn transform_vector(
self,
vec: Vector2D<T, Src>
) -> Vector2D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
[src]
self,
vec: Vector2D<T, Src>
) -> Vector2D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
Returns the given vector transformed by this scale.
Example
use euclid::{Scale, vec2}; enum Mm {}; enum Cm {}; let to_mm: Scale<i32, Cm, Mm> = Scale::new(10); assert_eq!(to_mm.transform_vector(vec2(42, -42)), vec2(420, -420));
pub fn transform_size(
self,
size: Size2D<T, Src>
) -> Size2D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
[src]
self,
size: Size2D<T, Src>
) -> Size2D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
Returns the given vector transformed by this scale.
Example
use euclid::{Scale, size2}; enum Mm {}; enum Cm {}; let to_mm: Scale<i32, Cm, Mm> = Scale::new(10); assert_eq!(to_mm.transform_size(size2(42, -42)), size2(420, -420));
pub fn transform_rect(
self,
rect: &Rect<T, Src>
) -> Rect<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
[src]
self,
rect: &Rect<T, Src>
) -> Rect<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
Returns the given rect transformed by this scale.
Example
use euclid::{Scale, rect}; enum Mm {}; enum Cm {}; let to_mm: Scale<i32, Cm, Mm> = Scale::new(10); assert_eq!(to_mm.transform_rect(&rect(1, 2, 42, -42)), rect(10, 20, 420, -420));
pub fn transform_box2d(
self,
b: &Box2D<T, Src>
) -> Box2D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
[src]
self,
b: &Box2D<T, Src>
) -> Box2D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
Returns the given box transformed by this scale.
pub fn transform_box3d(
self,
b: &Box3D<T, Src>
) -> Box3D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
[src]
self,
b: &Box3D<T, Src>
) -> Box3D<<T as Mul<T>>::Output, Dst> where
T: Copy + Mul<T>,
Returns the given box transformed by this scale.
pub fn is_identity(self) -> bool where
T: PartialEq<T> + One,
[src]
T: PartialEq<T> + One,
Returns true
if this scale has no effect.
Example
use euclid::Scale; use euclid::num::One; enum Mm {}; enum Cm {}; let cm_per_mm: Scale<f32, Mm, Cm> = Scale::new(0.1); let mm_per_mm: Scale<f32, Mm, Mm> = Scale::new(1.0); assert_eq!(cm_per_mm.is_identity(), false); assert_eq!(mm_per_mm.is_identity(), true); assert_eq!(mm_per_mm, Scale::one());
pub fn get(self) -> T
[src]
Returns the underlying scalar scale factor.
pub fn inverse(self) -> Scale<<T as Div<T>>::Output, Dst, Src> where
T: One + Div<T>,
[src]
T: One + Div<T>,
The inverse Scale (1.0 / self).
Example
use euclid::Scale; enum Mm {}; enum Cm {}; let cm_per_mm: Scale<f32, Cm, Mm> = Scale::new(0.1); assert_eq!(cm_per_mm.inverse(), Scale::new(10.0));
impl<T, Src, Dst> Scale<T, Src, Dst> where
T: NumCast,
[src]
T: NumCast,
pub fn cast<NewT>(self) -> Scale<NewT, Src, Dst> where
NewT: NumCast,
[src]
NewT: NumCast,
Cast from one numeric representation to another, preserving the units.
Panics
If the source value cannot be represented by the target type NewT
, then
method panics. Use try_cast
if that must be case.
Example
use euclid::Scale; enum Mm {}; enum Cm {}; let to_mm: Scale<i32, Cm, Mm> = Scale::new(10); assert_eq!(to_mm.cast::<f32>(), Scale::new(10.0));
That conversion will panic, because i32
not enough to store such big numbers:
use euclid::Scale; enum Mm {};// millimeter = 10^-2 meters enum Em {};// exameter = 10^18 meters // Panics let to_em: Scale<i32, Mm, Em> = Scale::new(10e20).cast();
pub fn try_cast<NewT>(self) -> Option<Scale<NewT, Src, Dst>> where
NewT: NumCast,
[src]
NewT: NumCast,
Fallible cast from one numeric representation to another, preserving the units.
If the source value cannot be represented by the target type NewT
, then None
is returned.
Example
use euclid::Scale; enum Mm {}; enum Cm {}; enum Em {};// Exameter = 10^18 meters let to_mm: Scale<i32, Cm, Mm> = Scale::new(10); let to_em: Scale<f32, Mm, Em> = Scale::new(10e20); assert_eq!(to_mm.try_cast::<f32>(), Some(Scale::new(10.0))); // Integer to small to store that number assert_eq!(to_em.try_cast::<i32>(), None);
Trait Implementations
impl<T, Src, Dst> Add<Scale<T, Src, Dst>> for Scale<T, Src, Dst> where
T: Add<T>,
[src]
T: Add<T>,
type Output = Scale<<T as Add<T>>::Output, Src, Dst>
The resulting type after applying the +
operator.
fn add(
self,
other: Scale<T, Src, Dst>
) -> <Scale<T, Src, Dst> as Add<Scale<T, Src, Dst>>>::Output
[src]
self,
other: Scale<T, Src, Dst>
) -> <Scale<T, Src, Dst> as Add<Scale<T, Src, Dst>>>::Output
impl<T, Src, Dst> Clone for Scale<T, Src, Dst> where
T: Clone,
[src]
T: Clone,
impl<T, Src, Dst> Copy for Scale<T, Src, Dst> where
T: Copy,
[src]
T: Copy,
impl<T, Src, Dst> Debug for Scale<T, Src, Dst> where
T: Debug,
[src]
T: Debug,
impl<T, Src, Dst> Default for Scale<T, Src, Dst> where
T: Default,
[src]
T: Default,
impl<'de, T, Src, Dst> Deserialize<'de> for Scale<T, Src, Dst> where
T: Deserialize<'de>,
[src]
T: Deserialize<'de>,
fn deserialize<__D>(
__deserializer: __D
) -> Result<Scale<T, Src, Dst>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
[src]
__deserializer: __D
) -> Result<Scale<T, Src, Dst>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
impl<Src, Dst, T> Div<Scale<T, Src, Dst>> for Length<T, Dst> where
T: Div<T>,
[src]
T: Div<T>,
type Output = Length<<T as Div<T>>::Output, Src>
The resulting type after applying the /
operator.
fn div(
self,
scale: Scale<T, Src, Dst>
) -> <Length<T, Dst> as Div<Scale<T, Src, Dst>>>::Output
[src]
self,
scale: Scale<T, Src, Dst>
) -> <Length<T, Dst> as Div<Scale<T, Src, Dst>>>::Output
impl<T, Src, Dst> Eq for Scale<T, Src, Dst> where
T: Eq,
[src]
T: Eq,
impl<T, Src, Dst> Hash for Scale<T, Src, Dst> where
T: Hash,
[src]
T: Hash,
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<T, A, B, C> Mul<Scale<T, B, C>> for Scale<T, A, B> where
T: Mul<T>,
[src]
T: Mul<T>,
type Output = Scale<<T as Mul<T>>::Output, A, C>
The resulting type after applying the *
operator.
fn mul(
self,
other: Scale<T, B, C>
) -> <Scale<T, A, B> as Mul<Scale<T, B, C>>>::Output
[src]
self,
other: Scale<T, B, C>
) -> <Scale<T, A, B> as Mul<Scale<T, B, C>>>::Output
impl<Src, Dst, T> Mul<Scale<T, Src, Dst>> for Length<T, Src> where
T: Mul<T>,
[src]
T: Mul<T>,
type Output = Length<<T as Mul<T>>::Output, Dst>
The resulting type after applying the *
operator.
fn mul(
self,
scale: Scale<T, Src, Dst>
) -> <Length<T, Src> as Mul<Scale<T, Src, Dst>>>::Output
[src]
self,
scale: Scale<T, Src, Dst>
) -> <Length<T, Src> as Mul<Scale<T, Src, Dst>>>::Output
impl<A, B> Mul<Scale<f32, A, B>> for SpriteRotation<A>
[src]
type Output = SpriteRotation<B>
The resulting type after applying the *
operator.
fn mul(self, rhs: Scale<f32, A, B>) -> Self::Output
[src]
impl<Src, Dst> Mul<Scale<f32, Src, Dst>> for Path<Src>
[src]
type Output = Path<Dst>
The resulting type after applying the *
operator.
fn mul(self, scale: Scale<f32, Src, Dst>) -> Self::Output
[src]
impl<Src, Dst> Mul<Scale<f32, Src, Dst>> for PathEvent<Src>
[src]
type Output = PathEvent<Dst>
The resulting type after applying the *
operator.
fn mul(self, scale: Scale<f32, Src, Dst>) -> Self::Output
[src]
impl<Src, Dst> Mul<Scale<f32, Src, Dst>> for Shape<Src>
[src]
type Output = Shape<Dst>
The resulting type after applying the *
operator.
fn mul(self, scale: Scale<f32, Src, Dst>) -> Self::Output
[src]
impl<T, Src, Dst> One for Scale<T, Src, Dst> where
T: One,
[src]
T: One,
impl<T, Src, Dst> Ord for Scale<T, Src, Dst> where
T: Ord,
[src]
T: Ord,
fn cmp(&self, other: &Scale<T, Src, Dst>) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<T, Src, Dst> PartialEq<Scale<T, Src, Dst>> for Scale<T, Src, Dst> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
fn eq(&self, other: &Scale<T, Src, Dst>) -> bool
[src]
#[must_use]fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<T, Src, Dst> PartialOrd<Scale<T, Src, Dst>> for Scale<T, Src, Dst> where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
fn partial_cmp(&self, other: &Scale<T, Src, Dst>) -> Option<Ordering>
[src]
#[must_use]fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<T, Src, Dst> Serialize for Scale<T, Src, Dst> where
T: Serialize,
[src]
T: Serialize,
fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
[src]
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
impl<T, Src, Dst> Sub<Scale<T, Src, Dst>> for Scale<T, Src, Dst> where
T: Sub<T>,
[src]
T: Sub<T>,
type Output = Scale<<T as Sub<T>>::Output, Src, Dst>
The resulting type after applying the -
operator.
fn sub(
self,
other: Scale<T, Src, Dst>
) -> <Scale<T, Src, Dst> as Sub<Scale<T, Src, Dst>>>::Output
[src]
self,
other: Scale<T, Src, Dst>
) -> <Scale<T, Src, Dst> as Sub<Scale<T, Src, Dst>>>::Output
impl<S> Transformation<S> for Scale<S, UnknownUnit, UnknownUnit> where
S: Scalar,
S: Scalar,
fn transform_point(&self, p: Point2D<S, UnknownUnit>) -> Point2D<S, UnknownUnit>
fn transform_vector(
&self,
v: Vector2D<S, UnknownUnit>
) -> Vector2D<S, UnknownUnit>
&self,
v: Vector2D<S, UnknownUnit>
) -> Vector2D<S, UnknownUnit>
Auto Trait Implementations
impl<T, Src, Dst> RefUnwindSafe for Scale<T, Src, Dst> where
Dst: RefUnwindSafe,
Src: RefUnwindSafe,
T: RefUnwindSafe,
Dst: RefUnwindSafe,
Src: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, Src, Dst> Send for Scale<T, Src, Dst> where
Dst: Send,
Src: Send,
T: Send,
Dst: Send,
Src: Send,
T: Send,
impl<T, Src, Dst> Sync for Scale<T, Src, Dst> where
Dst: Sync,
Src: Sync,
T: Sync,
Dst: Sync,
Src: Sync,
T: Sync,
impl<T, Src, Dst> Unpin for Scale<T, Src, Dst> where
Dst: Unpin,
Src: Unpin,
T: Unpin,
Dst: Unpin,
Src: Unpin,
T: Unpin,
impl<T, Src, Dst> UnwindSafe for Scale<T, Src, Dst> where
Dst: UnwindSafe,
Src: UnwindSafe,
T: UnwindSafe,
Dst: UnwindSafe,
Src: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S where
D: AdaptFrom<S, Swp, Dwp, T>,
Dwp: WhitePoint,
Swp: WhitePoint,
T: Component + Float,
[src]
D: AdaptFrom<S, Swp, Dwp, T>,
Dwp: WhitePoint,
Swp: WhitePoint,
T: Component + Float,
fn adapt_into_using<M>(self, method: M) -> D where
M: TransformMatrix<Swp, Dwp, T>,
[src]
M: TransformMatrix<Swp, Dwp, T>,
fn adapt_into(self) -> D
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Component for T where
T: 'static + Send + Sync,
[src]
T: 'static + Send + Sync,
type Storage = PackedStorage<T>
The storage type required to hold all instances of this component in a world.
impl<T, U> ConvertInto<U> for T where
U: ConvertFrom<T>,
[src]
U: ConvertFrom<T>,
fn convert_into(self) -> U
[src]
fn convert_unclamped_into(self) -> U
[src]
fn try_convert_into(self) -> Result<U, OutOfBounds<U>>
[src]
impl<T> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,
[src]
T: for<'de> Deserialize<'de>,
impl<T> Downcast for T where
T: Any,
T: Any,
fn into_any(self: Box<T>) -> Box<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn as_any(&self) -> &(dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
impl<T> DowncastSync for T where
T: Send + Sync + Any,
T: Send + Sync + Any,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> One for T where
T: One,
[src]
T: One,
impl<T> Resource for T where
T: 'static,
[src]
T: 'static,
impl<T> Serialize for T where
T: Serialize + ?Sized,
[src]
T: Serialize + ?Sized,
fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<Ok, Error>
[src]
impl<T> SetParameter for T
fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where
T: Parameter<Self>,
T: Parameter<Self>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> TypeKey for T where
T: Serialize + for<'de> Deserialize<'de> + Ord + Clone + Hash,
[src]
T: Serialize + for<'de> Deserialize<'de> + Ord + Clone + Hash,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,