From 1f4618c117f713a44e88ca1e6af08c52c60c7eed Mon Sep 17 00:00:00 2001 From: Dzmitry Malyshau Date: Fri, 17 Aug 2018 15:44:19 -0400 Subject: [PATCH] Mint integration --- .travis.yml | 6 ++++++ Cargo.toml | 3 ++- src/lib.rs | 3 ++- src/macros.rs | 22 ++++++++++++++++++++++ src/point.rs | 30 ++++++++++++++++++++++++++++++ src/size.rs | 35 +++++++++++++++++++++++++++++++++++ src/transform2d.rs | 37 +++++++++++++++++++++++++++++++++++++ src/transform3d.rs | 37 +++++++++++++++++++++++++++++++++++++ src/vector.rs | 29 ++++++++++++++++++++++++++++- 9 files changed, 199 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 90605ea..6b08dad 100644 --- a/.travis.yml +++ b/.travis.yml @@ -15,6 +15,12 @@ env: matrix: include: + - rust: stable + env: FEATURES="" + - rust: stable + env: FEATURES="--features mint" + - rust: beta + env: FEATURES="" - rust: nightly env: FEATURES="--features unstable" - rust: nightly diff --git a/Cargo.toml b/Cargo.toml index 67a1937..dfc713c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "euclid" -version = "0.19.0" +version = "0.19.1" authors = ["The Servo Project Developers"] description = "Geometry primitives" documentation = "https://docs.rs/euclid/" @@ -15,6 +15,7 @@ unstable = [] [dependencies] num-traits = { version = "0.2" } serde = { version = "1.0", features = ["serde_derive"], optional = true } +mint = {version = "0.5.1", optional = true} [dev-dependencies] rand = "0.4" diff --git a/src/lib.rs b/src/lib.rs index 7ad54d6..7f7d5ae 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -60,10 +60,11 @@ #[macro_use] extern crate serde; +#[cfg(feature = "mint")] +pub extern crate mint; extern crate num_traits; #[cfg(test)] extern crate rand; - #[cfg(test)] use std as core; diff --git a/src/macros.rs b/src/macros.rs index 6659738..cf422a8 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -84,3 +84,25 @@ macro_rules! define_matrix { } ) } + +macro_rules! mint_vec { + ($name:ident [ $($field:ident),* ] = $std_name:ident) => { + #[cfg(feature = "mint")] + impl From> for $name { + fn from(v: mint::$std_name) -> Self { + $name { + $( $field: v.$field, )* + _unit: PhantomData, + } + } + } + #[cfg(feature = "mint")] + impl Into> for $name { + fn into(self) -> mint::$std_name { + mint::$std_name { + $( $field: self.$field, )* + } + } + } + } +} diff --git a/src/point.rs b/src/point.rs index 437f5da..90af77c 100644 --- a/src/point.rs +++ b/src/point.rs @@ -12,6 +12,8 @@ use approxeq::ApproxEq; use length::Length; use scale::TypedScale; use size::TypedSize2D; +#[cfg(feature = "mint")] +use mint; use num::*; use num_traits::{Float, NumCast}; use vector::{TypedVector2D, TypedVector3D, vec2, vec3}; @@ -26,6 +28,7 @@ define_matrix! { pub y: T, } } +mint_vec!(TypedPoint2D[x, y] = Point2); /// Default 2d point type with no unit. /// @@ -408,6 +411,7 @@ define_matrix! { pub z: T, } } +mint_vec!(TypedPoint3D[x, y, z] = Point3); /// Default 3d point type with no unit. /// @@ -777,9 +781,12 @@ pub fn point3(x: T, y: T, z: T) -> TypedPoint3D { TypedPoint3D::new(x, y, z) } + #[cfg(test)] mod point2d { use super::Point2D; + #[cfg(feature = "mint")] + use mint; #[test] pub fn test_scalar_mul() { @@ -809,6 +816,16 @@ mod point2d { assert_eq!(result, Point2D::new(2.0, 3.0)); } + + #[cfg(feature = "mint")] + #[test] + pub fn test_mint() { + let p1 = Point2D::new(1.0, 3.0); + let pm: mint::Point2<_> = p1.into(); + let p2 = Point2D::from(pm); + + assert_eq!(p1, p2); + } } #[cfg(test)] @@ -874,6 +891,8 @@ mod typedpoint2d { #[cfg(test)] mod point3d { use super::{Point3D, point2, point3}; + #[cfg(feature = "mint")] + use mint; #[test] pub fn test_min() { @@ -915,4 +934,15 @@ mod point3d { assert_eq!(p.xz(), point2(1, 3)); assert_eq!(p.yz(), point2(2, 3)); } + + #[cfg(feature = "mint")] + #[test] + pub fn test_mint() { + let p1 = Point3D::new(1.0, 3.0, 5.0); + let pm: mint::Point3<_> = p1.into(); + let p2 = Point3D::from(pm); + + assert_eq!(p1, p2); + } + } diff --git a/src/size.rs b/src/size.rs index e55a416..513e9a8 100644 --- a/src/size.rs +++ b/src/size.rs @@ -8,6 +8,8 @@ // except according to those terms. use super::UnknownUnit; +#[cfg(feature = "mint")] +use mint; use length::Length; use scale::TypedScale; use vector::{TypedVector2D, vec2, BoolVector2D}; @@ -332,9 +334,32 @@ pub fn size2(w: T, h: T) -> TypedSize2D { TypedSize2D::new(w, h) } +#[cfg(feature = "mint")] +impl From> for TypedSize2D { + fn from(v: mint::Vector2) -> Self { + TypedSize2D { + width: v.x, + height: v.y, + _unit: PhantomData, + } + } +} +#[cfg(feature = "mint")] +impl Into> for TypedSize2D { + fn into(self) -> mint::Vector2 { + mint::Vector2 { + x: self.width, + y: self.height, + } + } +} + + #[cfg(test)] mod size2d { use super::Size2D; + #[cfg(feature = "mint")] + use mint; #[test] pub fn test_add() { @@ -379,4 +404,14 @@ mod size2d { let p = Size2D::new(1.5, 2.0); assert_eq!(p.area(), 3.0); } + + #[cfg(feature = "mint")] + #[test] + pub fn test_mint() { + let s1 = Size2D::new(1.0, 2.0); + let sm: mint::Vector2<_> = s1.into(); + let s2 = Size2D::from(sm); + + assert_eq!(s1, s2); + } } diff --git a/src/transform2d.rs b/src/transform2d.rs index 23b2497..9ff19bd 100644 --- a/src/transform2d.rs +++ b/src/transform2d.rs @@ -10,6 +10,8 @@ #![cfg_attr(feature = "cargo-clippy", allow(just_underscores_and_digits))] use super::{UnknownUnit, Angle}; +#[cfg(feature = "mint")] +use mint; use num::{One, Zero}; use point::TypedPoint2D; use vector::{TypedVector2D, vec2}; @@ -405,12 +407,37 @@ where T: Copy + fmt::Debug + } } +#[cfg(feature = "mint")] +impl From> for TypedTransform2D { + fn from(m: mint::RowMatrix3x2) -> Self { + TypedTransform2D { + m11: m.x.x, m12: m.x.y, + m21: m.y.x, m22: m.y.y, + m31: m.z.x, m32: m.z.y, + _unit: PhantomData, + } + } +} +#[cfg(feature = "mint")] +impl Into> for TypedTransform2D { + fn into(self) -> mint::RowMatrix3x2 { + mint::RowMatrix3x2 { + x: mint::Vector2 { x: self.m11, y: self.m12 }, + y: mint::Vector2 { x: self.m21, y: self.m22 }, + z: mint::Vector2 { x: self.m31, y: self.m32 }, + } + } +} + + #[cfg(test)] mod test { use super::*; use approxeq::ApproxEq; use point::Point2D; use Angle; + #[cfg(feature = "mint")] + use mint; use core::f32::consts::FRAC_PI_2; @@ -539,4 +566,14 @@ mod test { let v1 = vec2(10.0, -10.0); assert_eq!(v1, m1.transform_vector(&v1)); } + + #[cfg(feature = "mint")] + #[test] + pub fn test_mint() { + let m1 = Mat::create_rotation(rad(FRAC_PI_2)); + let mm: mint::RowMatrix3x2<_> = m1.into(); + let m2 = Mat::from(mm); + + assert_eq!(m1, m2); + } } diff --git a/src/transform3d.rs b/src/transform3d.rs index b8133b9..94b2e45 100644 --- a/src/transform3d.rs +++ b/src/transform3d.rs @@ -12,6 +12,8 @@ use super::{UnknownUnit, Angle}; use approxeq::ApproxEq; use homogen::HomogeneousVector; +#[cfg(feature = "mint")] +use mint; use trig::Trig; use point::{TypedPoint2D, TypedPoint3D}; use vector::{TypedVector2D, TypedVector3D, vec2, vec3}; @@ -741,6 +743,31 @@ where T: Copy + fmt::Debug + } } +#[cfg(feature = "mint")] +impl From> for TypedTransform3D { + fn from(m: mint::RowMatrix4) -> Self { + TypedTransform3D { + m11: m.x.x, m12: m.x.y, m13: m.x.z, m14: m.x.w, + m21: m.y.x, m22: m.y.y, m23: m.y.z, m24: m.y.w, + m31: m.z.x, m32: m.z.y, m33: m.z.z, m34: m.z.w, + m41: m.w.x, m42: m.w.y, m43: m.w.z, m44: m.w.w, + _unit: PhantomData, + } + } +} +#[cfg(feature = "mint")] +impl Into> for TypedTransform3D { + fn into(self) -> mint::RowMatrix4 { + mint::RowMatrix4 { + x: mint::Vector4 { x: self.m11, y: self.m12, z: self.m13, w: self.m14 }, + y: mint::Vector4 { x: self.m21, y: self.m22, z: self.m23, w: self.m24 }, + z: mint::Vector4 { x: self.m31, y: self.m32, z: self.m33, w: self.m34 }, + w: mint::Vector4 { x: self.m41, y: self.m42, z: self.m43, w: self.m44 }, + } + } +} + + #[cfg(test)] mod tests { use approxeq::ApproxEq; @@ -1021,4 +1048,14 @@ mod tests { m.m24 = -1.0; assert_eq!(None, m.transform_point2d(&p)); } + + #[cfg(feature = "mint")] + #[test] + pub fn test_mint() { + let m1 = Mf32::create_rotation(0.0, 0.0, 1.0, rad(FRAC_PI_2)); + let mm: mint::RowMatrix4<_> = m1.into(); + let m2 = Mf32::from(mm); + + assert_eq!(m1, m2); + } } diff --git a/src/vector.rs b/src/vector.rs index 5dc824f..8eb7c92 100644 --- a/src/vector.rs +++ b/src/vector.rs @@ -10,6 +10,8 @@ use super::UnknownUnit; use approxeq::ApproxEq; use length::Length; +#[cfg(feature = "mint")] +use mint; use point::{TypedPoint2D, TypedPoint3D, point2, point3}; use size::{TypedSize2D, size2}; use scale::TypedScale; @@ -28,6 +30,7 @@ define_matrix! { pub y: T, } } +mint_vec!(TypedVector2D[x, y] = Vector2); /// Default 2d vector type with no unit. /// @@ -468,6 +471,7 @@ define_matrix! { pub z: T, } } +mint_vec!(TypedVector3D[x, y, z] = Vector3); /// Default 3d vector type with no unit. /// @@ -1180,6 +1184,8 @@ pub fn bvec3(x: bool, y: bool, z: bool) -> BoolVector3D { #[cfg(test)] mod vector2d { use super::{Vector2D, vec2}; + #[cfg(feature = "mint")] + use mint; type Vec2 = Vector2D; #[test] @@ -1239,7 +1245,6 @@ mod vector2d { assert_eq!(result, vec2(2.0, 3.0)); } - #[test] pub fn test_angle_from_x_axis() { use core::f32::consts::FRAC_PI_2; @@ -1253,6 +1258,16 @@ mod vector2d { assert!(down.angle_from_x_axis().get().approx_eq(&FRAC_PI_2)); assert!(up.angle_from_x_axis().get().approx_eq(&-FRAC_PI_2)); } + + #[cfg(feature = "mint")] + #[test] + pub fn test_mint() { + let v1 = Vec2::new(1.0, 3.0); + let vm: mint::Vector2<_> = v1.into(); + let v2 = Vec2::from(vm); + + assert_eq!(v1, v2); + } } #[cfg(test)] @@ -1303,6 +1318,8 @@ mod typedvector2d { #[cfg(test)] mod vector3d { + #[cfg(feature = "mint")] + use mint; use super::{TypedVector3D, Vector3D, vec2, vec3}; use scale::TypedScale; @@ -1379,6 +1396,16 @@ mod vector3d { assert_eq!(p.xz(), vec2(1, 3)); assert_eq!(p.yz(), vec2(2, 3)); } + + #[cfg(feature = "mint")] + #[test] + pub fn test_mint() { + let v1 = Vec3::new(1.0, 3.0, 5.0); + let vm: mint::Vector3<_> = v1.into(); + let v2 = Vec3::from(vm); + + assert_eq!(v1, v2); + } } #[cfg(test)]