1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
// Copyright 2013 The Servo Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![cfg_attr(feature = "unstable", feature(asm, repr_simd, test))] //! A collection of strongly typed math tools for computer graphics with an inclination //! towards 2d graphics and layout. //! //! All types are generic over the scalar type of their component (`f32`, `i32`, etc.), //! and tagged with a generic Unit parameter which is useful to prevent mixing //! values from different spaces. For example it should not be legal to translate //! a screen-space position by a world-space vector and this can be expressed using //! the generic Unit parameter. //! //! This unit system is not mandatory and all Typed* structures have an alias //! with the default unit: `UnknownUnit`. //! for example ```Point2D<T>``` is equivalent to ```TypedPoint2D<T, UnknownUnit>```. //! Client code typically creates a set of aliases for each type and doesn't need //! to deal with the specifics of typed units further. For example: //! //! All euclid types are marked `#[repr(C)]` in order to facilitate exposing them to //! foreign function interfaces (provided the underlying scalar type is also `repr(C)`). //! //! ```rust //! use euclid::*; //! pub struct ScreenSpace; //! pub type ScreenPoint = TypedPoint2D<f32, ScreenSpace>; //! pub type ScreenSize = TypedSize2D<f32, ScreenSpace>; //! pub struct WorldSpace; //! pub type WorldPoint = TypedPoint3D<f32, WorldSpace>; //! pub type ProjectionMatrix = TypedMatrix4D<f32, WorldSpace, ScreenSpace>; //! // etc... //! ``` //! //! Components are accessed in their scalar form by default for convenience, and most //! types additionally implement strongly typed accessors which return typed ```Length``` wrappers. //! For example: //! //! ```rust //! # use euclid::*; //! # pub struct WorldSpace; //! # pub type WorldPoint = TypedPoint3D<f32, WorldSpace>; //! let p = WorldPoint::new(0.0, 1.0, 1.0); //! // p.x is an f32. //! println!("p.x = {:?} ", p.x); //! // p.x is a Length<f32, WorldSpace>. //! println!("p.x_typed() = {:?} ", p.x_typed()); //! // Length::get returns the scalar value (f32). //! assert_eq!(p.x, p.x_typed().get()); //! ``` extern crate heapsize; #[cfg_attr(test, macro_use)] extern crate log; extern crate serde; #[cfg(test)] extern crate rand; #[cfg(feature = "unstable")] extern crate test; extern crate num_traits; pub use length::Length; pub use scale_factor::ScaleFactor; pub use transform2d::{Transform2D, TypedTransform2D}; pub use transform3d::{Transform3D, TypedTransform3D}; pub use point::{ Point2D, TypedPoint2D, point2, Point3D, TypedPoint3D, point3, }; pub use vector::{ Vector2D, TypedVector2D, vec2, Vector3D, TypedVector3D, vec3, }; pub use rect::{Rect, TypedRect, rect}; pub use side_offsets::{SideOffsets2D, TypedSideOffsets2D}; #[cfg(feature = "unstable")] pub use side_offsets::SideOffsets2DSimdI32; pub use size::{Size2D, TypedSize2D, size2}; pub use trig::Trig; pub mod approxeq; pub mod num; mod length; #[macro_use] mod macros; mod transform2d; mod transform3d; mod point; mod rect; mod scale_factor; mod side_offsets; mod size; mod trig; mod vector; /// The default unit. #[derive(Clone, Copy)] pub struct UnknownUnit; /// Unit for angles in radians. pub struct Rad; /// Unit for angles in degrees. pub struct Deg; /// A value in radians. pub type Radians<T> = Length<T, Rad>; /// A value in Degrees. pub type Degrees<T> = Length<T, Deg>; /// Temporary alias to facilitate the transition to the new naming scheme #[deprecated] pub type Matrix2D<T> = Transform2D<T>; /// Temporary alias to facilitate the transition to the new naming scheme #[deprecated] pub type TypedMatrix2D<T, Src, Dst> = TypedTransform2D<T, Src, Dst>; /// Temporary alias to facilitate the transition to the new naming scheme #[deprecated] pub type Matrix4D<T> = Transform3D<T>; /// Temporary alias to facilitate the transition to the new naming scheme #[deprecated] pub type TypedMatrix4D<T, Src, Dst> = TypedTransform3D<T, Src, Dst>;