Fixes for core->std and changes to use
This commit is contained in:
Brendan Zabarauskas
parent
0361be55c5
commit
f800a0ae04
5 changed files with 284 additions and 240 deletions
163
src/mat.rs
163
src/mat.rs
|
|
@ -1,8 +1,7 @@
|
|||
use core::cast::transmute;
|
||||
use core::cmp::ApproxEq;
|
||||
use core::num::Zero::zero;
|
||||
use core::num::One::one;
|
||||
use core::util;
|
||||
use std::cast::transmute;
|
||||
use std::cmp::ApproxEq;
|
||||
use std::num::{Zero, One};
|
||||
use std::util;
|
||||
|
||||
use vec::*;
|
||||
use quat::Quat;
|
||||
|
|
@ -343,8 +342,8 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn from_value(value: T) -> Mat2<T> {
|
||||
BaseMat2::new(value, zero(),
|
||||
zero(), value)
|
||||
BaseMat2::new(value, Zero::zero(),
|
||||
Zero::zero(), value)
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -360,8 +359,8 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn identity() -> Mat2<T> {
|
||||
BaseMat2::new( one::<T>(), zero::<T>(),
|
||||
zero::<T>(), one::<T>())
|
||||
BaseMat2::new( One::one::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), One::one::<T>())
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -377,8 +376,8 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn zero() -> Mat2<T> {
|
||||
BaseMat2::new(zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>())
|
||||
BaseMat2::new(Zero::zero::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -426,7 +425,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
|
|||
#[inline(always)]
|
||||
fn inverse(&self) -> Option<Mat2<T>> {
|
||||
let d = self.determinant();
|
||||
if d.approx_eq(&zero()) {
|
||||
if d.approx_eq(&Zero::zero()) {
|
||||
None
|
||||
} else {
|
||||
Some(BaseMat2::new( self[1][1]/d, -self[0][1]/d,
|
||||
|
|
@ -515,8 +514,8 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn is_diagonal(&self) -> bool {
|
||||
self[0][1].approx_eq(&zero()) &&
|
||||
self[1][0].approx_eq(&zero())
|
||||
self[0][1].approx_eq(&Zero::zero()) &&
|
||||
self[1][0].approx_eq(&Zero::zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -532,7 +531,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn is_invertible(&self) -> bool {
|
||||
!self.determinant().approx_eq(&zero())
|
||||
!self.determinant().approx_eq(&Zero::zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -612,9 +611,9 @@ impl<T:Copy + Float + NumAssign> BaseMat2<T, Vec2<T>> for Mat2<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn to_mat3(&self) -> Mat3<T> {
|
||||
BaseMat3::new(self[0][0], self[0][1], zero(),
|
||||
self[1][0], self[1][1], zero(),
|
||||
zero(), zero(), one())
|
||||
BaseMat3::new( self[0][0], self[0][1], Zero::zero(),
|
||||
self[1][0], self[1][1], Zero::zero(),
|
||||
Zero::zero(), Zero::zero(), One::one())
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -634,10 +633,10 @@ impl<T:Copy + Float + NumAssign> BaseMat2<T, Vec2<T>> for Mat2<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn to_mat4(&self) -> Mat4<T> {
|
||||
BaseMat4::new(self[0][0], self[0][1], zero(), zero(),
|
||||
self[1][0], self[1][1], zero(), zero(),
|
||||
zero(), zero(), one(), zero(),
|
||||
zero(), zero(), zero(), one())
|
||||
BaseMat4::new( self[0][0], self[0][1], Zero::zero(), Zero::zero(),
|
||||
self[1][0], self[1][1], Zero::zero(), Zero::zero(),
|
||||
Zero::zero(), Zero::zero(), One::one(), Zero::zero(),
|
||||
Zero::zero(), Zero::zero(), Zero::zero(), One::one())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -720,9 +719,9 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn from_value(value: T) -> Mat3<T> {
|
||||
BaseMat3::new(value, zero(), zero(),
|
||||
zero(), value, zero(),
|
||||
zero(), zero(), value)
|
||||
BaseMat3::new(value, Zero::zero(), Zero::zero(),
|
||||
Zero::zero(), value, Zero::zero(),
|
||||
Zero::zero(), Zero::zero(), value)
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -740,9 +739,9 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn identity() -> Mat3<T> {
|
||||
BaseMat3::new( one::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), one::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), one::<T>())
|
||||
BaseMat3::new(One::one::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), One::one::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), Zero::zero::<T>(), One::one::<T>())
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -760,9 +759,9 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn zero() -> Mat3<T> {
|
||||
BaseMat3::new(zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), zero::<T>())
|
||||
BaseMat3::new(Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -823,7 +822,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
|
|||
// #[inline(always)]
|
||||
fn inverse(&self) -> Option<Mat3<T>> {
|
||||
let d = self.determinant();
|
||||
if d.approx_eq(&zero()) {
|
||||
if d.approx_eq(&Zero::zero()) {
|
||||
None
|
||||
} else {
|
||||
let m: Mat3<T> = BaseMat3::from_cols(self[1].cross(&self[2]).div_t(d),
|
||||
|
|
@ -925,14 +924,14 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn is_diagonal(&self) -> bool {
|
||||
self[0][1].approx_eq(&zero()) &&
|
||||
self[0][2].approx_eq(&zero()) &&
|
||||
self[0][1].approx_eq(&Zero::zero()) &&
|
||||
self[0][2].approx_eq(&Zero::zero()) &&
|
||||
|
||||
self[1][0].approx_eq(&zero()) &&
|
||||
self[1][2].approx_eq(&zero()) &&
|
||||
self[1][0].approx_eq(&Zero::zero()) &&
|
||||
self[1][2].approx_eq(&Zero::zero()) &&
|
||||
|
||||
self[2][0].approx_eq(&zero()) &&
|
||||
self[2][1].approx_eq(&zero())
|
||||
self[2][0].approx_eq(&Zero::zero()) &&
|
||||
self[2][1].approx_eq(&Zero::zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -954,7 +953,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn is_invertible(&self) -> bool {
|
||||
!self.determinant().approx_eq(&zero())
|
||||
!self.determinant().approx_eq(&Zero::zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -1027,9 +1026,9 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
|
|||
let cos_theta = radians.cos();
|
||||
let sin_theta = radians.sin();
|
||||
|
||||
BaseMat3::new( one(), zero(), zero(),
|
||||
zero(), cos_theta, sin_theta,
|
||||
zero(), -sin_theta, cos_theta)
|
||||
BaseMat3::new( One::one(), Zero::zero(), Zero::zero(),
|
||||
Zero::zero(), cos_theta, sin_theta,
|
||||
Zero::zero(), -sin_theta, cos_theta)
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1041,9 +1040,9 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
|
|||
let cos_theta = radians.cos();
|
||||
let sin_theta = radians.sin();
|
||||
|
||||
BaseMat3::new(cos_theta, zero(), -sin_theta,
|
||||
zero(), one(), zero(),
|
||||
sin_theta, zero(), cos_theta)
|
||||
BaseMat3::new( cos_theta, Zero::zero(), -sin_theta,
|
||||
Zero::zero(), One::one(), Zero::zero(),
|
||||
sin_theta, Zero::zero(), cos_theta)
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1055,9 +1054,9 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
|
|||
let cos_theta = radians.cos();
|
||||
let sin_theta = radians.sin();
|
||||
|
||||
BaseMat3::new( cos_theta, sin_theta, zero(),
|
||||
-sin_theta, cos_theta, zero(),
|
||||
zero(), zero(), one())
|
||||
BaseMat3::new( cos_theta, sin_theta, Zero::zero(),
|
||||
-sin_theta, cos_theta, Zero::zero(),
|
||||
Zero::zero(), Zero::zero(), One::one())
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1091,15 +1090,15 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
|
|||
fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Mat3<T> {
|
||||
let c = radians.cos();
|
||||
let s = radians.sin();
|
||||
let _1_c = one::<T>() - c;
|
||||
let _1_c = One::one::<T>() - c;
|
||||
|
||||
let x = axis.x;
|
||||
let y = axis.y;
|
||||
let z = axis.z;
|
||||
|
||||
BaseMat3::new(_1_c*x*x + c, _1_c*x*y + s*z, _1_c*x*z - s*y,
|
||||
_1_c*x*y - s*z, _1_c*y*y + c, _1_c*y*z + s*x,
|
||||
_1_c*x*z + s*y, _1_c*y*z - s*x, _1_c*z*z + c)
|
||||
_1_c*x*y - s*z, _1_c*y*y + c, _1_c*y*z + s*x,
|
||||
_1_c*x*z + s*y, _1_c*y*z - s*x, _1_c*z*z + c)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -1133,10 +1132,10 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn to_mat4(&self) -> Mat4<T> {
|
||||
BaseMat4::new(self[0][0], self[0][1], self[0][2], zero(),
|
||||
self[1][0], self[1][1], self[1][2], zero(),
|
||||
self[2][0], self[2][1], self[2][2], zero(),
|
||||
zero(), zero(), zero(), one())
|
||||
BaseMat4::new( self[0][0], self[0][1], self[0][2], Zero::zero(),
|
||||
self[1][0], self[1][1], self[1][2], Zero::zero(),
|
||||
self[2][0], self[2][1], self[2][2], Zero::zero(),
|
||||
Zero::zero(), Zero::zero(), Zero::zero(), One::one())
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1154,7 +1153,7 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
|
|||
let _1: T = num::cast(1.0);
|
||||
let half: T = num::cast(0.5);
|
||||
|
||||
if trace >= zero() {
|
||||
if trace >= Zero::zero() {
|
||||
s = (_1 + trace).sqrt();
|
||||
w = half * s;
|
||||
s = half / s;
|
||||
|
|
@ -1272,10 +1271,10 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn from_value(value: T) -> Mat4<T> {
|
||||
BaseMat4::new(value, zero(), zero(), zero(),
|
||||
zero(), value, zero(), zero(),
|
||||
zero(), zero(), value, zero(),
|
||||
zero(), zero(), zero(), value)
|
||||
BaseMat4::new(value, Zero::zero(), Zero::zero(), Zero::zero(),
|
||||
Zero::zero(), value, Zero::zero(), Zero::zero(),
|
||||
Zero::zero(), Zero::zero(), value, Zero::zero(),
|
||||
Zero::zero(), Zero::zero(), Zero::zero(), value)
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1295,10 +1294,10 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn identity() -> Mat4<T> {
|
||||
BaseMat4::new( one::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), one::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), one::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), zero::<T>(), one::<T>())
|
||||
BaseMat4::new(One::one::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), One::one::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), Zero::zero::<T>(), One::one::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), One::one::<T>())
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1318,10 +1317,10 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn zero() -> Mat4<T> {
|
||||
BaseMat4::new(zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
|
||||
zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>())
|
||||
BaseMat4::new(Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
|
||||
Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -1410,7 +1409,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
|
|||
|
||||
fn inverse(&self) -> Option<Mat4<T>> {
|
||||
let d = self.determinant();
|
||||
if d.approx_eq(&zero()) {
|
||||
if d.approx_eq(&Zero::zero()) {
|
||||
None
|
||||
} else {
|
||||
|
||||
|
|
@ -1556,21 +1555,21 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn is_diagonal(&self) -> bool {
|
||||
self[0][1].approx_eq(&zero()) &&
|
||||
self[0][2].approx_eq(&zero()) &&
|
||||
self[0][3].approx_eq(&zero()) &&
|
||||
self[0][1].approx_eq(&Zero::zero()) &&
|
||||
self[0][2].approx_eq(&Zero::zero()) &&
|
||||
self[0][3].approx_eq(&Zero::zero()) &&
|
||||
|
||||
self[1][0].approx_eq(&zero()) &&
|
||||
self[1][2].approx_eq(&zero()) &&
|
||||
self[1][3].approx_eq(&zero()) &&
|
||||
self[1][0].approx_eq(&Zero::zero()) &&
|
||||
self[1][2].approx_eq(&Zero::zero()) &&
|
||||
self[1][3].approx_eq(&Zero::zero()) &&
|
||||
|
||||
self[2][0].approx_eq(&zero()) &&
|
||||
self[2][1].approx_eq(&zero()) &&
|
||||
self[2][3].approx_eq(&zero()) &&
|
||||
self[2][0].approx_eq(&Zero::zero()) &&
|
||||
self[2][1].approx_eq(&Zero::zero()) &&
|
||||
self[2][3].approx_eq(&Zero::zero()) &&
|
||||
|
||||
self[3][0].approx_eq(&zero()) &&
|
||||
self[3][1].approx_eq(&zero()) &&
|
||||
self[3][2].approx_eq(&zero())
|
||||
self[3][0].approx_eq(&Zero::zero()) &&
|
||||
self[3][1].approx_eq(&Zero::zero()) &&
|
||||
self[3][2].approx_eq(&Zero::zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -1599,7 +1598,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn is_invertible(&self) -> bool {
|
||||
!self.determinant().approx_eq(&zero())
|
||||
!self.determinant().approx_eq(&Zero::zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
|
|||
48
src/quat.rs
48
src/quat.rs
|
|
@ -7,9 +7,9 @@
|
|||
* Sir William Hamilton
|
||||
*/
|
||||
|
||||
use core::cmp::ApproxEq;
|
||||
use core::num::Zero::zero;
|
||||
use core::num::One::one;
|
||||
use std::cast::transmute;
|
||||
use std::cmp::ApproxEq;
|
||||
use std::num::{Zero, One};
|
||||
|
||||
use mat::{Mat3, BaseMat3};
|
||||
use vec::{Vec3, BaseVec3, AffineVec, NumVec, NumVec3};
|
||||
|
|
@ -68,7 +68,10 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn identity() -> Quat<T> {
|
||||
Quat::new(one(), zero(), zero(), zero())
|
||||
Quat::new(One::one(),
|
||||
Zero::zero(),
|
||||
Zero::zero(),
|
||||
Zero::zero())
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -78,25 +81,37 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn zero() -> Quat<T> {
|
||||
Quat::new(zero(), zero(), zero(), zero())
|
||||
Quat::new(Zero::zero(),
|
||||
Zero::zero(),
|
||||
Zero::zero(),
|
||||
Zero::zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn from_angle_x(radians: T) -> Quat<T> {
|
||||
let _2 = num::cast(2);
|
||||
Quat::new((radians / _2).cos(), radians.sin(), zero(), zero())
|
||||
Quat::new((radians / _2).cos(),
|
||||
radians.sin(),
|
||||
Zero::zero(),
|
||||
Zero::zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn from_angle_y(radians: T) -> Quat<T> {
|
||||
let _2 = num::cast(2);
|
||||
Quat::new((radians / _2).cos(), zero(), radians.sin(), zero())
|
||||
Quat::new((radians / _2).cos(),
|
||||
Zero::zero(),
|
||||
radians.sin(),
|
||||
Zero::zero())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn from_angle_z(radians: T) -> Quat<T> {
|
||||
let _2 = num::cast(2);
|
||||
Quat::new((radians / _2).cos(), zero(), zero(), radians.sin())
|
||||
Quat::new((radians / _2).cos(),
|
||||
Zero::zero(),
|
||||
Zero::zero(),
|
||||
radians.sin())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -273,7 +288,7 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn normalize(&self) -> Quat<T> {
|
||||
self.mul_t(one::<T>()/self.magnitude())
|
||||
self.mul_t(One::one::<T>()/self.magnitude())
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -285,7 +300,7 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
|
|||
*/
|
||||
#[inline(always)]
|
||||
fn nlerp(&self, other: &Quat<T>, amount: T) -> Quat<T> {
|
||||
self.mul_t(one::<T>() - amount).add_q(&other.mul_t(amount)).normalize()
|
||||
self.mul_t(One::one::<T>() - amount).add_q(&other.mul_t(amount)).normalize()
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -316,12 +331,13 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
|
|||
let dot_threshold = num::cast(0.9995);
|
||||
|
||||
if dot > dot_threshold {
|
||||
return self.nlerp(other, amount); // if quaternions are close together use `nlerp`
|
||||
return self.nlerp(other, amount); // if quaternions are close together use `nlerp`
|
||||
} else {
|
||||
let robust_dot = dot.clamp(&-one::<T>(), &one()); // stay within the domain of acos()
|
||||
let robust_dot = dot.clamp(&-One::one::<T>(),
|
||||
&One::one()); // stay within the domain of acos()
|
||||
|
||||
let theta_0 = robust_dot.acos(); // the angle between the quaternions
|
||||
let theta = theta_0 * amount; // the fraction of theta specified by `amount`
|
||||
let theta_0 = robust_dot.acos(); // the angle between the quaternions
|
||||
let theta = theta_0 * amount; // the fraction of theta specified by `amount`
|
||||
|
||||
let q = other.sub_q(&self.mul_t(robust_dot))
|
||||
.normalize();
|
||||
|
|
@ -362,7 +378,7 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
|
|||
let sz2 = z2 * self.s;
|
||||
let sx2 = x2 * self.s;
|
||||
|
||||
let _1: T = one();
|
||||
let _1: T = One::one();
|
||||
|
||||
BaseMat3::new(_1 - yy2 - zz2, xy2 + sz2, xz2 - sy2,
|
||||
xy2 - sz2, _1 - xx2 - zz2, yz2 + sx2,
|
||||
|
|
@ -373,7 +389,7 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
|
|||
impl<T:Copy> Index<uint, T> for Quat<T> {
|
||||
#[inline(always)]
|
||||
fn index(&self, i: &uint) -> T {
|
||||
unsafe { do vec::raw::buf_as_slice(cast::transmute(self), 4) |slice| { slice[*i] } }
|
||||
unsafe { transmute::<Quat<T>,[T,..4]>(*self)[*i] }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,4 @@
|
|||
use std::cmp::FuzzyEq;
|
||||
use numeric::*;
|
||||
|
||||
use mat::*;
|
||||
use quat::*;
|
||||
|
|
@ -32,13 +31,13 @@ fn test_quat() {
|
|||
fn test_quat_2() {
|
||||
let v = vec3::new(1f32, 0f32, 0f32);
|
||||
|
||||
let q = quat::from_angle_axis(radians(-45f32), &vec3::new(0f32, 0f32, -1f32));
|
||||
let q = quat::from_angle_axis((-45f32).radians(), &vec3::new(0f32, 0f32, -1f32));
|
||||
|
||||
// http://www.wolframalpha.com/input/?i={1,0}+rotate+-45+degrees
|
||||
assert!(q.mul_v(&v).fuzzy_eq(&vec3::new(1f32/sqrt(2f32), 1f32/sqrt(2f32), 0f32)));
|
||||
assert!(q.mul_v(&v).fuzzy_eq(&vec3::new(1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32)));
|
||||
assert!(q.mul_v(&v).length() == v.length());
|
||||
assert!(q.to_mat3().fuzzy_eq(&mat3::new( 1f32/sqrt(2f32), 1f32/sqrt(2f32), 0f32,
|
||||
-1f32/sqrt(2f32), 1f32/sqrt(2f32), 0f32,
|
||||
assert!(q.to_mat3().fuzzy_eq(&mat3::new( 1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32,
|
||||
-1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32,
|
||||
0f32, 0f32, 1f32)));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
use std::cmp::FuzzyEq;
|
||||
use numeric::float::Float::frac_pi_2;
|
||||
use numeric::float::Float::frac_pi_3;
|
||||
use std::num::Real::{frac_pi_2, frac_pi_3};
|
||||
|
||||
use vec::*;
|
||||
|
||||
|
|
@ -9,79 +8,79 @@ use vec::*;
|
|||
#[test]
|
||||
fn test_vec2() {
|
||||
// assert!(vec2::dim == 2);
|
||||
|
||||
|
||||
let a = Vec2 { x: 1.0, y: 2.0 };
|
||||
let b = Vec2 { x: 3.0, y: 4.0 };
|
||||
let f1 = 1.5;
|
||||
let f2 = 0.5;
|
||||
|
||||
|
||||
let mut mut_a = a;
|
||||
|
||||
|
||||
assert!(vec2::new(1.0, 2.0) == a);
|
||||
assert!(vec2::from_value(1.0) == vec2::new(1.0, 1.0));
|
||||
|
||||
|
||||
assert!(vec2::zero() == vec2::new(0.0, 0.0));
|
||||
assert!(vec2::unit_x() == vec2::new(1.0, 0.0));
|
||||
assert!(vec2::unit_y() == vec2::new(0.0, 1.0));
|
||||
assert!(vec2::identity() == vec2::new(1.0, 1.0));
|
||||
|
||||
|
||||
*mut_a.index_mut(0) = 42.0;
|
||||
*mut_a.index_mut(1) = 43.0;
|
||||
assert!(mut_a == vec2::new(42.0, 43.0));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.swap(0, 1);
|
||||
assert!(mut_a[0] == a[1]);
|
||||
assert!(mut_a[1] == a[0]);
|
||||
mut_a = a;
|
||||
|
||||
|
||||
assert!(a.x == 1.0);
|
||||
assert!(a.y == 2.0);
|
||||
assert!(a[0] == 1.0);
|
||||
assert!(a[1] == 2.0);
|
||||
|
||||
|
||||
assert!(-a == vec2::new(-1.0, -2.0));
|
||||
assert!(a.neg() == vec2::new(-1.0, -2.0));
|
||||
|
||||
|
||||
assert!(vec2::new(0.0, 0.0).is_zero());
|
||||
assert!(!vec2::new(1.0, 1.0).is_zero());
|
||||
|
||||
|
||||
assert!(a.mul_t(f1) == vec2::new( 1.5, 3.0));
|
||||
assert!(a.div_t(f2) == vec2::new( 2.0, 4.0));
|
||||
|
||||
|
||||
assert!(a.add_v(&b) == vec2::new( 4.0, 6.0));
|
||||
assert!(a.sub_v(&b) == vec2::new( -2.0, -2.0));
|
||||
assert!(a.mul_v(&b) == vec2::new( 3.0, 8.0));
|
||||
assert!(a.div_v(&b) == vec2::new(1.0/3.0, 2.0/4.0));
|
||||
|
||||
|
||||
mut_a.neg_self();
|
||||
assert!(mut_a == -a);
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.mul_self_t(f1);
|
||||
assert!(mut_a == a.mul_t(f1));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.div_self_t(f2);
|
||||
assert!(mut_a == a.div_t(f2));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.add_self_v(&b);
|
||||
assert!(mut_a == a.add_v(&b));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.sub_self_v(&b);
|
||||
assert!(mut_a == a.sub_v(&b));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.mul_self_v(&b);
|
||||
assert!(mut_a == a.mul_v(&b));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.div_self_v(&b);
|
||||
assert!(mut_a == a.div_v(&b));
|
||||
// mut_a = a;
|
||||
|
||||
|
||||
// assert!(c.abs() == vec2::new( 2.0, 1.0));
|
||||
// assert!(c.min(&d) == vec2::new(-2.0, -1.0));
|
||||
// assert!(c.max(&d) == vec2::new( 1.0, 0.0));
|
||||
|
|
@ -98,28 +97,28 @@ fn test_vec2_euclidean() {
|
|||
let a = vec2::new(5.0, 12.0); // (5, 12, 13) Pythagorean triple
|
||||
let b0 = vec2::new(3.0, 4.0); // (3, 4, 5) Pythagorean triple
|
||||
let b = a.add_v(&b0);
|
||||
|
||||
|
||||
assert!(a.length() == 13.0);
|
||||
assert!(a.length2() == 13.0 * 13.0);
|
||||
|
||||
|
||||
assert!(b0.length() == 5.0);
|
||||
assert!(b0.length2() == 5.0 * 5.0);
|
||||
|
||||
|
||||
assert!(a.distance(&b) == 5.0);
|
||||
assert!(a.distance2(&b) == 5.0 * 5.0);
|
||||
|
||||
|
||||
assert!(vec2::new(1.0, 0.0).angle(&vec2::new(0.0, 1.0)).fuzzy_eq(&frac_pi_2()));
|
||||
assert!(vec2::new(10.0, 0.0).angle(&vec2::new(0.0, 5.0)).fuzzy_eq(&frac_pi_2()));
|
||||
assert!(vec2::new(-1.0, 0.0).angle(&vec2::new(0.0, 1.0)).fuzzy_eq(&-frac_pi_2::<f32>()));
|
||||
|
||||
|
||||
assert!(vec2::new(3.0, 4.0).normalize().fuzzy_eq(&vec2::new(3.0/5.0, 4.0/5.0)));
|
||||
// TODO: test normalize_to, normalize_self, and normalize_self_to
|
||||
|
||||
|
||||
let c = vec2::new(-2.0, -1.0);
|
||||
let d = vec2::new( 1.0, 0.0);
|
||||
|
||||
|
||||
assert!(c.lerp(&d, 0.75) == vec2::new(0.250, -0.250));
|
||||
|
||||
|
||||
let mut mut_c = c;
|
||||
mut_c.lerp_self(&d, 0.75);
|
||||
assert!(mut_c == c.lerp(&d, 0.75));
|
||||
|
|
@ -130,15 +129,15 @@ fn test_vec2_boolean() {
|
|||
let tf = bvec2::new(true, false);
|
||||
let ff = bvec2::new(false, false);
|
||||
let tt = bvec2::new(true, true);
|
||||
|
||||
|
||||
assert!(tf.any() == true);
|
||||
assert!(tf.all() == false);
|
||||
assert!(tf.not() == bvec2::new(false, true));
|
||||
|
||||
|
||||
assert!(ff.any() == false);
|
||||
assert!(ff.all() == false);
|
||||
assert!(ff.not() == bvec2::new(true, true));
|
||||
|
||||
|
||||
assert!(tt.any() == true);
|
||||
assert!(tt.all() == true);
|
||||
assert!(tt.not() == bvec2::new(false, false));
|
||||
|
|
@ -147,98 +146,98 @@ fn test_vec2_boolean() {
|
|||
#[test]
|
||||
fn test_vec3() {
|
||||
// assert!(Vec3::dim == 3);
|
||||
|
||||
|
||||
let a = Vec3 { x: 1.0, y: 2.0, z: 3.0 };
|
||||
let b = Vec3 { x: 4.0, y: 5.0, z: 6.0 };
|
||||
let f1 = 1.5;
|
||||
let f2 = 0.5;
|
||||
|
||||
|
||||
let mut mut_a = a;
|
||||
|
||||
|
||||
assert!(vec3::new(1.0, 2.0, 3.0) == a);
|
||||
assert!(vec3::from_value(1.0) == vec3::new(1.0, 1.0, 1.0));
|
||||
|
||||
|
||||
assert!(vec3::zero() == vec3::new(0.0, 0.0, 0.0));
|
||||
assert!(vec3::unit_x() == vec3::new(1.0, 0.0, 0.0));
|
||||
assert!(vec3::unit_y() == vec3::new(0.0, 1.0, 0.0));
|
||||
assert!(vec3::unit_z() == vec3::new(0.0, 0.0, 1.0));
|
||||
assert!(vec3::identity() == vec3::new(1.0, 1.0, 1.0));
|
||||
|
||||
|
||||
*mut_a.index_mut(0) = 42.0;
|
||||
*mut_a.index_mut(1) = 43.0;
|
||||
*mut_a.index_mut(2) = 44.0;
|
||||
assert!(mut_a == vec3::new(42.0, 43.0, 44.0));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.swap(0, 2);
|
||||
assert!(mut_a[0] == a[2]);
|
||||
assert!(mut_a[2] == a[0]);
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.swap(1, 2);
|
||||
assert!(mut_a[1] == a[2]);
|
||||
assert!(mut_a[2] == a[1]);
|
||||
mut_a = a;
|
||||
|
||||
|
||||
assert!(a.x == 1.0);
|
||||
assert!(a.y == 2.0);
|
||||
assert!(a.z == 3.0);
|
||||
assert!(a[0] == 1.0);
|
||||
assert!(a[1] == 2.0);
|
||||
assert!(a[2] == 3.0);
|
||||
|
||||
|
||||
assert!(a.cross(&b) == vec3::new(-3.0, 6.0, -3.0));
|
||||
|
||||
|
||||
mut_a.cross_self(&b);
|
||||
assert!(mut_a == a.cross(&b));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
assert!(-a == vec3::new(-1.0, -2.0, -3.0));
|
||||
assert!(a.neg() == vec3::new(-1.0, -2.0, -3.0));
|
||||
|
||||
|
||||
assert!(vec3::new(0.0, 0.0, 0.0).is_zero());
|
||||
assert!(!vec3::new(1.0, 1.0, 1.0).is_zero());
|
||||
|
||||
|
||||
assert!(a.mul_t(f1) == vec3::new( 1.5, 3.0, 4.5));
|
||||
assert!(a.div_t(f2) == vec3::new( 2.0, 4.0, 6.0));
|
||||
|
||||
|
||||
assert!(a.add_v(&b) == vec3::new( 5.0, 7.0, 9.0));
|
||||
assert!(a.sub_v(&b) == vec3::new( -3.0, -3.0, -3.0));
|
||||
assert!(a.mul_v(&b) == vec3::new( 4.0, 10.0, 18.0));
|
||||
assert!(a.div_v(&b) == vec3::new(1.0/4.0, 2.0/5.0, 3.0/6.0));
|
||||
|
||||
|
||||
mut_a.neg_self();
|
||||
assert!(mut_a == -a);
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.mul_self_t(f1);
|
||||
assert!(mut_a == a.mul_t(f1));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.div_self_t(f2);
|
||||
assert!(mut_a == a.div_t(f2));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.add_self_v(&b);
|
||||
assert!(mut_a == a.add_v(&b));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.sub_self_v(&b);
|
||||
assert!(mut_a == a.sub_v(&b));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.mul_self_v(&b);
|
||||
assert!(mut_a == a.mul_v(&b));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.div_self_v(&b);
|
||||
assert!(mut_a == a.div_v(&b));
|
||||
// mut_a = a;
|
||||
|
||||
|
||||
// exact_eq
|
||||
// fuzzy_eq
|
||||
// eq
|
||||
|
||||
|
||||
// assert!(c.abs() == vec3::new( 2.0, 1.0, 1.0));
|
||||
// assert!(c.min(&d) == vec3::new(-2.0, -1.0, 0.5));
|
||||
// assert!(c.max(&d) == vec3::new( 1.0, 0.0, 1.0));
|
||||
|
|
@ -255,28 +254,28 @@ fn test_vec3_euclidean() {
|
|||
let a = vec3::new(2.0, 3.0, 6.0); // (2, 3, 6, 7) Pythagorean quadruple
|
||||
let b0 = vec3::new(1.0, 4.0, 8.0); // (1, 4, 8, 9) Pythagorean quadruple
|
||||
let b = a.add_v(&b0);
|
||||
|
||||
|
||||
assert!(a.length() == 7.0);
|
||||
assert!(a.length2() == 7.0 * 7.0);
|
||||
|
||||
|
||||
assert!(b0.length() == 9.0);
|
||||
assert!(b0.length2() == 9.0 * 9.0);
|
||||
|
||||
|
||||
assert!(a.distance(&b) == 9.0);
|
||||
assert!(a.distance2(&b) == 9.0 * 9.0);
|
||||
|
||||
|
||||
assert!(vec3::new(1.0, 0.0, 1.0).angle(&vec3::new(1.0, 1.0, 0.0)).fuzzy_eq(&frac_pi_3()));
|
||||
assert!(vec3::new(10.0, 0.0, 10.0).angle(&vec3::new(5.0, 5.0, 0.0)).fuzzy_eq(&frac_pi_3()));
|
||||
assert!(vec3::new(-1.0, 0.0, -1.0).angle(&vec3::new(1.0, -1.0, 0.0)).fuzzy_eq(&(2.0 * frac_pi_3())));
|
||||
|
||||
|
||||
assert!(vec3::new(2.0, 3.0, 6.0).normalize().fuzzy_eq(&vec3::new(2.0/7.0, 3.0/7.0, 6.0/7.0)));
|
||||
// TODO: test normalize_to, normalize_self, and normalize_self_to
|
||||
|
||||
|
||||
let c = vec3::new(-2.0, -1.0, 1.0);
|
||||
let d = vec3::new( 1.0, 0.0, 0.5);
|
||||
|
||||
|
||||
assert!(c.lerp(&d, 0.75) == vec3::new(0.250, -0.250, 0.625));
|
||||
|
||||
|
||||
let mut mut_c = c;
|
||||
mut_c.lerp_self(&d, 0.75);
|
||||
assert!(mut_c == c.lerp(&d, 0.75));
|
||||
|
|
@ -287,15 +286,15 @@ fn test_vec3_boolean() {
|
|||
let tft = bvec3::new(true, false, true);
|
||||
let fff = bvec3::new(false, false, false);
|
||||
let ttt = bvec3::new(true, true, true);
|
||||
|
||||
|
||||
assert!(tft.any() == true);
|
||||
assert!(tft.all() == false);
|
||||
assert!(tft.not() == bvec3::new(false, true, false));
|
||||
|
||||
|
||||
assert!(fff.any() == false);
|
||||
assert!(fff.all() == false);
|
||||
assert!(fff.not() == bvec3::new(true, true, true));
|
||||
|
||||
|
||||
assert!(ttt.any() == true);
|
||||
assert!(ttt.all() == true);
|
||||
assert!(ttt.not() == bvec3::new(false, false, false));
|
||||
|
|
@ -304,41 +303,41 @@ fn test_vec3_boolean() {
|
|||
#[test]
|
||||
fn test_vec4() {
|
||||
// assert!(Vec4::dim == 4);
|
||||
|
||||
|
||||
let a = Vec4 { x: 1.0, y: 2.0, z: 3.0, w: 4.0 };
|
||||
let b = Vec4 { x: 5.0, y: 6.0, z: 7.0, w: 8.0 };
|
||||
let f1 = 1.5;
|
||||
let f2 = 0.5;
|
||||
|
||||
|
||||
let mut mut_a = a;
|
||||
|
||||
|
||||
assert!(vec4::new(1.0, 2.0, 3.0, 4.0) == a);
|
||||
assert!(vec4::from_value(1.0) == vec4::new(1.0, 1.0, 1.0, 1.0));
|
||||
|
||||
|
||||
*mut_a.index_mut(0) = 42.0;
|
||||
*mut_a.index_mut(1) = 43.0;
|
||||
*mut_a.index_mut(2) = 44.0;
|
||||
*mut_a.index_mut(3) = 45.0;
|
||||
assert!(mut_a == vec4::new(42.0, 43.0, 44.0, 45.0));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.swap(0, 3);
|
||||
assert!(mut_a[0] == a[3]);
|
||||
assert!(mut_a[3] == a[0]);
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.swap(1, 2);
|
||||
assert!(mut_a[1] == a[2]);
|
||||
assert!(mut_a[2] == a[1]);
|
||||
mut_a = a;
|
||||
|
||||
|
||||
assert!(vec4::zero() == vec4::new(0.0, 0.0, 0.0, 0.0));
|
||||
assert!(vec4::unit_x() == vec4::new(1.0, 0.0, 0.0, 0.0));
|
||||
assert!(vec4::unit_y() == vec4::new(0.0, 1.0, 0.0, 0.0));
|
||||
assert!(vec4::unit_z() == vec4::new(0.0, 0.0, 1.0, 0.0));
|
||||
assert!(vec4::unit_w() == vec4::new(0.0, 0.0, 0.0, 1.0));
|
||||
assert!(vec4::identity() == vec4::new(1.0, 1.0, 1.0, 1.0));
|
||||
|
||||
|
||||
assert!(a.x == 1.0);
|
||||
assert!(a.y == 2.0);
|
||||
assert!(a.z == 3.0);
|
||||
|
|
@ -347,51 +346,51 @@ fn test_vec4() {
|
|||
assert!(a[1] == 2.0);
|
||||
assert!(a[2] == 3.0);
|
||||
assert!(a[3] == 4.0);
|
||||
|
||||
|
||||
assert!(-a == vec4::new(-1.0, -2.0, -3.0, -4.0));
|
||||
assert!(a.neg() == vec4::new(-1.0, -2.0, -3.0, -4.0));
|
||||
|
||||
|
||||
assert!(vec4::new(0.0, 0.0, 0.0, 0.0).is_zero());
|
||||
assert!(!vec4::new(1.0, 1.0, 1.0, 1.0).is_zero());
|
||||
|
||||
|
||||
assert!(a.mul_t(f1) == vec4::new( 1.5, 3.0, 4.5, 6.0));
|
||||
assert!(a.div_t(f2) == vec4::new( 2.0, 4.0, 6.0, 8.0));
|
||||
|
||||
|
||||
assert!(a.add_v(&b) == vec4::new( 6.0, 8.0, 10.0, 12.0));
|
||||
assert!(a.sub_v(&b) == vec4::new( -4.0, -4.0, -4.0, -4.0));
|
||||
assert!(a.mul_v(&b) == vec4::new( 5.0, 12.0, 21.0, 32.0));
|
||||
assert!(a.div_v(&b) == vec4::new(1.0/5.0, 2.0/6.0, 3.0/7.0, 4.0/8.0));
|
||||
|
||||
|
||||
assert!(a.dot(&b) == 70.0);
|
||||
|
||||
|
||||
mut_a.neg_self();
|
||||
assert!(mut_a == -a);
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.mul_self_t(f1);
|
||||
assert!(mut_a == a.mul_t(f1));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.div_self_t(f2);
|
||||
assert!(mut_a == a.div_t(f2));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.add_self_v(&b);
|
||||
assert!(mut_a == a.add_v(&b));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.sub_self_v(&b);
|
||||
assert!(mut_a == a.sub_v(&b));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.mul_self_v(&b);
|
||||
assert!(mut_a == a.mul_v(&b));
|
||||
mut_a = a;
|
||||
|
||||
|
||||
mut_a.div_self_v(&b);
|
||||
assert!(mut_a == a.div_v(&b));
|
||||
// mut_a = a;
|
||||
|
||||
|
||||
// assert!(c.abs() == vec4::new( 2.0, 1.0, 1.0, 2.0));
|
||||
// assert!(c.min(&d) == vec4::new(-2.0, -1.0, 0.5, 1.0));
|
||||
// assert!(c.max(&d) == vec4::new( 1.0, 0.0, 1.0, 2.0));
|
||||
|
|
@ -408,28 +407,28 @@ fn test_vec4_euclidean() {
|
|||
let a = vec4::new(1.0, 2.0, 4.0, 10.0); // (1, 2, 4, 10, 11) Pythagorean quintuple
|
||||
let b0 = vec4::new(1.0, 2.0, 8.0, 10.0); // (1, 2, 8, 10, 13) Pythagorean quintuple
|
||||
let b = a.add_v(&b0);
|
||||
|
||||
|
||||
assert!(a.length() == 11.0);
|
||||
assert!(a.length2() == 11.0 * 11.0);
|
||||
|
||||
|
||||
assert!(b0.length() == 13.0);
|
||||
assert!(b0.length2() == 13.0 * 13.0);
|
||||
|
||||
|
||||
assert!(a.distance(&b) == 13.0);
|
||||
assert!(a.distance2(&b) == 13.0 * 13.0);
|
||||
|
||||
|
||||
assert!(vec4::new(1.0, 0.0, 1.0, 0.0).angle(&vec4::new(0.0, 1.0, 0.0, 1.0)).fuzzy_eq(&frac_pi_2()));
|
||||
assert!(vec4::new(10.0, 0.0, 10.0, 0.0).angle(&vec4::new(0.0, 5.0, 0.0, 5.0)).fuzzy_eq(&frac_pi_2()));
|
||||
assert!(vec4::new(-1.0, 0.0, -1.0, 0.0).angle(&vec4::new(0.0, 1.0, 0.0, 1.0)).fuzzy_eq(&frac_pi_2()));
|
||||
|
||||
|
||||
assert!(vec4::new(1.0, 2.0, 4.0, 10.0).normalize().fuzzy_eq(&vec4::new(1.0/11.0, 2.0/11.0, 4.0/11.0, 10.0/11.0)));
|
||||
// TODO: test normalize_to, normalize_self, and normalize_self_to
|
||||
|
||||
let c = vec4::new(-2.0, -1.0, 1.0, 2.0);
|
||||
let d = vec4::new( 1.0, 0.0, 0.5, 1.0);
|
||||
|
||||
|
||||
assert!(c.lerp(&d, 0.75) == vec4::new(0.250, -0.250, 0.625, 1.250));
|
||||
|
||||
|
||||
let mut mut_c = c;
|
||||
mut_c.lerp_self(&d, 0.75);
|
||||
assert!(mut_c == c.lerp(&d, 0.75));
|
||||
|
|
@ -440,15 +439,15 @@ fn test_vec4_boolean() {
|
|||
let tftf = bvec4::new(true, false, true, false);
|
||||
let ffff = bvec4::new(false, false, false, false);
|
||||
let tttt = bvec4::new(true, true, true, true);
|
||||
|
||||
|
||||
assert!(tftf.any() == true);
|
||||
assert!(tftf.all() == false);
|
||||
assert!(tftf.not() == bvec4::new(false, true, false, true));
|
||||
|
||||
|
||||
assert!(ffff.any() == false);
|
||||
assert!(ffff.all() == false);
|
||||
assert!(ffff.not() == bvec4::new(true, true, true, true));
|
||||
|
||||
|
||||
assert!(tttt.any() == true);
|
||||
assert!(tttt.all() == true);
|
||||
assert!(tttt.not() == bvec4::new(false, false, false, false));
|
||||
|
|
|
|||
111
src/vec.rs
111
src/vec.rs
|
|
@ -1,8 +1,7 @@
|
|||
use core::cast::transmute;
|
||||
use core::cmp::ApproxEq;
|
||||
use core::num::Zero::zero;
|
||||
use core::num::One::one;
|
||||
use core::util;
|
||||
use std::cast::transmute;
|
||||
use std::cmp::ApproxEq;
|
||||
use std::num::{Zero, One};
|
||||
use std::util;
|
||||
|
||||
use num::NumAssign;
|
||||
|
||||
|
|
@ -538,7 +537,7 @@ impl<T:Copy + Eq> BaseVec<T> for Vec2<T> {
|
|||
#[inline(always)]
|
||||
fn index_mut<'a>(&'a mut self, i: uint) -> &'a mut T {
|
||||
unsafe {
|
||||
&'a mut transmute::<
|
||||
&mut transmute::<
|
||||
&'a mut Vec2<T>,
|
||||
&'a mut [T,..2]
|
||||
>(self)[i]
|
||||
|
|
@ -568,18 +567,20 @@ impl<T:Copy + Eq> Index<uint, T> for Vec2<T> {
|
|||
impl<T:Copy + Num + NumAssign> NumVec<T> for Vec2<T> {
|
||||
#[inline(always)]
|
||||
fn identity() -> Vec2<T> {
|
||||
BaseVec2::new(one::<T>(), one::<T>())
|
||||
BaseVec2::new(One::one::<T>(),
|
||||
One::one::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn zero() -> Vec2<T> {
|
||||
BaseVec2::new(zero::<T>(), zero::<T>())
|
||||
BaseVec2::new(Zero::zero::<T>(),
|
||||
Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn is_zero(&self) -> bool {
|
||||
self[0] == zero() &&
|
||||
self[1] == zero()
|
||||
self[0] == Zero::zero() &&
|
||||
self[1] == Zero::zero()
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -665,12 +666,14 @@ impl<T:Copy + Num> Neg<Vec2<T>> for Vec2<T> {
|
|||
impl<T:Copy + Num> NumVec2<T> for Vec2<T> {
|
||||
#[inline(always)]
|
||||
fn unit_x() -> Vec2<T> {
|
||||
BaseVec2::new(one::<T>(), zero::<T>())
|
||||
BaseVec2::new(One::one::<T>(),
|
||||
Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn unit_y() -> Vec2<T> {
|
||||
BaseVec2::new(zero::<T>(), one::<T>())
|
||||
BaseVec2::new(Zero::zero::<T>(),
|
||||
One::one::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -682,7 +685,7 @@ impl<T:Copy + Num> NumVec2<T> for Vec2<T> {
|
|||
impl<T:Copy + Num> ToHomogeneous<Vec3<T>> for Vec2<T> {
|
||||
#[inline(always)]
|
||||
fn to_homogeneous(&self) -> Vec3<T> {
|
||||
BaseVec3::new(self.x, self.y, zero())
|
||||
BaseVec3::new(self.x, self.y, Zero::zero())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -714,7 +717,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec2<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn normalize(&self) -> Vec2<T> {
|
||||
self.mul_t(one::<T>()/self.length())
|
||||
self.mul_t(One::one::<T>()/self.length())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -729,7 +732,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec2<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn normalize_self(&mut self) {
|
||||
let n = one::<T>() / self.length();
|
||||
let n = One::one::<T>() / self.length();
|
||||
self.mul_self_t(n);
|
||||
}
|
||||
|
||||
|
|
@ -845,7 +848,7 @@ impl<T:Copy + Eq> BaseVec<T> for Vec3<T> {
|
|||
#[inline(always)]
|
||||
fn index_mut<'a>(&'a mut self, i: uint) -> &'a mut T {
|
||||
unsafe {
|
||||
&'a mut transmute::<
|
||||
&mut transmute::<
|
||||
&'a mut Vec3<T>,
|
||||
&'a mut [T,..3]
|
||||
>(self)[i]
|
||||
|
|
@ -875,19 +878,23 @@ impl<T:Copy + Eq> Index<uint, T> for Vec3<T> {
|
|||
impl<T:Copy + Num + NumAssign> NumVec<T> for Vec3<T> {
|
||||
#[inline(always)]
|
||||
fn identity() -> Vec3<T> {
|
||||
BaseVec3::new(one::<T>(), one::<T>(), one::<T>())
|
||||
BaseVec3::new(One::one::<T>(),
|
||||
One::one::<T>(),
|
||||
One::one::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn zero() -> Vec3<T> {
|
||||
BaseVec3::new(zero::<T>(), zero::<T>(), zero::<T>())
|
||||
BaseVec3::new(Zero::zero::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn is_zero(&self) -> bool {
|
||||
self[0] == zero() &&
|
||||
self[1] == zero() &&
|
||||
self[2] == zero()
|
||||
self[0] == Zero::zero() &&
|
||||
self[1] == Zero::zero() &&
|
||||
self[2] == Zero::zero()
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -975,17 +982,23 @@ impl<T:Copy + Num> Neg<Vec3<T>> for Vec3<T> {
|
|||
impl<T:Copy + Num> NumVec3<T> for Vec3<T> {
|
||||
#[inline(always)]
|
||||
fn unit_x() -> Vec3<T> {
|
||||
BaseVec3::new(one::<T>(), zero::<T>(), zero::<T>())
|
||||
BaseVec3::new(One::one::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn unit_y() -> Vec3<T> {
|
||||
BaseVec3::new(zero::<T>(), one::<T>(), zero::<T>())
|
||||
BaseVec3::new(Zero::zero::<T>(),
|
||||
One::one::<T>(),
|
||||
Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn unit_z() -> Vec3<T> {
|
||||
BaseVec3::new(zero::<T>(), zero::<T>(), one::<T>())
|
||||
BaseVec3::new(Zero::zero::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
One::one::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -1004,7 +1017,7 @@ impl<T:Copy + Num> NumVec3<T> for Vec3<T> {
|
|||
impl<T:Copy + Num> ToHomogeneous<Vec4<T>> for Vec3<T> {
|
||||
#[inline(always)]
|
||||
fn to_homogeneous(&self) -> Vec4<T> {
|
||||
BaseVec4::new(self.x, self.y, self.z, zero())
|
||||
BaseVec4::new(self.x, self.y, self.z, Zero::zero())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1036,7 +1049,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec3<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn normalize(&self) -> Vec3<T> {
|
||||
self.mul_t(one::<T>()/self.length())
|
||||
self.mul_t(One::one::<T>()/self.length())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -1051,7 +1064,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec3<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn normalize_self(&mut self) {
|
||||
let n = one::<T>() / self.length();
|
||||
let n = One::one::<T>() / self.length();
|
||||
self.mul_self_t(n);
|
||||
}
|
||||
|
||||
|
|
@ -1169,7 +1182,7 @@ impl<T:Copy + Eq> BaseVec<T> for Vec4<T> {
|
|||
#[inline(always)]
|
||||
fn index_mut<'a>(&'a mut self, i: uint) -> &'a mut T {
|
||||
unsafe {
|
||||
&'a mut transmute::<
|
||||
&mut transmute::<
|
||||
&'a mut Vec4<T>,
|
||||
&'a mut [T,..4]
|
||||
>(self)[i]
|
||||
|
|
@ -1199,20 +1212,26 @@ impl<T:Copy + Eq> Index<uint, T> for Vec4<T> {
|
|||
impl<T:Copy + Num + NumAssign> NumVec<T> for Vec4<T> {
|
||||
#[inline(always)]
|
||||
fn identity() -> Vec4<T> {
|
||||
BaseVec4::new(one::<T>(), one::<T>(), one::<T>(), one::<T>())
|
||||
BaseVec4::new(One::one::<T>(),
|
||||
One::one::<T>(),
|
||||
One::one::<T>(),
|
||||
One::one::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn zero() -> Vec4<T> {
|
||||
BaseVec4::new(zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>())
|
||||
BaseVec4::new(Zero::zero::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn is_zero(&self) -> bool {
|
||||
self[0] == zero() &&
|
||||
self[1] == zero() &&
|
||||
self[2] == zero() &&
|
||||
self[3] == zero()
|
||||
self[0] == Zero::zero() &&
|
||||
self[1] == Zero::zero() &&
|
||||
self[2] == Zero::zero() &&
|
||||
self[3] == Zero::zero()
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -1302,22 +1321,34 @@ impl<T:Copy + Num> Neg<Vec4<T>> for Vec4<T> {
|
|||
impl<T:Copy + Num> NumVec4<T> for Vec4<T> {
|
||||
#[inline(always)]
|
||||
fn unit_x() -> Vec4<T> {
|
||||
BaseVec4::new(one::<T>(), zero::<T>(), zero::<T>(), zero::<T>())
|
||||
BaseVec4::new(One::one::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn unit_y() -> Vec4<T> {
|
||||
BaseVec4::new(zero::<T>(), one::<T>(), zero::<T>(), zero::<T>())
|
||||
BaseVec4::new(Zero::zero::<T>(),
|
||||
One::one::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn unit_z() -> Vec4<T> {
|
||||
BaseVec4::new(zero::<T>(), zero::<T>(), one::<T>(), zero::<T>())
|
||||
BaseVec4::new(Zero::zero::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
One::one::<T>(),
|
||||
Zero::zero::<T>())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn unit_w() -> Vec4<T> {
|
||||
BaseVec4::new(zero::<T>(), zero::<T>(), zero::<T>(), one::<T>())
|
||||
BaseVec4::new(Zero::zero::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
Zero::zero::<T>(),
|
||||
One::one::<T>())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1349,7 +1380,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec4<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn normalize(&self) -> Vec4<T> {
|
||||
self.mul_t(one::<T>()/self.length())
|
||||
self.mul_t(One::one::<T>()/self.length())
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
|
|
@ -1364,7 +1395,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec4<T> {
|
|||
|
||||
#[inline(always)]
|
||||
fn normalize_self(&mut self) {
|
||||
let n = one::<T>() / self.length();
|
||||
let n = One::one::<T>() / self.length();
|
||||
self.mul_self_t(n);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue