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
// 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 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: //! //! ```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; #[macro_use] extern crate log; extern crate rustc_serialize; 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 matrix2d::{Matrix2D, TypedMatrix2D}; pub use matrix4d::{Matrix4D, TypedMatrix4D}; pub use point::{ Point2D, TypedPoint2D, Point3D, TypedPoint3D, Point4D, TypedPoint4D, }; pub use rect::{Rect, TypedRect}; pub use side_offsets::{SideOffsets2D, TypedSideOffsets2D}; #[cfg(feature = "unstable")] pub use side_offsets::SideOffsets2DSimdI32; pub use size::{Size2D, TypedSize2D}; pub mod approxeq; pub mod length; #[macro_use] mod macros; pub mod matrix2d; pub mod matrix4d; pub mod num; pub mod point; pub mod rect; pub mod scale_factor; pub mod side_offsets; pub mod size; mod trig; /// The default unit. #[derive(Clone, Copy, RustcDecodable, RustcEncodable)] 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>;