From b9ca0747409f34f596257fa6ed300de6ad3e134b Mon Sep 17 00:00:00 2001 From: sebcrozet Date: Sun, 21 Oct 2018 22:11:27 +0200 Subject: [PATCH] Execute rustfmt. --- nalgebra-glm/src/aliases.rs | 19 +- nalgebra-glm/src/exponential.rs | 31 +- nalgebra-glm/src/ext/matrix_clip_space.rs | 3 +- nalgebra-glm/src/ext/matrix_projection.rs | 52 ++- nalgebra-glm/src/ext/matrix_relationnal.rs | 62 +++- nalgebra-glm/src/ext/matrix_transform.rs | 22 +- nalgebra-glm/src/ext/mod.rs | 39 ++- nalgebra-glm/src/ext/quaternion_common.rs | 4 +- nalgebra-glm/src/ext/quaternion_geometric.rs | 2 +- nalgebra-glm/src/ext/quaternion_relational.rs | 1 - nalgebra-glm/src/ext/quaternion_transform.rs | 4 +- .../src/ext/quaternion_trigonometric.rs | 2 +- nalgebra-glm/src/ext/vector_common.rs | 48 ++- nalgebra-glm/src/ext/vector_relational.rs | 44 ++- nalgebra-glm/src/geometric.rs | 48 ++- nalgebra-glm/src/gtc/epsilon.rs | 2 +- nalgebra-glm/src/gtc/matrix_access.rs | 32 +- nalgebra-glm/src/gtc/matrix_inverse.rs | 16 +- nalgebra-glm/src/gtc/mod.rs | 25 +- nalgebra-glm/src/gtc/quaternion.rs | 5 +- nalgebra-glm/src/gtc/type_ptr.rs | 49 +-- nalgebra-glm/src/gtx/component_wise.rs | 18 +- nalgebra-glm/src/gtx/exterior_product.rs | 4 +- .../src/gtx/handed_coordinate_space.rs | 2 +- nalgebra-glm/src/gtx/matrix_operation.rs | 4 +- nalgebra-glm/src/gtx/mod.rs | 38 ++- nalgebra-glm/src/gtx/norm.rs | 32 +- nalgebra-glm/src/gtx/normal.rs | 2 +- nalgebra-glm/src/gtx/normalize_dot.rs | 12 +- nalgebra-glm/src/gtx/quaternion.rs | 19 +- nalgebra-glm/src/gtx/rotate_vector.rs | 6 +- nalgebra-glm/src/gtx/transform.rs | 5 +- nalgebra-glm/src/gtx/transform2.rs | 40 +-- nalgebra-glm/src/gtx/transform2d.rs | 2 +- nalgebra-glm/src/gtx/vector_angle.rs | 7 +- nalgebra-glm/src/gtx/vector_query.rs | 20 +- nalgebra-glm/src/lib.rs | 307 +++++++++--------- nalgebra-glm/src/matrix.rs | 38 ++- nalgebra-glm/src/traits.rs | 94 ++++-- nalgebra-glm/src/trigonometric.rs | 63 +++- nalgebra-glm/src/vector_relational.rs | 40 ++- 41 files changed, 798 insertions(+), 465 deletions(-) diff --git a/nalgebra-glm/src/aliases.rs b/nalgebra-glm/src/aliases.rs index 9bb7edb6..206a8abe 100644 --- a/nalgebra-glm/src/aliases.rs +++ b/nalgebra-glm/src/aliases.rs @@ -1,9 +1,7 @@ -use na::{MatrixMN, VectorN, - Matrix2, Matrix3, Matrix4, - Matrix2x3, Matrix3x2, Matrix4x2, - Matrix2x4, Matrix3x4, Matrix4x3, - Quaternion, - U1, U2, U3, U4}; +use na::{ + Matrix2, Matrix2x3, Matrix2x4, Matrix3, Matrix3x2, Matrix3x4, Matrix4, Matrix4x2, Matrix4x3, + MatrixMN, Quaternion, VectorN, U1, U2, U3, U4, +}; /// A matrix with components of type `N`. It has `R` rows, and `C` columns. /// @@ -194,13 +192,13 @@ pub type UVec3 = TVec3; /// A 4D vector with `u32` components. pub type UVec4 = TVec4; /// A 1D vector with `f32` components. -pub type Vec1 = TVec1; +pub type Vec1 = TVec1; /// A 2D vector with `f32` components. -pub type Vec2 = TVec2; +pub type Vec2 = TVec2; /// A 3D vector with `f32` components. -pub type Vec3 = TVec3; +pub type Vec3 = TVec3; /// A 4D vector with `f32` components. -pub type Vec4 = TVec4; +pub type Vec4 = TVec4; /// A 1D vector with `u64` components. pub type U64Vec1 = TVec1; @@ -270,7 +268,6 @@ pub type I8Vec3 = TVec3; /// A 4D vector with `i8` components. pub type I8Vec4 = TVec4; - /// A 2x2 matrix with components of type `N`. pub type TMat2 = Matrix2; /// A 2x2 matrix with components of type `N`. diff --git a/nalgebra-glm/src/exponential.rs b/nalgebra-glm/src/exponential.rs index d73db3a8..a913dbc8 100644 --- a/nalgebra-glm/src/exponential.rs +++ b/nalgebra-glm/src/exponential.rs @@ -1,5 +1,5 @@ -use na::{Real, DefaultAllocator}; use aliases::TVec; +use na::{DefaultAllocator, Real}; use traits::{Alloc, Dimension}; /// Component-wise exponential. @@ -8,7 +8,9 @@ use traits::{Alloc, Dimension}; /// /// * [`exp2`](fn.exp2.html) pub fn exp(v: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ v.map(|x| x.exp()) } @@ -18,7 +20,9 @@ pub fn exp(v: &TVec) -> TVec /// /// * [`exp`](fn.exp.html) pub fn exp2(v: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ v.map(|x| x.exp2()) } @@ -28,9 +32,10 @@ pub fn exp2(v: &TVec) -> TVec /// /// * [`sqrt`](fn.sqrt.html) pub fn inversesqrt(v: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ v.map(|x| N::one() / x.sqrt()) - } /// Component-wise logarithm. @@ -39,7 +44,9 @@ pub fn inversesqrt(v: &TVec) -> TVec /// /// * [`log2`](fn.log2.html) pub fn log(v: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ v.map(|x| x.ln()) } @@ -49,13 +56,17 @@ pub fn log(v: &TVec) -> TVec /// /// * [`log`](fn.log.html) pub fn log2(v: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ v.map(|x| x.log2()) } /// Component-wise power. pub fn pow(base: &TVec, exponent: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ base.zip_map(exponent, |b, e| b.powf(e)) } @@ -68,6 +79,8 @@ pub fn pow(base: &TVec, exponent: &TVec) -> T /// * [`inversesqrt`](fn.inversesqrt.html) /// * [`pow`](fn.pow.html) pub fn sqrt(v: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ v.map(|x| x.sqrt()) } diff --git a/nalgebra-glm/src/ext/matrix_clip_space.rs b/nalgebra-glm/src/ext/matrix_clip_space.rs index 813fe8fc..89c137ea 100644 --- a/nalgebra-glm/src/ext/matrix_clip_space.rs +++ b/nalgebra-glm/src/ext/matrix_clip_space.rs @@ -1,5 +1,5 @@ -use na::{Real, Orthographic3, Perspective3}; use aliases::TMat4; +use na::{Orthographic3, Perspective3, Real}; //pub fn frustum(left: N, right: N, bottom: N, top: N, near: N, far: N) -> TMat4 { // unimplemented!() @@ -90,7 +90,6 @@ pub fn ortho(left: N, right: N, bottom: N, top: N, znear: N, zfar: N) - // unimplemented!() //} - /// Creates a matrix for a perspective-view frustum based on the right handedness and OpenGL near and far clip planes definition. /// /// # Important note diff --git a/nalgebra-glm/src/ext/matrix_projection.rs b/nalgebra-glm/src/ext/matrix_projection.rs index b8d2fc8d..7f07d3a4 100644 --- a/nalgebra-glm/src/ext/matrix_projection.rs +++ b/nalgebra-glm/src/ext/matrix_projection.rs @@ -1,6 +1,6 @@ use na::{self, Real, U3}; -use aliases::{TVec2, TVec3, TVec4, TMat4}; +use aliases::{TMat4, TVec2, TVec3, TVec4}; /// Define a picking region. /// @@ -13,11 +13,15 @@ pub fn pick_matrix(center: &TVec2, delta: &TVec2, viewport: &TVec let shift = TVec3::new( (viewport.z - (center.x - viewport.x) * na::convert(2.0)) / delta.x, (viewport.w - (center.y - viewport.y) * na::convert(2.0)) / delta.y, - N::zero() + N::zero(), ); let result = TMat4::new_translation(&shift); - result.prepend_nonuniform_scaling(&TVec3::new(viewport.z / delta.x, viewport.w / delta.y, N::one())) + result.prepend_nonuniform_scaling(&TVec3::new( + viewport.z / delta.x, + viewport.w / delta.y, + N::one(), + )) } /// Map the specified object coordinates `(obj.x, obj.y, obj.z)` into window coordinates using OpenGL near and far clip planes definition. @@ -36,7 +40,12 @@ pub fn pick_matrix(center: &TVec2, delta: &TVec2, viewport: &TVec /// * [`unproject`](fn.unproject.html) /// * [`unproject_no`](fn.unproject_no.html) /// * [`unproject_zo`](fn.unproject_zo.html) -pub fn project(obj: &TVec3, model: &TMat4, proj: &TMat4, viewport: TVec4) -> TVec3 { +pub fn project( + obj: &TVec3, + model: &TMat4, + proj: &TMat4, + viewport: TVec4, +) -> TVec3 { project_no(obj, model, proj, viewport) } @@ -58,7 +67,12 @@ pub fn project(obj: &TVec3, model: &TMat4, proj: &TMat4, viewp /// * [`unproject`](fn.unproject.html) /// * [`unproject_no`](fn.unproject_no.html) /// * [`unproject_zo`](fn.unproject_zo.html) -pub fn project_no(obj: &TVec3, model: &TMat4, proj: &TMat4, viewport: TVec4) -> TVec3 { +pub fn project_no( + obj: &TVec3, + model: &TMat4, + proj: &TMat4, + viewport: TVec4, +) -> TVec3 { let proj = project_zo(obj, model, proj, viewport); TVec3::new(proj.x, proj.y, proj.z * na::convert(0.5) + na::convert(0.5)) } @@ -81,7 +95,12 @@ pub fn project_no(obj: &TVec3, model: &TMat4, proj: &TMat4, vi /// * [`unproject`](fn.unproject.html) /// * [`unproject_no`](fn.unproject_no.html) /// * [`unproject_zo`](fn.unproject_zo.html) -pub fn project_zo(obj: &TVec3, model: &TMat4, proj: &TMat4, viewport: TVec4) -> TVec3 { +pub fn project_zo( + obj: &TVec3, + model: &TMat4, + proj: &TMat4, + viewport: TVec4, +) -> TVec3 { let normalized = proj * model * TVec4::new(obj.x, obj.y, obj.z, N::one()); let scale = N::one() / normalized.w; @@ -108,7 +127,12 @@ pub fn project_zo(obj: &TVec3, model: &TMat4, proj: &TMat4, vi /// * [`project_zo`](fn.project_zo.html) /// * [`unproject_no`](fn.unproject_no.html) /// * [`unproject_zo`](fn.unproject_zo.html) -pub fn unproject(win: &TVec3, model: &TMat4, proj: &TMat4, viewport: TVec4) -> TVec3 { +pub fn unproject( + win: &TVec3, + model: &TMat4, + proj: &TMat4, + viewport: TVec4, +) -> TVec3 { unproject_no(win, model, proj, viewport) } @@ -130,7 +154,12 @@ pub fn unproject(win: &TVec3, model: &TMat4, proj: &TMat4, vie /// * [`project_zo`](fn.project_zo.html) /// * [`unproject`](fn.unproject.html) /// * [`unproject_zo`](fn.unproject_zo.html) -pub fn unproject_no(win: &TVec3, model: &TMat4, proj: &TMat4, viewport: TVec4) -> TVec3 { +pub fn unproject_no( + win: &TVec3, + model: &TMat4, + proj: &TMat4, + viewport: TVec4, +) -> TVec3 { let _2: N = na::convert(2.0); let transform = (proj * model).try_inverse().unwrap_or_else(TMat4::zeros); let pt = TVec4::new( @@ -162,7 +191,12 @@ pub fn unproject_no(win: &TVec3, model: &TMat4, proj: &TMat4, /// * [`project_zo`](fn.project_zo.html) /// * [`unproject`](fn.unproject.html) /// * [`unproject_no`](fn.unproject_no.html) -pub fn unproject_zo(win: &TVec3, model: &TMat4, proj: &TMat4, viewport: TVec4) -> TVec3 { +pub fn unproject_zo( + win: &TVec3, + model: &TMat4, + proj: &TMat4, + viewport: TVec4, +) -> TVec3 { let _2: N = na::convert(2.0); let transform = (proj * model).try_inverse().unwrap_or_else(TMat4::zeros); let pt = TVec4::new( diff --git a/nalgebra-glm/src/ext/matrix_relationnal.rs b/nalgebra-glm/src/ext/matrix_relationnal.rs index d5f34ae8..80fb8b6f 100644 --- a/nalgebra-glm/src/ext/matrix_relationnal.rs +++ b/nalgebra-glm/src/ext/matrix_relationnal.rs @@ -1,13 +1,18 @@ use na::DefaultAllocator; -use aliases::{TVec, TMat}; -use traits::{Alloc, Number, Dimension}; +use aliases::{TMat, TVec}; +use traits::{Alloc, Dimension, Number}; /// Perform a component-wise equal-to comparison of two matrices. /// /// Return a boolean vector which components value is True if this expression is satisfied per column of the matrices. -pub fn equal_columns(x: &TMat, y: &TMat) -> TVec - where DefaultAllocator: Alloc { +pub fn equal_columns( + x: &TMat, + y: &TMat, +) -> TVec +where + DefaultAllocator: Alloc, +{ let mut res = TVec::<_, C>::repeat(false); for i in 0..C::dim() { @@ -20,16 +25,28 @@ pub fn equal_columns(x: &TMat, y /// Returns the component-wise comparison of `|x - y| < epsilon`. /// /// True if this expression is satisfied. -pub fn equal_columns_eps(x: &TMat, y: &TMat, epsilon: N) -> TVec - where DefaultAllocator: Alloc { +pub fn equal_columns_eps( + x: &TMat, + y: &TMat, + epsilon: N, +) -> TVec +where + DefaultAllocator: Alloc, +{ equal_columns_eps_vec(x, y, &TVec::<_, C>::repeat(epsilon)) } /// Returns the component-wise comparison on each matrix column `|x - y| < epsilon`. /// /// True if this expression is satisfied. -pub fn equal_columns_eps_vec(x: &TMat, y: &TMat, epsilon: &TVec) -> TVec - where DefaultAllocator: Alloc { +pub fn equal_columns_eps_vec( + x: &TMat, + y: &TMat, + epsilon: &TVec, +) -> TVec +where + DefaultAllocator: Alloc, +{ let mut res = TVec::<_, C>::repeat(false); for i in 0..C::dim() { @@ -42,8 +59,13 @@ pub fn equal_columns_eps_vec(x: &TMat(x: &TMat, y: &TMat) -> TVec - where DefaultAllocator: Alloc { +pub fn not_equal_columns( + x: &TMat, + y: &TMat, +) -> TVec +where + DefaultAllocator: Alloc, +{ let mut res = TVec::<_, C>::repeat(false); for i in 0..C::dim() { @@ -56,16 +78,28 @@ pub fn not_equal_columns(x: &TMat(x: &TMat, y: &TMat, epsilon: N) -> TVec - where DefaultAllocator: Alloc { +pub fn not_equal_columns_eps( + x: &TMat, + y: &TMat, + epsilon: N, +) -> TVec +where + DefaultAllocator: Alloc, +{ not_equal_columns_eps_vec(x, y, &TVec::<_, C>::repeat(epsilon)) } /// Returns the component-wise comparison of `|x - y| >= epsilon`. /// /// True if this expression is not satisfied. -pub fn not_equal_columns_eps_vec(x: &TMat, y: &TMat, epsilon: &TVec) -> TVec - where DefaultAllocator: Alloc { +pub fn not_equal_columns_eps_vec( + x: &TMat, + y: &TMat, + epsilon: &TVec, +) -> TVec +where + DefaultAllocator: Alloc, +{ let mut res = TVec::<_, C>::repeat(false); for i in 0..C::dim() { diff --git a/nalgebra-glm/src/ext/matrix_transform.rs b/nalgebra-glm/src/ext/matrix_transform.rs index af2408fd..613a4beb 100644 --- a/nalgebra-glm/src/ext/matrix_transform.rs +++ b/nalgebra-glm/src/ext/matrix_transform.rs @@ -1,11 +1,13 @@ -use na::{DefaultAllocator, Real, Unit, Rotation3, Point3}; +use na::{DefaultAllocator, Point3, Real, Rotation3, Unit}; -use traits::{Dimension, Number, Alloc}; -use aliases::{TMat, TVec, TVec3, TMat4}; +use aliases::{TMat, TMat4, TVec, TVec3}; +use traits::{Alloc, Dimension, Number}; /// The identity matrix. pub fn identity() -> TMat - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ TMat::::identity() } @@ -38,7 +40,11 @@ pub fn look_at(eye: &TVec3, center: &TVec3, up: &TVec3) -> TMa /// * [`look_at`](fn.look_at.html) /// * [`look_at_rh`](fn.look_at_rh.html) pub fn look_at_lh(eye: &TVec3, center: &TVec3, up: &TVec3) -> TMat4 { - TMat::look_at_lh(&Point3::from_coordinates(*eye), &Point3::from_coordinates(*center), up) + TMat::look_at_lh( + &Point3::from_coordinates(*eye), + &Point3::from_coordinates(*center), + up, + ) } /// Build a right handed look at view matrix. @@ -54,7 +60,11 @@ pub fn look_at_lh(eye: &TVec3, center: &TVec3, up: &TVec3) -> /// * [`look_at`](fn.look_at.html) /// * [`look_at_lh`](fn.look_at_lh.html) pub fn look_at_rh(eye: &TVec3, center: &TVec3, up: &TVec3) -> TMat4 { - TMat::look_at_rh(&Point3::from_coordinates(*eye), &Point3::from_coordinates(*center), up) + TMat::look_at_rh( + &Point3::from_coordinates(*eye), + &Point3::from_coordinates(*center), + up, + ) } /// Builds a rotation 4 * 4 matrix created from an axis vector and an angle and right-multiply it to `m`. diff --git a/nalgebra-glm/src/ext/mod.rs b/nalgebra-glm/src/ext/mod.rs index 5d8e9d5c..6ad74ff6 100644 --- a/nalgebra-glm/src/ext/mod.rs +++ b/nalgebra-glm/src/ext/mod.rs @@ -1,30 +1,41 @@ //! (Reexported) Additional features not specified by GLSL specification pub use self::matrix_clip_space::{ortho, perspective}; -pub use self::matrix_projection::{pick_matrix, project, project_no, project_zo, unproject, unproject_no, unproject_zo}; -pub use self::matrix_relationnal::{equal_columns, equal_columns_eps, equal_columns_eps_vec, not_equal_columns, not_equal_columns_eps, not_equal_columns_eps_vec}; -pub use self::matrix_transform::{identity, look_at, look_at_lh, rotate, scale, look_at_rh, translate, rotate_x, rotate_y, rotate_z}; +pub use self::matrix_projection::{ + pick_matrix, project, project_no, project_zo, unproject, unproject_no, unproject_zo, +}; +pub use self::matrix_relationnal::{ + equal_columns, equal_columns_eps, equal_columns_eps_vec, not_equal_columns, + not_equal_columns_eps, not_equal_columns_eps_vec, +}; +pub use self::matrix_transform::{ + identity, look_at, look_at_lh, look_at_rh, rotate, rotate_x, rotate_y, rotate_z, scale, + translate, +}; +pub use self::quaternion_common::{quat_conjugate, quat_inverse, quat_lerp, quat_slerp}; +pub use self::quaternion_geometric::{ + quat_cross, quat_dot, quat_length, quat_magnitude, quat_normalize, +}; +pub use self::quaternion_relational::{ + quat_equal, quat_equal_eps, quat_not_equal, quat_not_equal_eps, +}; +pub use self::quaternion_transform::{quat_exp, quat_log, quat_pow, quat_rotate}; +pub use self::quaternion_trigonometric::{quat_angle, quat_angle_axis, quat_axis}; pub use self::scalar_common::{max3_scalar, max4_scalar, min3_scalar, min4_scalar}; pub use self::scalar_constants::{epsilon, pi}; pub use self::vector_common::{max, max2, max3, max4, min, min2, min3, min4}; pub use self::vector_relational::{equal_eps, equal_eps_vec, not_equal_eps, not_equal_eps_vec}; -pub use self::quaternion_common::{quat_conjugate, quat_inverse, quat_lerp, quat_slerp}; -pub use self::quaternion_geometric::{quat_cross, quat_dot, quat_length, quat_magnitude, quat_normalize}; -pub use self::quaternion_relational::{quat_equal, quat_equal_eps, quat_not_equal, quat_not_equal_eps}; -pub use self::quaternion_transform::{quat_exp, quat_log, quat_pow, quat_rotate}; -pub use self::quaternion_trigonometric::{quat_angle, quat_angle_axis, quat_axis}; - mod matrix_clip_space; mod matrix_projection; mod matrix_relationnal; mod matrix_transform; -mod scalar_common; -mod scalar_constants; -mod vector_common; -mod vector_relational; mod quaternion_common; mod quaternion_geometric; mod quaternion_relational; mod quaternion_transform; -mod quaternion_trigonometric; \ No newline at end of file +mod quaternion_trigonometric; +mod scalar_common; +mod scalar_constants; +mod vector_common; +mod vector_relational; diff --git a/nalgebra-glm/src/ext/quaternion_common.rs b/nalgebra-glm/src/ext/quaternion_common.rs index 84af997d..208601ed 100644 --- a/nalgebra-glm/src/ext/quaternion_common.rs +++ b/nalgebra-glm/src/ext/quaternion_common.rs @@ -31,5 +31,7 @@ pub fn quat_lerp(x: &Qua, y: &Qua, a: N) -> Qua { /// Interpolate spherically between `x` and `y`. pub fn quat_slerp(x: &Qua, y: &Qua, a: N) -> Qua { - Unit::new_normalize(*x).slerp(&Unit::new_normalize(*y), a).unwrap() + Unit::new_normalize(*x) + .slerp(&Unit::new_normalize(*y), a) + .unwrap() } diff --git a/nalgebra-glm/src/ext/quaternion_geometric.rs b/nalgebra-glm/src/ext/quaternion_geometric.rs index 88838f8a..a67de587 100644 --- a/nalgebra-glm/src/ext/quaternion_geometric.rs +++ b/nalgebra-glm/src/ext/quaternion_geometric.rs @@ -25,4 +25,4 @@ pub fn quat_magnitude(q: &Qua) -> N { /// Normalizes the quaternion `q`. pub fn quat_normalize(q: &Qua) -> Qua { q.normalize() -} \ No newline at end of file +} diff --git a/nalgebra-glm/src/ext/quaternion_relational.rs b/nalgebra-glm/src/ext/quaternion_relational.rs index d493defd..e459054f 100644 --- a/nalgebra-glm/src/ext/quaternion_relational.rs +++ b/nalgebra-glm/src/ext/quaternion_relational.rs @@ -1,6 +1,5 @@ use na::{Real, U4}; - use aliases::{Qua, TVec}; /// Component-wise equality comparison between two quaternions. diff --git a/nalgebra-glm/src/ext/quaternion_transform.rs b/nalgebra-glm/src/ext/quaternion_transform.rs index c2fedf36..a1459269 100644 --- a/nalgebra-glm/src/ext/quaternion_transform.rs +++ b/nalgebra-glm/src/ext/quaternion_transform.rs @@ -1,4 +1,4 @@ -use na::{Real, UnitQuaternion, Unit}; +use na::{Real, Unit, UnitQuaternion}; use aliases::{Qua, TVec3}; @@ -24,4 +24,4 @@ pub fn quat_rotate(q: &Qua, angle: N, axis: &TVec3) -> Qua { //pub fn quat_sqrt(q: &Qua) -> Qua { // unimplemented!() -//} \ No newline at end of file +//} diff --git a/nalgebra-glm/src/ext/quaternion_trigonometric.rs b/nalgebra-glm/src/ext/quaternion_trigonometric.rs index ae53eb72..6e9be030 100644 --- a/nalgebra-glm/src/ext/quaternion_trigonometric.rs +++ b/nalgebra-glm/src/ext/quaternion_trigonometric.rs @@ -19,4 +19,4 @@ pub fn quat_axis(x: &Qua) -> TVec3 { } else { TVec3::zeros() } -} \ No newline at end of file +} diff --git a/nalgebra-glm/src/ext/vector_common.rs b/nalgebra-glm/src/ext/vector_common.rs index 4c736651..f1b76724 100644 --- a/nalgebra-glm/src/ext/vector_common.rs +++ b/nalgebra-glm/src/ext/vector_common.rs @@ -1,7 +1,7 @@ use na::{self, DefaultAllocator}; -use traits::{Alloc, Number, Dimension}; use aliases::TVec; +use traits::{Alloc, Dimension, Number}; /// Component-wise maximum between a vector and a scalar. /// @@ -17,7 +17,9 @@ use aliases::TVec; /// * [`min3`](fn.min3.html) /// * [`min4`](fn.min4.html) pub fn max(a: &TVec, b: N) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ a.map(|a| na::sup(&a, &b)) } @@ -35,7 +37,9 @@ pub fn max(a: &TVec, b: N) -> TVec /// * [`min3`](fn.min3.html) /// * [`min4`](fn.min4.html) pub fn max2(a: &TVec, b: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ na::sup(a, b) } @@ -53,7 +57,9 @@ pub fn max2(a: &TVec, b: &TVec) -> TVec(a: &TVec, b: &TVec, c: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ max2(&max2(a, b), c) } @@ -70,8 +76,15 @@ pub fn max3(a: &TVec, b: &TVec, c: &TVec(a: &TVec, b: &TVec, c: &TVec, d: &TVec) -> TVec - where DefaultAllocator: Alloc { +pub fn max4( + a: &TVec, + b: &TVec, + c: &TVec, + d: &TVec, +) -> TVec +where + DefaultAllocator: Alloc, +{ max2(&max2(a, b), &max2(c, d)) } @@ -89,7 +102,9 @@ pub fn max4(a: &TVec, b: &TVec, c: &TVec(x: &TVec, y: N) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.map(|x| na::inf(&x, &y)) } @@ -107,7 +122,9 @@ pub fn min(x: &TVec, y: N) -> TVec /// * [`min3`](fn.min3.html) /// * [`min4`](fn.min4.html) pub fn min2(x: &TVec, y: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ na::inf(x, y) } @@ -125,7 +142,9 @@ pub fn min2(x: &TVec, y: &TVec) -> TVec(a: &TVec, b: &TVec, c: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ min2(&min2(a, b), c) } @@ -142,7 +161,14 @@ pub fn min3(a: &TVec, b: &TVec, c: &TVec(a: &TVec, b: &TVec, c: &TVec, d: &TVec) -> TVec - where DefaultAllocator: Alloc { +pub fn min4( + a: &TVec, + b: &TVec, + c: &TVec, + d: &TVec, +) -> TVec +where + DefaultAllocator: Alloc, +{ min2(&min2(a, b), &min2(c, d)) } diff --git a/nalgebra-glm/src/ext/vector_relational.rs b/nalgebra-glm/src/ext/vector_relational.rs index cfd8649b..ee418588 100644 --- a/nalgebra-glm/src/ext/vector_relational.rs +++ b/nalgebra-glm/src/ext/vector_relational.rs @@ -1,7 +1,7 @@ -use na::{DefaultAllocator}; +use na::DefaultAllocator; -use traits::{Alloc, Number, Dimension}; use aliases::TVec; +use traits::{Alloc, Dimension, Number}; /// Component-wise approximate equality of two vectors, using a scalar epsilon. /// @@ -10,8 +10,14 @@ use aliases::TVec; /// * [`equal_eps_vec`](fn.equal_eps_vec.html) /// * [`not_equal_eps`](fn.not_equal_eps.html) /// * [`not_equal_eps_vec`](fn.not_equal_eps_vec.html) -pub fn equal_eps(x: &TVec, y: &TVec, epsilon: N) -> TVec - where DefaultAllocator: Alloc { +pub fn equal_eps( + x: &TVec, + y: &TVec, + epsilon: N, +) -> TVec +where + DefaultAllocator: Alloc, +{ x.zip_map(y, |x, y| abs_diff_eq!(x, y, epsilon = epsilon)) } @@ -22,8 +28,14 @@ pub fn equal_eps(x: &TVec, y: &TVec, epsilo /// * [`equal_eps`](fn.equal_eps.html) /// * [`not_equal_eps`](fn.not_equal_eps.html) /// * [`not_equal_eps_vec`](fn.not_equal_eps_vec.html) -pub fn equal_eps_vec(x: &TVec, y: &TVec, epsilon: &TVec) -> TVec - where DefaultAllocator: Alloc { +pub fn equal_eps_vec( + x: &TVec, + y: &TVec, + epsilon: &TVec, +) -> TVec +where + DefaultAllocator: Alloc, +{ x.zip_zip_map(y, epsilon, |x, y, eps| abs_diff_eq!(x, y, epsilon = eps)) } @@ -34,8 +46,14 @@ pub fn equal_eps_vec(x: &TVec, y: &TVec, ep /// * [`equal_eps`](fn.equal_eps.html) /// * [`equal_eps_vec`](fn.equal_eps_vec.html) /// * [`not_equal_eps_vec`](fn.not_equal_eps_vec.html) -pub fn not_equal_eps(x: &TVec, y: &TVec, epsilon: N) -> TVec - where DefaultAllocator: Alloc { +pub fn not_equal_eps( + x: &TVec, + y: &TVec, + epsilon: N, +) -> TVec +where + DefaultAllocator: Alloc, +{ x.zip_map(y, |x, y| abs_diff_ne!(x, y, epsilon = epsilon)) } @@ -46,7 +64,13 @@ pub fn not_equal_eps(x: &TVec, y: &TVec, ep /// * [`equal_eps`](fn.equal_eps.html) /// * [`equal_eps_vec`](fn.equal_eps_vec.html) /// * [`not_equal_eps`](fn.not_equal_eps.html) -pub fn not_equal_eps_vec(x: &TVec, y: &TVec, epsilon: &TVec) -> TVec - where DefaultAllocator: Alloc { +pub fn not_equal_eps_vec( + x: &TVec, + y: &TVec, + epsilon: &TVec, +) -> TVec +where + DefaultAllocator: Alloc, +{ x.zip_zip_map(y, epsilon, |x, y, eps| abs_diff_ne!(x, y, epsilon = eps)) } diff --git a/nalgebra-glm/src/geometric.rs b/nalgebra-glm/src/geometric.rs index 57355bbc..c9352a47 100644 --- a/nalgebra-glm/src/geometric.rs +++ b/nalgebra-glm/src/geometric.rs @@ -1,7 +1,7 @@ -use na::{Real, DefaultAllocator}; +use na::{DefaultAllocator, Real}; -use traits::{Number, Alloc, Dimension}; use aliases::{TVec, TVec3}; +use traits::{Alloc, Dimension, Number}; /// The cross product of two vectors. pub fn cross(x: &TVec3, y: &TVec3) -> TVec3 { @@ -14,19 +14,29 @@ pub fn cross(x: &TVec3, y: &TVec3) -> TVec3 { /// /// * [`distance2`](fn.distance2.html) pub fn distance(p0: &TVec, p1: &TVec) -> N - where DefaultAllocator: Alloc { - (p1 - p0).norm() +where + DefaultAllocator: Alloc, +{ + (p1 - p0).norm() } /// The dot product of two vectors. pub fn dot(x: &TVec, y: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.dot(y) } /// If `dot(nref, i) < 0.0`, return `n`, otherwise, return `-n`. -pub fn faceforward(n: &TVec, i: &TVec, nref: &TVec) -> TVec - where DefaultAllocator: Alloc { +pub fn faceforward( + n: &TVec, + i: &TVec, + nref: &TVec, +) -> TVec +where + DefaultAllocator: Alloc, +{ if nref.dot(i) < N::zero() { n.clone() } else { @@ -44,7 +54,9 @@ pub fn faceforward(n: &TVec, i: &TVec, nref /// * [`magnitude`](fn.magnitude.html) /// * [`magnitude2`](fn.magnitude2.html) pub fn length(x: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.norm() } @@ -58,34 +70,40 @@ pub fn length(x: &TVec) -> N /// * [`magnitude2`](fn.magnitude2.html) /// * [`nalgebra::norm`](../nalgebra/fn.norm.html) pub fn magnitude(x: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.norm() } /// Normalizes a vector. pub fn normalize(x: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.normalize() } /// For the incident vector `i` and surface orientation `n`, returns the reflection direction : `result = i - 2.0 * dot(n, i) * n`. pub fn reflect_vec(i: &TVec, n: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ let _2 = N::one() + N::one(); i - n * (n.dot(i) * _2) } /// For the incident vector `i` and surface normal `n`, and the ratio of indices of refraction `eta`, return the refraction vector. pub fn refract_vec(i: &TVec, n: &TVec, eta: N) -> TVec - where DefaultAllocator: Alloc { - +where + DefaultAllocator: Alloc, +{ let ni = n.dot(i); let k = N::one() - eta * eta * (N::one() - ni * ni); if k < N::zero() { TVec::<_, D>::zeros() - } - else { + } else { i * eta - n * (eta * dot(n, i) + k.sqrt()) } } diff --git a/nalgebra-glm/src/gtc/epsilon.rs b/nalgebra-glm/src/gtc/epsilon.rs index 604ed3e4..4fd7138a 100644 --- a/nalgebra-glm/src/gtc/epsilon.rs +++ b/nalgebra-glm/src/gtc/epsilon.rs @@ -28,4 +28,4 @@ pub fn epsilon_not_equal(x: &TVec, y: &TVec pub fn epsilon_not_equal2>(x: N, y: N, epsilon: N) -> bool { abs_diff_ne!(x, y, epsilon = epsilon) } -*/ \ No newline at end of file +*/ diff --git a/nalgebra-glm/src/gtc/matrix_access.rs b/nalgebra-glm/src/gtc/matrix_access.rs index 2db271c1..eea2658b 100644 --- a/nalgebra-glm/src/gtc/matrix_access.rs +++ b/nalgebra-glm/src/gtc/matrix_access.rs @@ -1,7 +1,7 @@ -use na::{Scalar, DefaultAllocator}; +use na::{DefaultAllocator, Scalar}; +use aliases::{TMat, TVec}; use traits::{Alloc, Dimension}; -use aliases::{TVec, TMat}; /// The `index`-th column of the matrix `m`. /// @@ -11,7 +11,9 @@ use aliases::{TVec, TMat}; /// * [`set_column`](fn.set_column.html) /// * [`set_row`](fn.set_row.html) pub fn column(m: &TMat, index: usize) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ m.column(index).into_owned() } @@ -22,8 +24,14 @@ pub fn column(m: &TMat, index: u /// * [`column`](fn.column.html) /// * [`row`](fn.row.html) /// * [`set_row`](fn.set_row.html) -pub fn set_column(m: &TMat, index: usize, x: &TVec) -> TMat - where DefaultAllocator: Alloc { +pub fn set_column( + m: &TMat, + index: usize, + x: &TVec, +) -> TMat +where + DefaultAllocator: Alloc, +{ let mut res = m.clone(); res.set_column(index, x); res @@ -37,7 +45,9 @@ pub fn set_column(m: &TMat, inde /// * [`set_column`](fn.set_column.html) /// * [`set_row`](fn.set_row.html) pub fn row(m: &TMat, index: usize) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ m.row(index).into_owned().transpose() } @@ -48,8 +58,14 @@ pub fn row(m: &TMat, index: usiz /// * [`column`](fn.column.html) /// * [`row`](fn.row.html) /// * [`set_column`](fn.set_column.html) -pub fn set_row(m: &TMat, index: usize, x: &TVec) -> TMat - where DefaultAllocator: Alloc { +pub fn set_row( + m: &TMat, + index: usize, + x: &TVec, +) -> TMat +where + DefaultAllocator: Alloc, +{ let mut res = m.clone(); res.set_row(index, &x.transpose()); res diff --git a/nalgebra-glm/src/gtc/matrix_inverse.rs b/nalgebra-glm/src/gtc/matrix_inverse.rs index 0ccfca86..9f7bd159 100644 --- a/nalgebra-glm/src/gtc/matrix_inverse.rs +++ b/nalgebra-glm/src/gtc/matrix_inverse.rs @@ -1,17 +1,23 @@ -use na::{Real, DefaultAllocator}; +use na::{DefaultAllocator, Real}; -use traits::{Alloc, Dimension}; use aliases::TMat; +use traits::{Alloc, Dimension}; /// Fast matrix inverse for affine matrix. pub fn affine_inverse(m: TMat) -> TMat - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ // FIXME: this should be optimized. m.try_inverse().unwrap_or_else(TMat::<_, D, D>::zeros) } /// Compute the transpose of the inverse of a matrix. pub fn inverse_transpose(m: TMat) -> TMat - where DefaultAllocator: Alloc { - m.try_inverse().unwrap_or_else(TMat::<_, D, D>::zeros).transpose() +where + DefaultAllocator: Alloc, +{ + m.try_inverse() + .unwrap_or_else(TMat::<_, D, D>::zeros) + .transpose() } diff --git a/nalgebra-glm/src/gtc/mod.rs b/nalgebra-glm/src/gtc/mod.rs index 2fd871b2..66db7b7a 100644 --- a/nalgebra-glm/src/gtc/mod.rs +++ b/nalgebra-glm/src/gtc/mod.rs @@ -1,17 +1,32 @@ //! (Reexported) Recommended features not specified by GLSL specification //pub use self::bitfield::*; -pub use self::constants::{e, two_pi, euler, four_over_pi, golden_ratio, half_pi, ln_ln_two, ln_ten, ln_two, one, one_over_pi, one_over_root_two, one_over_two_pi, quarter_pi, root_five, root_half_pi, root_ln_four, root_pi, root_three, root_two, root_two_pi, third, three_over_two_pi, two_over_pi, two_over_root_pi, two_thirds, zero}; +pub use self::constants::{ + e, euler, four_over_pi, golden_ratio, half_pi, ln_ln_two, ln_ten, ln_two, one, one_over_pi, + one_over_root_two, one_over_two_pi, quarter_pi, root_five, root_half_pi, root_ln_four, root_pi, + root_three, root_two, root_two_pi, third, three_over_two_pi, two_over_pi, two_over_root_pi, + two_pi, two_thirds, zero, +}; //pub use self::integer::*; pub use self::matrix_access::{column, row, set_column, set_row}; pub use self::matrix_inverse::{affine_inverse, inverse_transpose}; //pub use self::packing::*; //pub use self::reciprocal::*; //pub use self::round::*; -pub use self::type_ptr::{make_mat2, make_mat2x2, make_mat2x3, make_mat2x4, make_mat3, make_mat3x2, make_mat3x3, make_mat3x4, make_mat4, make_mat4x2, make_mat4x3, make_mat4x4, make_quat, make_vec1, make_vec2, make_vec3, make_vec4, value_ptr, value_ptr_mut, vec1_to_vec2, vec1_to_vec3, vec1_to_vec4, vec2_to_vec1, vec2_to_vec2, vec2_to_vec3, vec2_to_vec4, vec3_to_vec1, vec3_to_vec2, vec3_to_vec3, vec3_to_vec4, vec4_to_vec1, vec4_to_vec2, vec4_to_vec3, vec4_to_vec4, mat2_to_mat3, mat2_to_mat4, mat3_to_mat2, mat3_to_mat4, mat4_to_mat2, mat4_to_mat3}; +pub use self::type_ptr::{ + make_mat2, make_mat2x2, make_mat2x3, make_mat2x4, make_mat3, make_mat3x2, make_mat3x3, + make_mat3x4, make_mat4, make_mat4x2, make_mat4x3, make_mat4x4, make_quat, make_vec1, make_vec2, + make_vec3, make_vec4, mat2_to_mat3, mat2_to_mat4, mat3_to_mat2, mat3_to_mat4, mat4_to_mat2, + mat4_to_mat3, value_ptr, value_ptr_mut, vec1_to_vec2, vec1_to_vec3, vec1_to_vec4, vec2_to_vec1, + vec2_to_vec2, vec2_to_vec3, vec2_to_vec4, vec3_to_vec1, vec3_to_vec2, vec3_to_vec3, + vec3_to_vec4, vec4_to_vec1, vec4_to_vec2, vec4_to_vec3, vec4_to_vec4, +}; //pub use self::ulp::*; -pub use self::quaternion::{quat_cast, quat_euler_angles, quat_greater_than, quat_greater_than_equal, quat_less_than, quat_less_than_equal, quat_look_at, quat_look_at_lh, quat_look_at_rh, quat_pitch, quat_roll, quat_yaw}; - +pub use self::quaternion::{ + quat_cast, quat_euler_angles, quat_greater_than, quat_greater_than_equal, quat_less_than, + quat_less_than_equal, quat_look_at, quat_look_at_lh, quat_look_at_rh, quat_pitch, quat_roll, + quat_yaw, +}; //mod bitfield; mod constants; @@ -24,4 +39,4 @@ mod matrix_inverse; //mod round; mod type_ptr; //mod ulp; -mod quaternion; \ No newline at end of file +mod quaternion; diff --git a/nalgebra-glm/src/gtc/quaternion.rs b/nalgebra-glm/src/gtc/quaternion.rs index 15793605..fd3e22bf 100644 --- a/nalgebra-glm/src/gtc/quaternion.rs +++ b/nalgebra-glm/src/gtc/quaternion.rs @@ -1,7 +1,6 @@ -use na::{Real, U4, UnitQuaternion}; - -use aliases::{Qua, TVec, TVec3, TMat4}; +use na::{Real, UnitQuaternion, U4}; +use aliases::{Qua, TMat4, TVec, TVec3}; /// Euler angles of the quaternion `q` as (pitch, yaw, roll). pub fn quat_euler_angles(x: &Qua) -> TVec3 { diff --git a/nalgebra-glm/src/gtc/type_ptr.rs b/nalgebra-glm/src/gtc/type_ptr.rs index 96f87ef2..1bde6951 100644 --- a/nalgebra-glm/src/gtc/type_ptr.rs +++ b/nalgebra-glm/src/gtc/type_ptr.rs @@ -1,8 +1,10 @@ -use na::{Scalar, Real, DefaultAllocator, Quaternion}; +use na::{DefaultAllocator, Quaternion, Real, Scalar}; -use traits::{Number, Alloc, Dimension}; -use aliases::{Qua, TMat, TMat2, TMat3, TMat4, TVec1, TVec2, TVec3, TVec4, - TMat2x3, TMat2x4, TMat3x2, TMat3x4, TMat4x2, TMat4x3}; +use aliases::{ + Qua, TMat, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3, TVec1, + TVec2, TVec3, TVec4, +}; +use traits::{Alloc, Dimension, Number}; /// Creates a 2x2 matrix from a slice arranged in column-major order. pub fn make_mat2(ptr: &[N]) -> TMat2 { @@ -69,19 +71,12 @@ pub fn mat2_to_mat3(m: &TMat2) -> TMat3 { let _0 = N::zero(); let _1 = N::one(); - TMat3::new( - m.m11, m.m12, _0, - m.m21, m.m22, _0, - _0, _0, _1 - ) + TMat3::new(m.m11, m.m12, _0, m.m21, m.m22, _0, _0, _0, _1) } /// Converts a 3x3 matrix to a 2x2 matrix. pub fn mat3_to_mat2(m: &TMat3) -> TMat2 { - TMat2::new( - m.m11, m.m12, - m.m21, m.m22 - ) + TMat2::new(m.m11, m.m12, m.m21, m.m22) } /// Converts a 3x3 matrix to a 4x4 matrix. @@ -90,19 +85,14 @@ pub fn mat3_to_mat4(m: &TMat3) -> TMat4 { let _1 = N::one(); TMat4::new( - m.m11, m.m12, m.m13, _0, - m.m21, m.m22, m.m23, _0, - m.m31, m.m32, m.m33, _0, - _0, _0, _0, _1, + m.m11, m.m12, m.m13, _0, m.m21, m.m22, m.m23, _0, m.m31, m.m32, m.m33, _0, _0, _0, _0, _1, ) } /// Converts a 4x4 matrix to a 3x3 matrix. pub fn mat4_to_mat3(m: &TMat4) -> TMat3 { TMat3::new( - m.m11, m.m12, m.m13, - m.m21, m.m22, m.m23, - m.m31, m.m32, m.m33, + m.m11, m.m12, m.m13, m.m21, m.m22, m.m23, m.m31, m.m32, m.m33, ) } @@ -112,19 +102,13 @@ pub fn mat2_to_mat4(m: &TMat2) -> TMat4 { let _1 = N::one(); TMat4::new( - m.m11, m.m12, _0, _0, - m.m21, m.m22, _0, _0, - _0, _0, _1, _0, - _0, _0, _0, _1, + m.m11, m.m12, _0, _0, m.m21, m.m22, _0, _0, _0, _0, _1, _0, _0, _0, _0, _1, ) } /// Converts a 4x4 matrix to a 2x2 matrix. pub fn mat4_to_mat2(m: &TMat4) -> TMat2 { - TMat2::new( - m.m11, m.m12, - m.m21, m.m22, - ) + TMat2::new(m.m11, m.m12, m.m21, m.m22) } /// Creates a quaternion from a slice arranged as `[x, y, z, w]`. @@ -400,13 +384,16 @@ pub fn make_vec4(ptr: &[N]) -> TVec4 { /// Converts a matrix or vector to a slice arranged in column-major order. pub fn value_ptr(x: &TMat) -> &[N] - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.as_slice() } /// Converts a matrix or vector to a mutable slice arranged in column-major order. pub fn value_ptr_mut(x: &mut TMat) -> &mut [N] - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.as_mut_slice() } - diff --git a/nalgebra-glm/src/gtx/component_wise.rs b/nalgebra-glm/src/gtx/component_wise.rs index 56d4cff4..bcc14a8c 100644 --- a/nalgebra-glm/src/gtx/component_wise.rs +++ b/nalgebra-glm/src/gtx/component_wise.rs @@ -1,7 +1,7 @@ use na::{self, DefaultAllocator}; -use traits::{Number, Alloc, Dimension}; use aliases::TMat; +use traits::{Alloc, Dimension, Number}; /// The sum of every component of the given matrix or vector. /// @@ -22,7 +22,9 @@ use aliases::TMat; /// * [`comp_min`](fn.comp_min.html) /// * [`comp_mul`](fn.comp_mul.html) pub fn comp_add(m: &TMat) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ m.iter().fold(N::zero(), |x, y| x + *y) } @@ -49,7 +51,9 @@ pub fn comp_add(m: &TMat) -> N /// * [`max3`](fn.max3.html) /// * [`max4`](fn.max4.html) pub fn comp_max(m: &TMat) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ m.iter().fold(N::min_value(), |x, y| na::sup(&x, y)) } @@ -76,7 +80,9 @@ pub fn comp_max(m: &TMat) -> N /// * [`min3`](fn.min3.html) /// * [`min4`](fn.min4.html) pub fn comp_min(m: &TMat) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ m.iter().fold(N::max_value(), |x, y| na::inf(&x, y)) } @@ -99,7 +105,9 @@ pub fn comp_min(m: &TMat) -> N /// * [`comp_max`](fn.comp_max.html) /// * [`comp_min`](fn.comp_min.html) pub fn comp_mul(m: &TMat) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ m.iter().fold(N::one(), |x, y| x * *y) } diff --git a/nalgebra-glm/src/gtx/exterior_product.rs b/nalgebra-glm/src/gtx/exterior_product.rs index 228be61e..cc58597b 100644 --- a/nalgebra-glm/src/gtx/exterior_product.rs +++ b/nalgebra-glm/src/gtx/exterior_product.rs @@ -1,7 +1,7 @@ -use traits::Number; use aliases::TVec2; +use traits::Number; /// The 2D perpendicular product between two vectors. pub fn cross2d(v: &TVec2, u: &TVec2) -> N { v.perp(u) -} \ No newline at end of file +} diff --git a/nalgebra-glm/src/gtx/handed_coordinate_space.rs b/nalgebra-glm/src/gtx/handed_coordinate_space.rs index e499207f..ee1979ad 100644 --- a/nalgebra-glm/src/gtx/handed_coordinate_space.rs +++ b/nalgebra-glm/src/gtx/handed_coordinate_space.rs @@ -1,5 +1,5 @@ -use traits::Number; use aliases::TVec3; +use traits::Number; /// Returns `true` if `{a, b, c}` forms a left-handed trihedron. /// diff --git a/nalgebra-glm/src/gtx/matrix_operation.rs b/nalgebra-glm/src/gtx/matrix_operation.rs index 17ea4bb9..954607ef 100644 --- a/nalgebra-glm/src/gtx/matrix_operation.rs +++ b/nalgebra-glm/src/gtx/matrix_operation.rs @@ -1,5 +1,7 @@ +use aliases::{ + TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3, TVec2, TVec3, TVec4, +}; use traits::Number; -use aliases::{TVec2, TVec3, TVec4, TMat2, TMat2x3, TMat2x4, TMat3, TMat3x2, TMat3x4, TMat4, TMat4x2, TMat4x3}; /// Builds a 2x2 diagonal matrix. /// diff --git a/nalgebra-glm/src/gtx/mod.rs b/nalgebra-glm/src/gtx/mod.rs index 7dc66bda..b06f3998 100644 --- a/nalgebra-glm/src/gtx/mod.rs +++ b/nalgebra-glm/src/gtx/mod.rs @@ -1,25 +1,37 @@ //! (Reexported) Experimental features not specified by GLSL specification. - pub use self::component_wise::{comp_add, comp_max, comp_min, comp_mul}; //pub use self::euler_angles::*; -pub use self::exterior_product::{cross2d}; +pub use self::exterior_product::cross2d; pub use self::handed_coordinate_space::{left_handed, right_handed}; pub use self::matrix_cross_product::{matrix_cross, matrix_cross3}; -pub use self::matrix_operation::{diagonal2x2, diagonal2x3, diagonal2x4, diagonal3x2, diagonal3x3, diagonal3x4, diagonal4x2, diagonal4x3, diagonal4x4}; +pub use self::matrix_operation::{ + diagonal2x2, diagonal2x3, diagonal2x4, diagonal3x2, diagonal3x3, diagonal3x4, diagonal4x2, + diagonal4x3, diagonal4x4, +}; pub use self::norm::{distance2, l1_distance, l1_norm, l2_distance, l2_norm, length2, magnitude2}; -pub use self::normal::{triangle_normal}; +pub use self::normal::triangle_normal; pub use self::normalize_dot::{fast_normalize_dot, normalize_dot}; +pub use self::quaternion::{ + mat3_to_quat, quat_cross_vec, quat_extract_real_component, quat_fast_mix, quat_identity, + quat_inv_cross_vec, quat_length2, quat_magnitude2, quat_rotate_vec, quat_rotate_vec3, + quat_rotation, quat_short_mix, quat_to_mat3, quat_to_mat4, to_quat, +}; pub use self::rotate_normalized_axis::{quat_rotate_normalized_axis, rotate_normalized_axis}; -pub use self::rotate_vector::{orientation, rotate_vec2, rotate_vec3, rotate_vec4, rotate_x_vec4, rotate_x_vec3, rotate_y_vec4, rotate_y_vec3, rotate_z_vec4, rotate_z_vec3, slerp}; -pub use self::transform::{rotation, scaling, translation, rotation2d, scaling2d, translation2d}; -pub use self::transform2::{proj, proj2d, reflect, reflect2d, scale_bias, scale_bias_matrix, shear2d_x, shear_x, shear_y, shear2d_y, shear_z}; +pub use self::rotate_vector::{ + orientation, rotate_vec2, rotate_vec3, rotate_vec4, rotate_x_vec3, rotate_x_vec4, + rotate_y_vec3, rotate_y_vec4, rotate_z_vec3, rotate_z_vec4, slerp, +}; +pub use self::transform::{rotation, rotation2d, scaling, scaling2d, translation, translation2d}; +pub use self::transform2::{ + proj, proj2d, reflect, reflect2d, scale_bias, scale_bias_matrix, shear2d_x, shear2d_y, shear_x, + shear_y, shear_z, +}; pub use self::transform2d::{rotate2d, scale2d, translate2d}; -pub use self::vector_angle::{angle}; -pub use self::vector_query::{are_collinear, are_collinear2d, are_orthogonal, is_comp_null, is_normalized, is_null}; -pub use self::quaternion::{quat_to_mat3, quat_rotate_vec, quat_cross_vec, mat3_to_quat, quat_extract_real_component, quat_fast_mix, quat_inv_cross_vec, quat_length2, quat_magnitude2, quat_identity, quat_rotate_vec3, quat_rotation, quat_short_mix, quat_to_mat4, to_quat}; - - +pub use self::vector_angle::angle; +pub use self::vector_query::{ + are_collinear, are_collinear2d, are_orthogonal, is_comp_null, is_normalized, is_null, +}; mod component_wise; //mod euler_angles; @@ -30,6 +42,7 @@ mod matrix_operation; mod norm; mod normal; mod normalize_dot; +mod quaternion; mod rotate_normalized_axis; mod rotate_vector; mod transform; @@ -37,4 +50,3 @@ mod transform2; mod transform2d; mod vector_angle; mod vector_query; -mod quaternion; \ No newline at end of file diff --git a/nalgebra-glm/src/gtx/norm.rs b/nalgebra-glm/src/gtx/norm.rs index 2a40c02a..aef2a818 100644 --- a/nalgebra-glm/src/gtx/norm.rs +++ b/nalgebra-glm/src/gtx/norm.rs @@ -1,7 +1,7 @@ -use na::{Real, DefaultAllocator}; +use na::{DefaultAllocator, Real}; -use traits::{Alloc, Dimension}; use aliases::TVec; +use traits::{Alloc, Dimension}; /// The squared distance between two points. /// @@ -9,7 +9,9 @@ use aliases::TVec; /// /// * [`distance`](fn.distance.html) pub fn distance2(p0: &TVec, p1: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ (p1 - p0).norm_squared() } @@ -21,7 +23,9 @@ pub fn distance2(p0: &TVec, p1: &TVec) -> N /// * [`l2_distance`](fn.l2_distance.html) /// * [`l2_norm`](fn.l2_norm.html) pub fn l1_distance(x: &TVec, y: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ l1_norm(&(y - x)) } @@ -36,7 +40,9 @@ pub fn l1_distance(x: &TVec, y: &TVec) -> N /// * [`l2_distance`](fn.l2_distance.html) /// * [`l2_norm`](fn.l2_norm.html) pub fn l1_norm(v: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ ::comp_add(&v.abs()) } @@ -55,7 +61,9 @@ pub fn l1_norm(v: &TVec) -> N /// * [`magnitude`](fn.magnitude.html) /// * [`magnitude2`](fn.magnitude2.html) pub fn l2_distance(x: &TVec, y: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ l2_norm(&(y - x)) } @@ -76,7 +84,9 @@ pub fn l2_distance(x: &TVec, y: &TVec) -> N /// * [`magnitude`](fn.magnitude.html) /// * [`magnitude2`](fn.magnitude2.html) pub fn l2_norm(x: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.norm() } @@ -92,7 +102,9 @@ pub fn l2_norm(x: &TVec) -> N /// * [`magnitude`](fn.magnitude.html) /// * [`magnitude2`](fn.magnitude2.html) pub fn length2(x: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.norm_squared() } @@ -108,7 +120,9 @@ pub fn length2(x: &TVec) -> N /// * [`magnitude`](fn.magnitude.html) /// * [`nalgebra::norm_squared`](../nalgebra/fn.norm_squared.html) pub fn magnitude2(x: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.norm_squared() } diff --git a/nalgebra-glm/src/gtx/normal.rs b/nalgebra-glm/src/gtx/normal.rs index 6ae70ab7..63fc9246 100644 --- a/nalgebra-glm/src/gtx/normal.rs +++ b/nalgebra-glm/src/gtx/normal.rs @@ -7,4 +7,4 @@ use aliases::TVec3; /// The normal is computed as the normalized vector `cross(p2 - p1, p3 - p1)`. pub fn triangle_normal(p1: &TVec3, p2: &TVec3, p3: &TVec3) -> TVec3 { (p2 - p1).cross(&(p3 - p1)).normalize() -} \ No newline at end of file +} diff --git a/nalgebra-glm/src/gtx/normalize_dot.rs b/nalgebra-glm/src/gtx/normalize_dot.rs index 4c67aee3..34fc5665 100644 --- a/nalgebra-glm/src/gtx/normalize_dot.rs +++ b/nalgebra-glm/src/gtx/normalize_dot.rs @@ -1,7 +1,7 @@ -use na::{Real, DefaultAllocator}; +use na::{DefaultAllocator, Real}; -use traits::{Dimension, Alloc}; use aliases::TVec; +use traits::{Alloc, Dimension}; /// The dot product of the normalized version of `x` and `y`. /// @@ -11,7 +11,9 @@ use aliases::TVec; /// /// * [`normalize_dot`](fn.normalize_dot.html`) pub fn fast_normalize_dot(x: &TVec, y: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ // XXX: improve those. x.normalize().dot(&y.normalize()) } @@ -22,7 +24,9 @@ pub fn fast_normalize_dot(x: &TVec, y: &TVec) /// /// * [`fast_normalize_dot`](fn.fast_normalize_dot.html`) pub fn normalize_dot(x: &TVec, y: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ // XXX: improve those. x.normalize().dot(&y.normalize()) } diff --git a/nalgebra-glm/src/gtx/quaternion.rs b/nalgebra-glm/src/gtx/quaternion.rs index a490352d..5762b58d 100644 --- a/nalgebra-glm/src/gtx/quaternion.rs +++ b/nalgebra-glm/src/gtx/quaternion.rs @@ -1,4 +1,4 @@ -use na::{Real, Unit, Rotation3, UnitQuaternion, U3}; +use na::{Real, Rotation3, Unit, UnitQuaternion, U3}; use aliases::{Qua, TMat3, TMat4, TVec3, TVec4}; @@ -19,7 +19,9 @@ pub fn quat_extract_real_component(q: &Qua) -> N { /// Normalized linear interpolation between two quaternions. pub fn quat_fast_mix(x: &Qua, y: &Qua, a: N) -> Qua { - Unit::new_unchecked(*x).nlerp(&Unit::new_unchecked(*y), a).unwrap() + Unit::new_unchecked(*x) + .nlerp(&Unit::new_unchecked(*y), a) + .unwrap() } //pub fn quat_intermediate(prev: &Qua, curr: &Qua, next: &Qua) -> Qua { @@ -54,12 +56,16 @@ pub fn quat_rotate_vec(q: &Qua, v: &TVec4) -> TVec4 { /// The rotation required to align `orig` to `dest`. pub fn quat_rotation(orig: &TVec3, dest: &TVec3) -> Qua { - UnitQuaternion::rotation_between(orig, dest).unwrap_or_else(UnitQuaternion::identity).unwrap() + UnitQuaternion::rotation_between(orig, dest) + .unwrap_or_else(UnitQuaternion::identity) + .unwrap() } /// The spherical linear interpolation between two quaternions. pub fn quat_short_mix(x: &Qua, y: &Qua, a: N) -> Qua { - Unit::new_normalize(*x).slerp(&Unit::new_normalize(*y), a).unwrap() + Unit::new_normalize(*x) + .slerp(&Unit::new_normalize(*y), a) + .unwrap() } //pub fn quat_squad(q1: &Qua, q2: &Qua, s1: &Qua, s2: &Qua, h: N) -> Qua { @@ -68,7 +74,9 @@ pub fn quat_short_mix(x: &Qua, y: &Qua, a: N) -> Qua { /// Converts a quaternion to a rotation matrix. pub fn quat_to_mat3(x: &Qua) -> TMat3 { - UnitQuaternion::new_unchecked(*x).to_rotation_matrix().unwrap() + UnitQuaternion::new_unchecked(*x) + .to_rotation_matrix() + .unwrap() } /// Converts a quaternion to a rotation matrix in homogenous coordinates. @@ -87,4 +95,3 @@ pub fn to_quat(x: &TMat4) -> Qua { let rot = x.fixed_slice::(0, 0).into_owned(); mat3_to_quat(&rot) } - diff --git a/nalgebra-glm/src/gtx/rotate_vector.rs b/nalgebra-glm/src/gtx/rotate_vector.rs index 76dcdbfa..0855244d 100644 --- a/nalgebra-glm/src/gtx/rotate_vector.rs +++ b/nalgebra-glm/src/gtx/rotate_vector.rs @@ -1,6 +1,6 @@ use na::{Real, Rotation3, Unit, UnitComplex}; -use aliases::{TVec2, TVec3, TVec4, TMat4}; +use aliases::{TMat4, TVec2, TVec3, TVec4}; /// Build the rotation matrix needed to align `normal` and `up`. pub fn orientation(normal: &TVec3, up: &TVec3) -> TMat4 { @@ -58,5 +58,7 @@ pub fn rotate_z_vec4(v: &TVec4, angle: N) -> TVec4 { /// Computes a spherical linear interpolation between the vectors `x` and `y` assumed to be normalized. pub fn slerp(x: &TVec3, y: &TVec3, a: N) -> TVec3 { - Unit::new_unchecked(*x).slerp(&Unit::new_unchecked(*y), a).unwrap() + Unit::new_unchecked(*x) + .slerp(&Unit::new_unchecked(*y), a) + .unwrap() } diff --git a/nalgebra-glm/src/gtx/transform.rs b/nalgebra-glm/src/gtx/transform.rs index 3ebc958d..85554fe5 100644 --- a/nalgebra-glm/src/gtx/transform.rs +++ b/nalgebra-glm/src/gtx/transform.rs @@ -1,7 +1,7 @@ -use na::{Real, Unit, Rotation2, Rotation3}; +use na::{Real, Rotation2, Rotation3, Unit}; +use aliases::{TMat3, TMat4, TVec2, TVec3}; use traits::Number; -use aliases::{TVec3, TVec2, TMat3, TMat4}; /// A rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in radians. /// @@ -42,7 +42,6 @@ pub fn translation(v: &TVec3) -> TMat4 { TMat4::new_translation(v) } - /// A rotation 3 * 3 matrix created from an angle expressed in radians. /// /// # See also: diff --git a/nalgebra-glm/src/gtx/transform2.rs b/nalgebra-glm/src/gtx/transform2.rs index 0bb19e95..fa5533f7 100644 --- a/nalgebra-glm/src/gtx/transform2.rs +++ b/nalgebra-glm/src/gtx/transform2.rs @@ -1,7 +1,7 @@ use na::{U2, U3}; +use aliases::{TMat3, TMat4, TVec2, TVec3}; use traits::Number; -use aliases::{TVec2, TVec3, TMat3, TMat4}; /// Build planar projection matrix along normal axis and right-multiply it to `m`. pub fn proj2d(m: &TMat3, normal: &TVec2) -> TMat3 { @@ -57,10 +57,7 @@ pub fn scale_bias_matrix(scale: N, bias: N) -> TMat4 { let _1 = N::one(); TMat4::new( - scale, _0, _0, bias, - _0, scale, _0, bias, - _0, _0, scale, bias, - _0, _0, _0, _1, + scale, _0, _0, bias, _0, scale, _0, bias, _0, _0, scale, bias, _0, _0, _0, _1, ) } @@ -74,11 +71,7 @@ pub fn shear2d_x(m: &TMat3, y: N) -> TMat3 { let _0 = N::zero(); let _1 = N::one(); - let shear = TMat3::new( - _1, y, _0, - _0, _1, _0, - _0, _0, _1 - ); + let shear = TMat3::new(_1, y, _0, _0, _1, _0, _0, _0, _1); m * shear } @@ -86,12 +79,7 @@ pub fn shear2d_x(m: &TMat3, y: N) -> TMat3 { pub fn shear_x(m: &TMat4, y: N, z: N) -> TMat4 { let _0 = N::zero(); let _1 = N::one(); - let shear = TMat4::new( - _1, _0, _0, _0, - y, _1, _0, _0, - z, _0, _1, _0, - _0, _0, _0, _1, - ); + let shear = TMat4::new(_1, _0, _0, _0, y, _1, _0, _0, z, _0, _1, _0, _0, _0, _0, _1); m * shear } @@ -101,11 +89,7 @@ pub fn shear2d_y(m: &TMat3, x: N) -> TMat3 { let _0 = N::zero(); let _1 = N::one(); - let shear = TMat3::new( - _1, _0, _0, - x, _1, _0, - _0, _0, _1 - ); + let shear = TMat3::new(_1, _0, _0, x, _1, _0, _0, _0, _1); m * shear } @@ -113,12 +97,7 @@ pub fn shear2d_y(m: &TMat3, x: N) -> TMat3 { pub fn shear_y(m: &TMat4, x: N, z: N) -> TMat4 { let _0 = N::zero(); let _1 = N::one(); - let shear = TMat4::new( - _1, x, _0, _0, - _0, _1, _0, _0, - _0, z, _1, _0, - _0, _0, _0, _1, - ); + let shear = TMat4::new(_1, x, _0, _0, _0, _1, _0, _0, _0, z, _1, _0, _0, _0, _0, _1); m * shear } @@ -127,12 +106,7 @@ pub fn shear_y(m: &TMat4, x: N, z: N) -> TMat4 { pub fn shear_z(m: &TMat4, x: N, y: N) -> TMat4 { let _0 = N::zero(); let _1 = N::one(); - let shear = TMat4::new( - _1, _0, x, _0, - _0, _1, y, _0, - _0, _0, _1, _0, - _0, _0, _0, _1, - ); + let shear = TMat4::new(_1, _0, x, _0, _0, _1, y, _0, _0, _0, _1, _0, _0, _0, _0, _1); m * shear } diff --git a/nalgebra-glm/src/gtx/transform2d.rs b/nalgebra-glm/src/gtx/transform2d.rs index 92aa7709..3d401f56 100644 --- a/nalgebra-glm/src/gtx/transform2d.rs +++ b/nalgebra-glm/src/gtx/transform2d.rs @@ -1,7 +1,7 @@ use na::{Real, UnitComplex}; -use traits::Number; use aliases::{TMat3, TVec2}; +use traits::Number; /// Builds a 2D rotation matrix from an angle and right-multiply it to `m`. /// diff --git a/nalgebra-glm/src/gtx/vector_angle.rs b/nalgebra-glm/src/gtx/vector_angle.rs index 22deaaf5..048a132d 100644 --- a/nalgebra-glm/src/gtx/vector_angle.rs +++ b/nalgebra-glm/src/gtx/vector_angle.rs @@ -1,12 +1,13 @@ use na::{DefaultAllocator, Real}; -use traits::{Dimension, Alloc}; use aliases::TVec; - +use traits::{Alloc, Dimension}; /// The angle between two vectors. pub fn angle(x: &TVec, y: &TVec) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.angle(y) } diff --git a/nalgebra-glm/src/gtx/vector_query.rs b/nalgebra-glm/src/gtx/vector_query.rs index c4517803..05114a5b 100644 --- a/nalgebra-glm/src/gtx/vector_query.rs +++ b/nalgebra-glm/src/gtx/vector_query.rs @@ -1,7 +1,7 @@ -use na::{Real, DefaultAllocator}; +use na::{DefaultAllocator, Real}; -use traits::{Number, Dimension, Alloc}; use aliases::{TVec, TVec2, TVec3}; +use traits::{Alloc, Dimension, Number}; /// Returns `true` if two vectors are collinear (up to an epsilon). /// @@ -23,7 +23,9 @@ pub fn are_collinear2d(v0: &TVec2, v1: &TVec2, epsilon: N) -> b /// Returns `true` if two vectors are orthogonal (up to an epsilon). pub fn are_orthogonal(v0: &TVec, v1: &TVec, epsilon: N) -> bool - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ abs_diff_eq!(v0.dot(v1), N::zero(), epsilon = epsilon) } @@ -34,18 +36,24 @@ pub fn are_orthogonal(v0: &TVec, v1: &TVec, /// Returns `true` if all the components of `v` are zero (up to an epsilon). pub fn is_comp_null(v: &TVec, epsilon: N) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ v.map(|x| abs_diff_eq!(x, N::zero(), epsilon = epsilon)) } /// Returns `true` if `v` has a magnitude of 1 (up to an epsilon). pub fn is_normalized(v: &TVec, epsilon: N) -> bool - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ abs_diff_eq!(v.norm_squared(), N::one(), epsilon = epsilon * epsilon) } /// Returns `true` if `v` is zero (up to an epsilon). pub fn is_null(v: &TVec, epsilon: N) -> bool - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ abs_diff_eq!(*v, TVec::::zeros(), epsilon = epsilon) } diff --git a/nalgebra-glm/src/lib.rs b/nalgebra-glm/src/lib.rs index dc485846..cb931f6c 100644 --- a/nalgebra-glm/src/lib.rs +++ b/nalgebra-glm/src/lib.rs @@ -1,114 +1,114 @@ /*! # nalgebra-glm − nalgebra in _easy mode_ - **nalgebra-glm** is a GLM-like interface for the **nalgebra** general-purpose linear algebra library. - [GLM](https://glm.g-truc.net) itself is a popular C++ linear algebra library essentially targeting computer graphics. Therefore - **nalgebra-glm** draws inspiration from GLM to define a nice and easy-to-use API for simple graphics application. + **nalgebra-glm** is a GLM-like interface for the **nalgebra** general-purpose linear algebra library. + [GLM](https://glm.g-truc.net) itself is a popular C++ linear algebra library essentially targeting computer graphics. Therefore + **nalgebra-glm** draws inspiration from GLM to define a nice and easy-to-use API for simple graphics application. - All the types of **nalgebra-glm** are aliases of types from **nalgebra**. Therefore there is a complete and - seamless inter-operability between both. + All the types of **nalgebra-glm** are aliases of types from **nalgebra**. Therefore there is a complete and + seamless inter-operability between both. - ## Getting started - First of all, you should start by taking a look at the official [GLM API documentation](http://glm.g-truc.net/0.9.9/api/index.html) - since **nalgebra-glm** implements a large subset of it. To use **nalgebra-glm** to your project, you - should add it as a dependency to your `Crates.toml`: + ## Getting started + First of all, you should start by taking a look at the official [GLM API documentation](http://glm.g-truc.net/0.9.9/api/index.html) + since **nalgebra-glm** implements a large subset of it. To use **nalgebra-glm** to your project, you + should add it as a dependency to your `Crates.toml`: - ```toml - [dependencies] - nalgebra-glm = "0.1" - ``` + ```toml + [dependencies] + nalgebra-glm = "0.1" + ``` - Then, you should add an `extern crate` statement to your `lib.rs` or `main.rs` file. It is **strongly - recommended** to add a crate alias to `glm` as well so that you will be able to call functions of - **nalgebra-glm** using the module prefix `glm::`. For example you will write `glm::rotate(...)` instead - of the more verbose `nalgebra_glm::rotate(...)`: + Then, you should add an `extern crate` statement to your `lib.rs` or `main.rs` file. It is **strongly + recommended** to add a crate alias to `glm` as well so that you will be able to call functions of + **nalgebra-glm** using the module prefix `glm::`. For example you will write `glm::rotate(...)` instead + of the more verbose `nalgebra_glm::rotate(...)`: - ```rust - extern crate nalgebra_glm as glm; - ``` + ```rust + extern crate nalgebra_glm as glm; + ``` - ## Features overview - **nalgebra-glm** supports most linear-algebra related features of the C++ GLM library. Mathematically - speaking, it supports all the common transformations like rotations, translations, scaling, shearing, - and projections but operating in homogeneous coordinates. This means all the 2D transformations are - expressed as 3x3 matrices, and all the 3D transformations as 4x4 matrices. This is less computationally-efficient - and memory-efficient than nalgebra's [transformation types](https://www.nalgebra.org/points_and_transformations/#transformations), - but this has the benefit of being simpler to use. - ### Main differences compared to GLM - While **nalgebra-glm** follows the feature line of the C++ GLM library, quite a few differences - remain and they are mostly syntactic. The main ones are: - * All function names use `snake_case`, which is the Rust convention. - * All type names use `CamelCase`, which is the Rust convention. - * All function arguments, except for scalars, are all passed by-reference. - * The most generic vector and matrix types are [`TMat`](type.TMat.html) and [`TVec`](type.TVec.html) instead of `mat` and `vec`. - * Some feature are not yet implemented and should be added in the future. In particular, no packing - functions are available. - * A few features are not implemented and will never be. This includes functions related to color - spaces, and closest points computations. Other crates should be used for those. For example, closest - points computation can be handled by the [ncollide](https://ncollide.org) project. + ## Features overview + **nalgebra-glm** supports most linear-algebra related features of the C++ GLM library. Mathematically + speaking, it supports all the common transformations like rotations, translations, scaling, shearing, + and projections but operating in homogeneous coordinates. This means all the 2D transformations are + expressed as 3x3 matrices, and all the 3D transformations as 4x4 matrices. This is less computationally-efficient + and memory-efficient than nalgebra's [transformation types](https://www.nalgebra.org/points_and_transformations/#transformations), + but this has the benefit of being simpler to use. + ### Main differences compared to GLM + While **nalgebra-glm** follows the feature line of the C++ GLM library, quite a few differences + remain and they are mostly syntactic. The main ones are: + * All function names use `snake_case`, which is the Rust convention. + * All type names use `CamelCase`, which is the Rust convention. + * All function arguments, except for scalars, are all passed by-reference. + * The most generic vector and matrix types are [`TMat`](type.TMat.html) and [`TVec`](type.TVec.html) instead of `mat` and `vec`. + * Some feature are not yet implemented and should be added in the future. In particular, no packing + functions are available. + * A few features are not implemented and will never be. This includes functions related to color + spaces, and closest points computations. Other crates should be used for those. For example, closest + points computation can be handled by the [ncollide](https://ncollide.org) project. - In addition, because Rust does not allows function overloading, all functions must be given a unique name. - Here are a few rules chosen arbitrarily for **nalgebra-glm**: - * Functions operating in 2d will usually end with the `2d` suffix, e.g., [`glm::rotate2d`](fn.rotate2d.html) is for 2D while [`glm::rotate`](fn.rotate.html) is for 3D. - * Functions operating on vectors will often end with the `_vec` suffix, possibly followed by the dimension of vector, e.g., [`glm::rotate_vec2`](fn.rotate_vec2.html). - * Every function related to quaternions start with the `quat_` prefix, e.g., [`glm::quat_dot(q1, q2)`](fn.quat_dot.html). - * All the conversion functions have unique names as described [below](#conversions). - ### Vector and matrix construction - Vectors, matrices, and quaternions can be constructed using several approaches: - * Using functions with the same name as their type in lower-case. For example [`glm::vec3(x, y, z)`](fn.vec3.html) will create a 3D vector. - * Using the `::new` constructor. For example [`Vec3::new(x, y, z)`](../nalgebra/base/type.MatrixMN.html#method.new-27) will create a 3D vector. - * Using the functions prefixed by `make_` to build a vector a matrix from a slice. For example [`glm::make_vec3(&[x, y, z])`](fn.make_vec3.html) will create a 3D vector. - Keep in mind that constructing a matrix using this type of functions require its components to be arranged in column-major order on the slice. - * Using a geometric construction function. For example [`glm::rotation(angle, axis)`](fn.rotation.html) will build a 4x4 homogeneous rotation matrix from an angle (in radians) and an axis. - * Using swizzling and conversions as described in the next sections. - ### Swizzling - Vector swizzling is a native feature of **nalgebra** itself. Therefore, you can use it with all - the vectors of **nalgebra-glm** as well. Swizzling is supported as methods and works only up to - dimension 3, i.e., you can only refer to the components `x`, `y` and `z` and can only create a - 2D or 3D vector using this technique. Here is some examples, assuming `v` is a vector with float - components here: - * `v.xx()` is equivalent to `glm::vec2(v.x, v.x)` and to `Vec2::new(v.x, v.x)`. - * `v.zx()` is equivalent to `glm::vec2(v.z, v.x)` and to `Vec2::new(v.z, v.x)`. - * `v.yxz()` is equivalent to `glm::vec3(v.y, v.x, v.z)` and to `Vec3::new(v.y, v.x, v.z)`. - * `v.zzy()` is equivalent to `glm::vec3(v.z, v.z, v.y)` and to `Vec3::new(v.z, v.z, v.y)`. + In addition, because Rust does not allows function overloading, all functions must be given a unique name. + Here are a few rules chosen arbitrarily for **nalgebra-glm**: + * Functions operating in 2d will usually end with the `2d` suffix, e.g., [`glm::rotate2d`](fn.rotate2d.html) is for 2D while [`glm::rotate`](fn.rotate.html) is for 3D. + * Functions operating on vectors will often end with the `_vec` suffix, possibly followed by the dimension of vector, e.g., [`glm::rotate_vec2`](fn.rotate_vec2.html). + * Every function related to quaternions start with the `quat_` prefix, e.g., [`glm::quat_dot(q1, q2)`](fn.quat_dot.html). + * All the conversion functions have unique names as described [below](#conversions). + ### Vector and matrix construction + Vectors, matrices, and quaternions can be constructed using several approaches: + * Using functions with the same name as their type in lower-case. For example [`glm::vec3(x, y, z)`](fn.vec3.html) will create a 3D vector. + * Using the `::new` constructor. For example [`Vec3::new(x, y, z)`](../nalgebra/base/type.MatrixMN.html#method.new-27) will create a 3D vector. + * Using the functions prefixed by `make_` to build a vector a matrix from a slice. For example [`glm::make_vec3(&[x, y, z])`](fn.make_vec3.html) will create a 3D vector. + Keep in mind that constructing a matrix using this type of functions require its components to be arranged in column-major order on the slice. + * Using a geometric construction function. For example [`glm::rotation(angle, axis)`](fn.rotation.html) will build a 4x4 homogeneous rotation matrix from an angle (in radians) and an axis. + * Using swizzling and conversions as described in the next sections. + ### Swizzling + Vector swizzling is a native feature of **nalgebra** itself. Therefore, you can use it with all + the vectors of **nalgebra-glm** as well. Swizzling is supported as methods and works only up to + dimension 3, i.e., you can only refer to the components `x`, `y` and `z` and can only create a + 2D or 3D vector using this technique. Here is some examples, assuming `v` is a vector with float + components here: + * `v.xx()` is equivalent to `glm::vec2(v.x, v.x)` and to `Vec2::new(v.x, v.x)`. + * `v.zx()` is equivalent to `glm::vec2(v.z, v.x)` and to `Vec2::new(v.z, v.x)`. + * `v.yxz()` is equivalent to `glm::vec3(v.y, v.x, v.z)` and to `Vec3::new(v.y, v.x, v.z)`. + * `v.zzy()` is equivalent to `glm::vec3(v.z, v.z, v.y)` and to `Vec3::new(v.z, v.z, v.y)`. - Any combination of two or three components picked among `x`, `y`, and `z` will work. - ### Conversions - It is often useful to convert one algebraic type to another. There are two main approaches for converting - between types in `nalgebra-glm`: - * Using function with the form `type1_to_type2` in order to convert an instance of `type1` into an instance of `type2`. - For example [`glm::mat3_to_mat4(m)`](fn.mat3_to_mat4.html) will convert the 3x3 matrix `m` to a 4x4 matrix by appending one column on the right - and one row on the left. Those now row and columns are filled with 0 except for the diagonal element which is set to 1. - * Using one of the [`convert`](fn.convert.html), [`try_convert`](fn.try_convert.html), or [`convert_unchecked`](fn.convert_unchecked.html) functions. - These functions are directly re-exported from nalgebra and are extremely versatile: - 1. The `convert` function can convert any type (especially geometric types from nalgebra like `Isometry3`) into another algebraic type which is equivalent but more general. For example, - `let sim: Similarity3<_> = na::convert(isometry)` will convert an `Isometry3` into a `Similarity3`. - In addition, `let mat: Mat4 = glm::convert(isometry)` will convert an `Isometry3` to a 4x4 matrix. This will also convert the scalar types, - therefore: `let mat: DMat4 = glm::convert(m)` where `m: Mat4` will work. However, conversion will not work the other way round: you - can't convert a `Matrix4` to an `Isometry3` using `glm::convert` because that could cause unexpected results if the matrix does - not complies to the requirements of the isometry. - 2. If you need this kind of conversions anyway, you can use `try_convert` which will test if the object being converted complies with the algebraic requirements of the target type. - This will return `None` if the requirements are not satisfied. - 3. The `convert_unchecked` will ignore those tests and always perform the conversion, even if that breaks the invariants of the target type. - This must be used with care! This is actually the recommended method to convert between homogeneous transformations generated by `nalgebra-glm` and - specific transformation types from **nalgebra** like `Isometry3`. Just be careful you know your conversions make sense. + Any combination of two or three components picked among `x`, `y`, and `z` will work. + ### Conversions + It is often useful to convert one algebraic type to another. There are two main approaches for converting + between types in `nalgebra-glm`: + * Using function with the form `type1_to_type2` in order to convert an instance of `type1` into an instance of `type2`. + For example [`glm::mat3_to_mat4(m)`](fn.mat3_to_mat4.html) will convert the 3x3 matrix `m` to a 4x4 matrix by appending one column on the right + and one row on the left. Those now row and columns are filled with 0 except for the diagonal element which is set to 1. + * Using one of the [`convert`](fn.convert.html), [`try_convert`](fn.try_convert.html), or [`convert_unchecked`](fn.convert_unchecked.html) functions. + These functions are directly re-exported from nalgebra and are extremely versatile: + 1. The `convert` function can convert any type (especially geometric types from nalgebra like `Isometry3`) into another algebraic type which is equivalent but more general. For example, + `let sim: Similarity3<_> = na::convert(isometry)` will convert an `Isometry3` into a `Similarity3`. + In addition, `let mat: Mat4 = glm::convert(isometry)` will convert an `Isometry3` to a 4x4 matrix. This will also convert the scalar types, + therefore: `let mat: DMat4 = glm::convert(m)` where `m: Mat4` will work. However, conversion will not work the other way round: you + can't convert a `Matrix4` to an `Isometry3` using `glm::convert` because that could cause unexpected results if the matrix does + not complies to the requirements of the isometry. + 2. If you need this kind of conversions anyway, you can use `try_convert` which will test if the object being converted complies with the algebraic requirements of the target type. + This will return `None` if the requirements are not satisfied. + 3. The `convert_unchecked` will ignore those tests and always perform the conversion, even if that breaks the invariants of the target type. + This must be used with care! This is actually the recommended method to convert between homogeneous transformations generated by `nalgebra-glm` and + specific transformation types from **nalgebra** like `Isometry3`. Just be careful you know your conversions make sense. - ### Should I use nalgebra or nalgebra-glm? - Well that depends on your tastes and your background. **nalgebra** is more powerful overall since it allows stronger typing, - and goes much further than simple computer graphics math. However, has a bit of a learning curve for - those not used to the abstract mathematical concepts for transformations. **nalgebra-glm** however - have more straightforward functions and benefit from the various tutorials existing on the internet - for the original C++ GLM library. + ### Should I use nalgebra or nalgebra-glm? + Well that depends on your tastes and your background. **nalgebra** is more powerful overall since it allows stronger typing, + and goes much further than simple computer graphics math. However, has a bit of a learning curve for + those not used to the abstract mathematical concepts for transformations. **nalgebra-glm** however + have more straightforward functions and benefit from the various tutorials existing on the internet + for the original C++ GLM library. - Overall, if you are already used to the C++ GLM library, or to working with homogeneous coordinates (like 4D - matrices for 3D transformations), then you will have more success with **nalgebra-glm**. If on the other - hand you prefer more rigorous treatments of transformations, with type-level restrictions, then go for **nalgebra**. - If you need dynamically-sized matrices, you should go for **nalgebra** as well. + Overall, if you are already used to the C++ GLM library, or to working with homogeneous coordinates (like 4D + matrices for 3D transformations), then you will have more success with **nalgebra-glm**. If on the other + hand you prefer more rigorous treatments of transformations, with type-level restrictions, then go for **nalgebra**. + If you need dynamically-sized matrices, you should go for **nalgebra** as well. - Keep in mind that **nalgebra-glm** is just a different API for **nalgebra**. So you can very well use both - and benefit from both their advantages: use **nalgebra-glm** when mathematical rigor is not that important, - and **nalgebra** itself when you need more expressive types, and more powerful linear algebra operations like - matrix factorizations and slicing. Just remember that all the **nalgebra-glm** types are just aliases to **nalgebra** types, - and keep in mind it is possible to convert, e.g., an `Isometry3` to a `Mat4` and vice-versa (see the [conversions section](#conversions)). - */ + Keep in mind that **nalgebra-glm** is just a different API for **nalgebra**. So you can very well use both + and benefit from both their advantages: use **nalgebra-glm** when mathematical rigor is not that important, + and **nalgebra** itself when you need more expressive types, and more powerful linear algebra operations like + matrix factorizations and slicing. Just remember that all the **nalgebra-glm** types are just aliases to **nalgebra** types, + and keep in mind it is possible to convert, e.g., an `Isometry3` to a `Mat4` and vice-versa (see the [conversions section](#conversions)). +*/ #![doc(html_favicon_url = "http://nalgebra.org/img/favicon.ico")] @@ -119,68 +119,83 @@ extern crate alga; extern crate nalgebra as na; pub use aliases::*; +pub use common::{ + abs, ceil, clamp, clamp_scalar, clamp_vec, float_bits_to_int, float_bits_to_int_vec, + float_bits_to_uint, float_bits_to_uint_vec, floor, fract, int_bits_to_float, + int_bits_to_float_vec, lerp, lerp_scalar, lerp_vec, mix, mix_scalar, mix_vec, modf, modf_vec, + round, sign, smoothstep, step, step_scalar, step_vec, trunc, uint_bits_to_float, + uint_bits_to_float_scalar, +}; pub use constructors::*; -pub use common::{abs, ceil, clamp, clamp_scalar, clamp_vec, float_bits_to_int, float_bits_to_int_vec, float_bits_to_uint, float_bits_to_uint_vec, floor, fract, int_bits_to_float, int_bits_to_float_vec, mix, modf, modf_vec, round, sign, smoothstep, step, step_scalar, step_vec, trunc, uint_bits_to_float, uint_bits_to_float_scalar}; -pub use geometric::{reflect_vec, cross, distance, dot, faceforward, length, magnitude, normalize, refract_vec}; -pub use matrix::{transpose, determinant, inverse, matrix_comp_mult, outer_product}; -pub use traits::{Dimension, Number, Alloc}; -pub use trigonometric::{acos, acosh, asin, asinh, atan, atan2, atanh, cos, cosh, degrees, radians, sin, sinh, tan, tanh}; -pub use vector_relational::{all, any, equal, greater_than, greater_than_equal, less_than, less_than_equal, not, not_equal}; pub use exponential::{exp, exp2, inversesqrt, log, log2, pow, sqrt}; +pub use geometric::{ + cross, distance, dot, faceforward, length, magnitude, normalize, reflect_vec, refract_vec, +}; +pub use matrix::{determinant, inverse, matrix_comp_mult, outer_product, transpose}; +pub use traits::{Alloc, Dimension, Number}; +pub use trigonometric::{ + acos, acosh, asin, asinh, atan, atan2, atanh, cos, cosh, degrees, radians, sin, sinh, tan, tanh, +}; +pub use vector_relational::{ + all, any, equal, greater_than, greater_than_equal, less_than, less_than_equal, not, not_equal, +}; -pub use gtx::{ - comp_add, comp_max, comp_min, comp_mul, - cross2d, - left_handed, right_handed, - matrix_cross, matrix_cross3, - diagonal2x2, diagonal2x3, diagonal2x4, diagonal3x2, diagonal3x3, diagonal3x4, diagonal4x2, diagonal4x3, diagonal4x4, - distance2, l1_distance, l1_norm, l2_distance, l2_norm, length2, magnitude2, - triangle_normal, - fast_normalize_dot, normalize_dot, - quat_rotate_normalized_axis, rotate_normalized_axis, - orientation, rotate_vec2, rotate_vec3, rotate_vec4, rotate_x_vec4, rotate_x_vec3, rotate_y_vec4, rotate_y_vec3, rotate_z_vec4, rotate_z_vec3, slerp, - rotation, scaling, translation, rotation2d, scaling2d, translation2d, - proj, proj2d, reflect, reflect2d, scale_bias, scale_bias_matrix, shear2d_x, shear_x, shear_y, shear2d_y, shear_z, - rotate2d, scale2d, translate2d, - angle, - are_collinear, are_collinear2d, are_orthogonal, is_comp_null, is_normalized, is_null, - quat_to_mat3, quat_rotate_vec, quat_cross_vec, mat3_to_quat, quat_extract_real_component, quat_fast_mix, quat_inv_cross_vec, quat_length2, quat_magnitude2, quat_identity, quat_rotate_vec3, quat_rotation, quat_short_mix, quat_to_mat4, to_quat +pub use ext::{ + epsilon, equal_columns, equal_columns_eps, equal_columns_eps_vec, equal_eps, equal_eps_vec, + identity, look_at, look_at_lh, look_at_rh, max, max2, max3, max3_scalar, max4, max4_scalar, + min, min2, min3, min3_scalar, min4, min4_scalar, not_equal_columns, not_equal_columns_eps, + not_equal_columns_eps_vec, not_equal_eps, not_equal_eps_vec, ortho, perspective, pi, + pick_matrix, project, project_no, project_zo, quat_angle, quat_angle_axis, quat_axis, + quat_conjugate, quat_cross, quat_dot, quat_equal, quat_equal_eps, quat_exp, quat_inverse, + quat_length, quat_lerp, quat_log, quat_magnitude, quat_normalize, quat_not_equal, + quat_not_equal_eps, quat_pow, quat_rotate, quat_slerp, rotate, rotate_x, rotate_y, rotate_z, + scale, translate, unproject, unproject_no, unproject_zo, }; pub use gtc::{ - e, two_pi, euler, four_over_pi, golden_ratio, half_pi, ln_ln_two, ln_ten, ln_two, one, one_over_pi, one_over_root_two, one_over_two_pi, quarter_pi, root_five, root_half_pi, root_ln_four, root_pi, root_three, root_two, root_two_pi, third, three_over_two_pi, two_over_pi, two_over_root_pi, two_thirds, zero, - column, row, set_column, set_row, - affine_inverse, inverse_transpose, - make_mat2, make_mat2x2, make_mat2x3, make_mat2x4, make_mat3, make_mat3x2, make_mat3x3, make_mat3x4, make_mat4, make_mat4x2, make_mat4x3, make_mat4x4, make_quat, make_vec1, make_vec2, make_vec3, make_vec4, value_ptr, value_ptr_mut, vec1_to_vec2, vec1_to_vec3, vec1_to_vec4, vec2_to_vec1, vec2_to_vec2, vec2_to_vec3, vec2_to_vec4, vec3_to_vec1, vec3_to_vec2, vec3_to_vec3, vec3_to_vec4, vec4_to_vec1, vec4_to_vec2, vec4_to_vec3, vec4_to_vec4, mat2_to_mat3, mat2_to_mat4, mat3_to_mat2, mat3_to_mat4, mat4_to_mat2, mat4_to_mat3, - quat_cast, quat_euler_angles, quat_greater_than, quat_greater_than_equal, quat_less_than, quat_less_than_equal, quat_look_at, quat_look_at_lh, quat_look_at_rh, quat_pitch, quat_roll, quat_yaw + affine_inverse, column, e, euler, four_over_pi, golden_ratio, half_pi, inverse_transpose, + ln_ln_two, ln_ten, ln_two, make_mat2, make_mat2x2, make_mat2x3, make_mat2x4, make_mat3, + make_mat3x2, make_mat3x3, make_mat3x4, make_mat4, make_mat4x2, make_mat4x3, make_mat4x4, + make_quat, make_vec1, make_vec2, make_vec3, make_vec4, mat2_to_mat3, mat2_to_mat4, + mat3_to_mat2, mat3_to_mat4, mat4_to_mat2, mat4_to_mat3, one, one_over_pi, one_over_root_two, + one_over_two_pi, quarter_pi, quat_cast, quat_euler_angles, quat_greater_than, + quat_greater_than_equal, quat_less_than, quat_less_than_equal, quat_look_at, quat_look_at_lh, + quat_look_at_rh, quat_pitch, quat_roll, quat_yaw, root_five, root_half_pi, root_ln_four, + root_pi, root_three, root_two, root_two_pi, row, set_column, set_row, third, three_over_two_pi, + two_over_pi, two_over_root_pi, two_pi, two_thirds, value_ptr, value_ptr_mut, vec1_to_vec2, + vec1_to_vec3, vec1_to_vec4, vec2_to_vec1, vec2_to_vec2, vec2_to_vec3, vec2_to_vec4, + vec3_to_vec1, vec3_to_vec2, vec3_to_vec3, vec3_to_vec4, vec4_to_vec1, vec4_to_vec2, + vec4_to_vec3, vec4_to_vec4, zero, }; -pub use ext::{ - ortho, perspective, - pick_matrix, project, project_no, project_zo, unproject, unproject_no, unproject_zo, - equal_columns, equal_columns_eps, equal_columns_eps_vec, not_equal_columns, not_equal_columns_eps, not_equal_columns_eps_vec, - identity, look_at, look_at_lh, rotate, scale, look_at_rh, translate, rotate_x, rotate_y, rotate_z, - max3_scalar, max4_scalar, min3_scalar, min4_scalar, - epsilon, pi, - max, max2, max3, max4, min, min2, min3, min4, - equal_eps, equal_eps_vec, not_equal_eps, not_equal_eps_vec, - quat_conjugate, quat_inverse, quat_lerp, quat_slerp, - quat_cross, quat_dot, quat_length, quat_magnitude, quat_normalize, - quat_equal, quat_equal_eps, quat_not_equal, quat_not_equal_eps, - quat_exp, quat_log, quat_pow, quat_rotate, - quat_angle, quat_angle_axis, quat_axis +pub use gtx::{ + angle, are_collinear, are_collinear2d, are_orthogonal, comp_add, comp_max, comp_min, comp_mul, + cross2d, diagonal2x2, diagonal2x3, diagonal2x4, diagonal3x2, diagonal3x3, diagonal3x4, + diagonal4x2, diagonal4x3, diagonal4x4, distance2, fast_normalize_dot, is_comp_null, + is_normalized, is_null, l1_distance, l1_norm, l2_distance, l2_norm, left_handed, length2, + magnitude2, mat3_to_quat, matrix_cross, matrix_cross3, normalize_dot, orientation, proj, + proj2d, quat_cross_vec, quat_extract_real_component, quat_fast_mix, quat_identity, + quat_inv_cross_vec, quat_length2, quat_magnitude2, quat_rotate_normalized_axis, + quat_rotate_vec, quat_rotate_vec3, quat_rotation, quat_short_mix, quat_to_mat3, quat_to_mat4, + reflect, reflect2d, right_handed, rotate2d, rotate_normalized_axis, rotate_vec2, rotate_vec3, + rotate_vec4, rotate_x_vec3, rotate_x_vec4, rotate_y_vec3, rotate_y_vec4, rotate_z_vec3, + rotate_z_vec4, rotation, rotation2d, scale2d, scale_bias, scale_bias_matrix, scaling, + scaling2d, shear2d_x, shear2d_y, shear_x, shear_y, shear_z, slerp, to_quat, translate2d, + translation, translation2d, triangle_normal, }; -pub use na::{convert, convert_ref, convert_unchecked, convert_ref_unchecked, try_convert, try_convert_ref}; -pub use na::{Scalar, Real, DefaultAllocator, U1, U2, U3, U4}; +pub use na::{ + convert, convert_ref, convert_ref_unchecked, convert_unchecked, try_convert, try_convert_ref, +}; +pub use na::{DefaultAllocator, Real, Scalar, U1, U2, U3, U4}; mod aliases; -mod constructors; mod common; -mod matrix; +mod constructors; +mod exponential; mod geometric; +mod matrix; mod traits; mod trigonometric; mod vector_relational; -mod exponential; //mod integer; //mod packing; diff --git a/nalgebra-glm/src/matrix.rs b/nalgebra-glm/src/matrix.rs index b61242c9..34ad5826 100644 --- a/nalgebra-glm/src/matrix.rs +++ b/nalgebra-glm/src/matrix.rs @@ -1,34 +1,52 @@ -use na::{Scalar, Real, DefaultAllocator}; +use na::{DefaultAllocator, Real, Scalar}; -use traits::{Alloc, Dimension, Number}; use aliases::{TMat, TVec}; +use traits::{Alloc, Dimension, Number}; /// The determinant of the matrix `m`. pub fn determinant(m: &TMat) -> N - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ m.determinant() } /// The inverse of the matrix `m`. pub fn inverse(m: &TMat) -> TMat - where DefaultAllocator: Alloc { - m.clone().try_inverse().unwrap_or_else(TMat::::zeros) +where + DefaultAllocator: Alloc, +{ + m.clone() + .try_inverse() + .unwrap_or_else(TMat::::zeros) } /// Component-wise multiplication of two matrices. -pub fn matrix_comp_mult(x: &TMat, y: &TMat) -> TMat - where DefaultAllocator: Alloc { +pub fn matrix_comp_mult( + x: &TMat, + y: &TMat, +) -> TMat +where + DefaultAllocator: Alloc, +{ x.component_mul(y) } /// Treats the first parameter `c` as a column vector and the second parameter `r` as a row vector and does a linear algebraic matrix multiply `c * r`. -pub fn outer_product(c: &TVec, r: &TVec) -> TMat - where DefaultAllocator: Alloc { +pub fn outer_product( + c: &TVec, + r: &TVec, +) -> TMat +where + DefaultAllocator: Alloc, +{ c * r.transpose() } /// The transpose of the matrix `m`. pub fn transpose(x: &TMat) -> TMat - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.transpose() } diff --git a/nalgebra-glm/src/traits.rs b/nalgebra-glm/src/traits.rs index 02e62e97..f4d47dfd 100644 --- a/nalgebra-glm/src/traits.rs +++ b/nalgebra-glm/src/traits.rs @@ -1,48 +1,80 @@ -use num::{Signed, FromPrimitive, Bounded}; use approx::AbsDiffEq; +use num::{Bounded, FromPrimitive, Signed}; -use alga::general::{Ring, Lattice}; -use na::{Scalar, DimName, DimMin, U1}; +use alga::general::{Lattice, Ring}; use na::allocator::Allocator; +use na::{DimMin, DimName, Scalar, U1}; /// A type-level number representing a vector, matrix row, or matrix column, dimension. pub trait Dimension: DimName + DimMin {} impl> Dimension for D {} - /// A number that can either be an integer or a float. -pub trait Number: Scalar + Ring + Lattice + AbsDiffEq + Signed + FromPrimitive + Bounded { +pub trait Number: + Scalar + Ring + Lattice + AbsDiffEq + Signed + FromPrimitive + Bounded +{ } -impl + Signed + FromPrimitive + Bounded> Number for T { -} +impl + Signed + FromPrimitive + Bounded> + Number for T +{} #[doc(hidden)] pub trait Alloc: -Allocator + Allocator + Allocator + Allocator + Allocator + Allocator + Allocator + Allocator + -Allocator + Allocator + -Allocator + Allocator + -Allocator + Allocator + -Allocator + Allocator + -Allocator + Allocator + -Allocator + Allocator + -Allocator + Allocator + -Allocator + Allocator + -Allocator<(usize, usize), R> + Allocator<(usize, usize), C> + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator<(usize, usize), R> + + Allocator<(usize, usize), C> { } -impl - Alloc for T -where T: Allocator + Allocator + Allocator + Allocator + Allocator + Allocator + Allocator + Allocator + - Allocator + Allocator + - Allocator + Allocator + - Allocator + Allocator + - Allocator + Allocator + - Allocator + Allocator + - Allocator + Allocator + - Allocator + Allocator + - Allocator + Allocator + - Allocator<(usize, usize), R> + Allocator<(usize, usize), C> -{ -} \ No newline at end of file +impl Alloc for T where + T: Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator + + Allocator<(usize, usize), R> + + Allocator<(usize, usize), C> +{} diff --git a/nalgebra-glm/src/trigonometric.rs b/nalgebra-glm/src/trigonometric.rs index e9f69ae5..ae376bcd 100644 --- a/nalgebra-glm/src/trigonometric.rs +++ b/nalgebra-glm/src/trigonometric.rs @@ -1,95 +1,124 @@ -use na::{self, Real, DefaultAllocator}; +use na::{self, DefaultAllocator, Real}; use aliases::TVec; use traits::{Alloc, Dimension}; - /// Component-wise arc-cosinus. pub fn acos(x: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.map(|e| e.acos()) } /// Component-wise hyperbolic arc-cosinus. pub fn acosh(x: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.map(|e| e.acosh()) } /// Component-wise arc-sinus. pub fn asin(x: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.map(|e| e.asin()) } /// Component-wise hyperbolic arc-sinus. pub fn asinh(x: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.map(|e| e.asinh()) } /// Component-wise arc-tangent of `y / x`. pub fn atan2(y: &TVec, x: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ y.zip_map(x, |y, x| y.atan2(x)) } /// Component-wise arc-tangent. pub fn atan(y_over_x: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ y_over_x.map(|e| e.atan()) } /// Component-wise hyperbolic arc-tangent. pub fn atanh(x: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.map(|e| e.atanh()) } /// Component-wise cosinus. pub fn cos(angle: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ angle.map(|e| e.cos()) } /// Component-wise hyperbolic cosinus. pub fn cosh(angle: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ angle.map(|e| e.cosh()) } /// Component-wise conversion from radians to degrees. pub fn degrees(radians: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ radians.map(|e| e * na::convert(180.0) / N::pi()) } /// Component-wise conversion fro degrees to radians. pub fn radians(degrees: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ degrees.map(|e| e * N::pi() / na::convert(180.0)) } /// Component-wise sinus. pub fn sin(angle: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ angle.map(|e| e.sin()) } /// Component-wise hyperbolic sinus. pub fn sinh(angle: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ angle.map(|e| e.sinh()) } /// Component-wise tangent. pub fn tan(angle: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ angle.map(|e| e.tan()) } /// Component-wise hyperbolic tangent. pub fn tanh(angle: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ angle.map(|e| e.tanh()) } diff --git a/nalgebra-glm/src/vector_relational.rs b/nalgebra-glm/src/vector_relational.rs index 24763e06..494b6f9f 100644 --- a/nalgebra-glm/src/vector_relational.rs +++ b/nalgebra-glm/src/vector_relational.rs @@ -1,7 +1,7 @@ -use na::{DefaultAllocator}; +use na::DefaultAllocator; use aliases::TVec; -use traits::{Number, Alloc, Dimension}; +use traits::{Alloc, Dimension, Number}; /// Checks that all the vector components are `true`. /// @@ -21,7 +21,9 @@ use traits::{Number, Alloc, Dimension}; /// * [`any`](fn.any.html) /// * [`not`](fn.not.html) pub fn all(v: &TVec) -> bool - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ v.iter().all(|x| *x) } @@ -46,7 +48,9 @@ pub fn all(v: &TVec) -> bool /// * [`all`](fn.all.html) /// * [`not`](fn.not.html) pub fn any(v: &TVec) -> bool - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ v.iter().any(|x| *x) } @@ -70,7 +74,9 @@ pub fn any(v: &TVec) -> bool /// * [`not`](fn.not.html) /// * [`not_equal`](fn.not_equal.html) pub fn equal(x: &TVec, y: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.zip_map(y, |x, y| x == y) } @@ -94,7 +100,9 @@ pub fn equal(x: &TVec, y: &TVec) -> TVec(x: &TVec, y: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.zip_map(y, |x, y| x > y) } @@ -118,7 +126,9 @@ pub fn greater_than(x: &TVec, y: &TVec) -> /// * [`not`](fn.not.html) /// * [`not_equal`](fn.not_equal.html) pub fn greater_than_equal(x: &TVec, y: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.zip_map(y, |x, y| x >= y) } @@ -142,7 +152,9 @@ pub fn greater_than_equal(x: &TVec, y: &TVec(x: &TVec, y: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.zip_map(y, |x, y| x < y) } @@ -166,7 +178,9 @@ pub fn less_than(x: &TVec, y: &TVec) -> TVe /// * [`not`](fn.not.html) /// * [`not_equal`](fn.not_equal.html) pub fn less_than_equal(x: &TVec, y: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.zip_map(y, |x, y| x <= y) } @@ -191,7 +205,9 @@ pub fn less_than_equal(x: &TVec, y: &TVec) /// * [`less_than_equal`](fn.less_than_equal.html) /// * [`not_equal`](fn.not_equal.html) pub fn not(v: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ v.map(|x| !x) } @@ -215,6 +231,8 @@ pub fn not(v: &TVec) -> TVec /// * [`less_than_equal`](fn.less_than_equal.html) /// * [`not`](fn.not.html) pub fn not_equal(x: &TVec, y: &TVec) -> TVec - where DefaultAllocator: Alloc { +where + DefaultAllocator: Alloc, +{ x.zip_map(y, |x, y| x != y) }