From 0469935161c4425ae56b514796a38424bc340644 Mon Sep 17 00:00:00 2001
From: Tim Neumann <mail@timnn.me>
Date: Sat, 12 Sep 2015 13:07:22 +0200
Subject: [PATCH] fix rfc 1214 fallout

---
 src/matrix.rs     |  8 ++++----
 src/projection.rs |  2 +-
 src/rotation.rs   | 18 +++++++++---------
 src/transform.rs  | 16 ++++++++--------
 4 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/matrix.rs b/src/matrix.rs
index d683b73..d38df2c 100644
--- a/src/matrix.rs
+++ b/src/matrix.rs
@@ -323,10 +323,10 @@ impl<S: Copy + Neg<Output = S>> Matrix4<S> {
     }
 }
 
-pub trait Matrix<S: BaseFloat, V: Clone + Vector<S>>: Array2<V, V, S>
-                                                    + Zero + One
-                                                    + ApproxEq<S>
-                                                    + Sized {
+pub trait Matrix<S: BaseFloat, V: Clone + Vector<S> + 'static>: Array2<V, V, S>
+                                                              + Zero + One
+                                                              + ApproxEq<S>
+                                                              + Sized {
     /// Multiply this matrix by a scalar, returning the new matrix.
     #[must_use]
     fn mul_s(&self, s: S) -> Self;
diff --git a/src/projection.rs b/src/projection.rs
index 507db02..792548f 100644
--- a/src/projection.rs
+++ b/src/projection.rs
@@ -65,7 +65,7 @@ pub fn ortho<S: BaseFloat + 'static>(left: S, right: S, bottom: S, top: S, near:
     }.into()
 }
 
-pub trait Projection<S>: Into<Matrix4<S>> {
+pub trait Projection<S: BaseFloat>: Into<Matrix4<S>> {
     fn to_frustum(&self) -> Frustum<S>;
 }
 
diff --git a/src/rotation.rs b/src/rotation.rs
index 6c5419a..9b7541d 100644
--- a/src/rotation.rs
+++ b/src/rotation.rs
@@ -18,7 +18,7 @@ use approx::ApproxEq;
 use matrix::Matrix;
 use matrix::Matrix2;
 use matrix::Matrix3;
-use num::{BaseNum, BaseFloat};
+use num::BaseFloat;
 use point::{Point, Point2, Point3};
 use quaternion::Quaternion;
 use ray::Ray;
@@ -26,7 +26,7 @@ use vector::{Vector, Vector2, Vector3};
 
 /// A trait for a generic rotation. A rotation is a transformation that
 /// creates a circular motion, and preserves at least one point in the space.
-pub trait Rotation<S: BaseNum, V: Vector<S>, P: Point<S, V>>: PartialEq + ApproxEq<S> + Sized {
+pub trait Rotation<S: BaseFloat, V: Vector<S>, P: Point<S, V>>: PartialEq + ApproxEq<S> + Sized {
     /// Create the identity transform (causes no transformation).
     fn identity() -> Self;
 
@@ -74,19 +74,19 @@ pub trait Rotation<S: BaseNum, V: Vector<S>, P: Point<S, V>>: PartialEq + Approx
 }
 
 /// A two-dimensional rotation.
-pub trait Rotation2<S>: Rotation<S, Vector2<S>, Point2<S>>
-                      + Into<Matrix2<S>>
-                      + Into<Basis2<S>> {
+pub trait Rotation2<S: BaseFloat>: Rotation<S, Vector2<S>, Point2<S>>
+                                 + Into<Matrix2<S>>
+                                 + Into<Basis2<S>> {
     /// Create a rotation by a given angle. Thus is a redundant case of both
     /// from_axis_angle() and from_euler() for 2D space.
     fn from_angle(theta: Rad<S>) -> Self;
 }
 
 /// A three-dimensional rotation.
-pub trait Rotation3<S: BaseNum>: Rotation<S, Vector3<S>, Point3<S>>
-                               + Into<Matrix3<S>>
-                               + Into<Basis3<S>>
-                               + Into<Quaternion<S>> {
+pub trait Rotation3<S: BaseFloat>: Rotation<S, Vector3<S>, Point3<S>>
+                                 + Into<Matrix3<S>>
+                                 + Into<Basis3<S>>
+                                 + Into<Quaternion<S>> {
     /// Create a rotation using an angle around a given axis.
     fn from_axis_angle(axis: &Vector3<S>, angle: Rad<S>) -> Self;
 
diff --git a/src/transform.rs b/src/transform.rs
index 7485fd3..b94a0f6 100644
--- a/src/transform.rs
+++ b/src/transform.rs
@@ -146,8 +146,8 @@ impl<
     }
 }
 
-pub trait Transform2<S>: Transform<S, Vector2<S>, Point2<S>> + Into<Matrix3<S>> {}
-pub trait Transform3<S>: Transform<S, Vector3<S>, Point3<S>> + Into<Matrix4<S>> {}
+pub trait Transform2<S: BaseNum>: Transform<S, Vector2<S>, Point2<S>> + Into<Matrix3<S>> {}
+pub trait Transform3<S: BaseNum>: Transform<S, Vector3<S>, Point3<S>> + Into<Matrix4<S>> {}
 
 impl<
     S: BaseFloat + 'static,
@@ -239,21 +239,21 @@ impl<S: BaseFloat + 'static> Transform3<S> for AffineMatrix3<S> {}
 
 /// A trait that allows extracting components (rotation, translation, scale)
 /// from an arbitrary transformations
-pub trait ToComponents<S: BaseNum, V: Vector<S>, P: Point<S, V>, R: Rotation<S, V, P>> {
+pub trait ToComponents<S: BaseFloat, V: Vector<S>, P: Point<S, V>, R: Rotation<S, V, P>> {
     /// Extract the (scale, rotation, translation) triple
     fn decompose(&self) -> (V, R, V);
 }
 
-pub trait ToComponents2<S, R: Rotation2<S>>:
+pub trait ToComponents2<S: BaseFloat, R: Rotation2<S>>:
     ToComponents<S, Vector2<S>, Point2<S>, R> {}
-pub trait ToComponents3<S, R: Rotation3<S>>:
+pub trait ToComponents3<S: BaseFloat, R: Rotation3<S>>:
     ToComponents<S, Vector3<S>, Point3<S>, R> {}
 
-pub trait CompositeTransform<S, V: Vector<S>, P: Point<S, V>, R: Rotation<S, V, P>>:
+pub trait CompositeTransform<S: BaseFloat, V: Vector<S>, P: Point<S, V>, R: Rotation<S, V, P>>:
     Transform<S, V, P> + ToComponents<S, V, P, R> {}
-pub trait CompositeTransform2<S, R: Rotation2<S>>:
+pub trait CompositeTransform2<S: BaseFloat, R: Rotation2<S>>:
     Transform2<S> + ToComponents2<S, R> {}
-pub trait CompositeTransform3<S, R: Rotation3<S>>:
+pub trait CompositeTransform3<S: BaseFloat, R: Rotation3<S>>:
     Transform3<S> + ToComponents3<S, R> {}
 
 impl<