hodasemi/cgmath
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Moved constants to submodules

Browse source
This commit is contained in:
Brendan Zabarauskas 2012-10-30 00:11:27 +10:00
parent 5d8319fff0
commit c80b95da59
6 changed files with 104 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

65
src/matrix.rs
View file

@ -2,7 +2,7 @@ use std::cmp::FuzzyEq;
use cmp::Eq;
use math::Sqrt;
use quaternion::Quat;
use vector::*;
use vector::{Vec2, Vec3, Vec4};
//
// NxN Matrix
@ -59,10 +59,10 @@ pub trait Matrix4<V3, V4> {
//
pub struct Mat2 { data:[Vec2 * 2] }
pub const mat2_zero :Mat2 = Mat2 { data: [ vec2_zero,
vec2_zero ] };
pub const mat2_identity :Mat2 = Mat2 { data: [ vec2_unit_x,
vec2_unit_y ] };
pub const mat2_zero :Mat2 = Mat2 { data: [ Vec2::zero,
Vec2::zero ] };
pub const mat2_identity :Mat2 = Mat2 { data: [ Vec2::unit_x,
Vec2::unit_y ] };
//
// Mat2 Constructor
@ -82,6 +82,13 @@ pub pure fn Mat2_v(col0: &Vec2, col1: &Vec2) -> Mat2 {
Mat2 { data: [ *col0, *col1 ] }
}
pub mod Mat2 {
pub const zero :Mat2 = Mat2 { data: [ Vec2::zero,
Vec2::zero ] };
pub const identity :Mat2 = Mat2 { data: [ Vec2::unit_x,
Vec2::unit_y ] };
}
//
// Matrix2x2 Implementation
//
@ -157,7 +164,7 @@ pub impl Mat2: Matrix<float, Vec2> {
#[inline]
pure fn is_identity() -> bool {
self.fuzzy_eq(&mat2_identity)
self.fuzzy_eq(&Mat2::identity)
}
#[inline]
@ -174,7 +181,7 @@ pub impl Mat2: Matrix<float, Vec2> {
#[inline]
pure fn is_rotated() -> bool {
!self.fuzzy_eq(&mat2_identity)
!self.fuzzy_eq(&Mat2::identity)
}
}
@ -222,13 +229,6 @@ pub impl Mat2: FuzzyEq {
//
pub struct Mat3 { data:[Vec3 * 3] }
pub const mat3_zero :Mat3 = Mat3 { data: [ vec3_zero,
vec3_zero,
vec3_zero ] };
pub const mat3_identity :Mat3 = Mat3 { data: [ vec3_unit_x,
vec3_unit_y,
vec3_unit_z ] };
//
// Mat3 Constructor
//
@ -249,6 +249,15 @@ pub pure fn Mat3_v(col0: &Vec3, col1: &Vec3, col2: &Vec3) -> Mat3 {
Mat3 { data: [ *col0, *col1, *col2 ] }
}
pub mod Mat3 {
pub const zero :Mat3 = Mat3 { data: [ Vec3::zero,
Vec3::zero,
Vec3::zero ] };
pub const identity :Mat3 = Mat3 { data: [ Vec3::unit_x,
Vec3::unit_y,
Vec3::unit_z ] };
}
//
// Matrix3x3 Implementation
//
@ -337,7 +346,7 @@ pub impl Mat3: Matrix<float, Vec3> {
#[inline]
pure fn is_identity() -> bool {
self.fuzzy_eq(&mat3_identity)
self.fuzzy_eq(&Mat3::identity)
}
#[inline]
@ -366,7 +375,7 @@ pub impl Mat3: Matrix<float, Vec3> {
#[inline]
pure fn is_rotated() -> bool {
!self.fuzzy_eq(&mat3_identity)
!self.fuzzy_eq(&Mat3::identity)
}
}
@ -472,15 +481,6 @@ pub impl Mat3: FuzzyEq {
//
pub struct Mat4 { data:[Vec4 * 4] }
pub const mat4_zero :Mat4 = Mat4 { data: [ vec4_zero,
vec4_zero,
vec4_zero,
vec4_zero ] };
pub const mat4_identity :Mat4 = Mat4 { data: [ vec4_unit_x,
vec4_unit_y,
vec4_unit_z,
vec4_unit_w ] };
//
// Mat4 Constructor
//
@ -503,6 +503,17 @@ pub pure fn Mat4_v(col0: &Vec4, col1: &Vec4, col2: &Vec4, col3: &Vec4) -> Mat4 {
Mat4 { data: [ *col0, *col1, *col2, *col3 ] }
}
pub mod Mat4 {
pub const zero :Mat4 = Mat4 { data: [ Vec4::zero,
Vec4::zero,
Vec4::zero,
Vec4::zero ] };
pub const identity :Mat4 = Mat4 { data: [ Vec4::unit_x,
Vec4::unit_y,
Vec4::unit_z,
Vec4::unit_w ] };
}
//
// Matrix4x4 Implementation
//
@ -606,7 +617,7 @@ pub impl Mat4: Matrix<float, Vec4> {
#[inline]
pure fn is_identity() -> bool {
self.fuzzy_eq(&mat4_identity)
self.fuzzy_eq(&Mat4::identity)
}
#[inline]
@ -649,7 +660,7 @@ pub impl Mat4: Matrix<float, Vec4> {
#[inline]
pure fn is_rotated() -> bool {
!self.fuzzy_eq(&mat4_identity)
!self.fuzzy_eq(&Mat4::identity)
}
}

8
src/quaternion.rs
View file

@ -43,9 +43,6 @@ pub trait Quaternion<T> {
//
pub struct Quat { w: float, x: float, y: float, z: float }
pub const quat_zero :Quat = Quat { w: 0f, x: 0f, y: 0f, z: 0f };
pub const quat_identity :Quat = Quat { w: 1f, x: 0f, y: 0f, z: 0f };
//
// Quat Constructor
//
@ -54,6 +51,11 @@ pub pure fn Quat(w: float, x: float, y: float, z: float) -> Quat {
Quat { w: w, x: x, y: y, z: z }
}
pub mod Quat {
pub const zero :Quat = Quat { w: 0f, x: 0f, y: 0f, z: 0f };
pub const identity :Quat = Quat { w: 1f, x: 0f, y: 0f, z: 0f };
}
//
// Quaternion Implementation
//

24
src/test/test_matrix.rs
View file

@ -49,10 +49,10 @@ fn test_Mat2() {
// fuzzy_eq
// eq
assert mat2_identity.is_identity();
assert mat2_identity.is_symmetric();
assert mat2_identity.is_diagonal();
assert !mat2_identity.is_rotated();
assert Mat2::identity.is_identity();
assert Mat2::identity.is_symmetric();
assert Mat2::identity.is_diagonal();
assert !Mat2::identity.is_rotated();
assert !a.is_identity();
assert !a.is_symmetric();
@ -126,10 +126,10 @@ fn test_Mat3() {
// fuzzy_eq
// eq
assert mat3_identity.is_identity();
assert mat3_identity.is_symmetric();
assert mat3_identity.is_diagonal();
assert !mat3_identity.is_rotated();
assert Mat3::identity.is_identity();
assert Mat3::identity.is_symmetric();
assert Mat3::identity.is_diagonal();
assert !Mat3::identity.is_rotated();
assert !a.is_identity();
assert !a.is_symmetric();
@ -224,10 +224,10 @@ fn test_Mat4() {
// fuzzy_eq
// eq
assert mat4_identity.is_identity();
assert mat4_identity.is_symmetric();
assert mat4_identity.is_diagonal();
assert !mat4_identity.is_rotated();
assert Mat4::identity.is_identity();
assert Mat4::identity.is_symmetric();
assert Mat4::identity.is_diagonal();
assert !Mat4::identity.is_rotated();
assert !a.is_identity();
assert !a.is_symmetric();

4
src/test/test_quaternion.rs
View file

@ -13,8 +13,8 @@ fn test_Quat() {
assert a == Quat(1f, 2f, 3f, 4f);
assert quat_zero == Quat(0f, 0f, 0f, 0f);
assert quat_identity == Quat(1f, 0f, 0f, 0f);
assert Quat::zero == Quat(0f, 0f, 0f, 0f);
assert Quat::identity == Quat(1f, 0f, 0f, 0f);
assert a.w == 1f;
assert a.x == 2f;

30
src/test/test_vector.rs
View file

@ -14,10 +14,10 @@ fn test_Vec2() {
assert a == Vec2(1f, 2f);
assert vec2_zero == Vec2(0f, 0f);
assert vec2_unit_x == Vec2(1f, 0f);
assert vec2_unit_y == Vec2(0f, 1f);
assert vec2_identity == Vec2(1f, 1f);
assert Vec2::zero == Vec2(0f, 0f);
assert Vec2::unit_x == Vec2(1f, 0f);
assert Vec2::unit_y == Vec2(0f, 1f);
assert Vec2::identity == Vec2(1f, 1f);
assert a.x == 1f;
assert a.y == 2f;
@ -63,11 +63,11 @@ fn test_Vec3() {
assert a == Vec3(1f, 2f, 3f);
assert vec3_zero == Vec3(0f, 0f, 0f);
assert vec3_unit_x == Vec3(1f, 0f, 0f);
assert vec3_unit_y == Vec3(0f, 1f, 0f);
assert vec3_unit_z == Vec3(0f, 0f, 1f);
assert vec3_identity == Vec3(1f, 1f, 1f);
assert Vec3::zero == Vec3(0f, 0f, 0f);
assert Vec3::unit_x == Vec3(1f, 0f, 0f);
assert Vec3::unit_y == Vec3(0f, 1f, 0f);
assert Vec3::unit_z == Vec3(0f, 0f, 1f);
assert Vec3::identity == Vec3(1f, 1f, 1f);
assert a.x == 1f;
assert a.y == 2f;
@ -117,12 +117,12 @@ fn test_Vec4() {
assert a == Vec4(1f, 2f, 3f, 4f);
assert vec4_zero == Vec4(0f, 0f, 0f, 0f);
assert vec4_unit_x == Vec4(1f, 0f, 0f, 0f);
assert vec4_unit_y == Vec4(0f, 1f, 0f, 0f);
assert vec4_unit_z == Vec4(0f, 0f, 1f, 0f);
assert vec4_unit_w == Vec4(0f, 0f, 0f, 1f);
assert vec4_identity == Vec4(1f, 1f, 1f, 1f);
assert Vec4::zero == Vec4(0f, 0f, 0f, 0f);
assert Vec4::unit_x == Vec4(1f, 0f, 0f, 0f);
assert Vec4::unit_y == Vec4(0f, 1f, 0f, 0f);
assert Vec4::unit_z == Vec4(0f, 0f, 1f, 0f);
assert Vec4::unit_w == Vec4(0f, 0f, 0f, 1f);
assert Vec4::identity == Vec4(1f, 1f, 1f, 1f);
assert a.x == 1f;
assert a.y == 2f;

57
src/vector.rs
View file

@ -49,10 +49,6 @@ pub trait Vector3<T> {
//
pub struct Vec2 { x: float, y: float }
pub const vec2_zero :Vec2 = Vec2 { x: 0f, y: 0f };
pub const vec2_unit_x :Vec2 = Vec2 { x: 1f, y: 0f };
pub const vec2_unit_y :Vec2 = Vec2 { x: 0f, y: 1f };
pub const vec2_identity :Vec2 = Vec2 { x: 1f, y: 1f };
//
// Constructor
@ -62,6 +58,13 @@ pub pure fn Vec2(x: float, y: float) -> Vec2 {
Vec2 { x: x, y: y }
}
pub mod Vec2 {
pub const zero :Vec2 = Vec2 { x: 0f, y: 0f };
pub const unit_x :Vec2 = Vec2 { x: 1f, y: 0f };
pub const unit_y :Vec2 = Vec2 { x: 0f, y: 1f };
pub const identity :Vec2 = Vec2 { x: 1f, y: 1f };
}
pub impl Vec2: Vector<float> {
#[inline]
static pure fn dim() -> uint { 2 }
@ -166,8 +169,8 @@ pub impl Vec2: Index<uint, float> {
pub impl Vec2: Abs {
#[inline]
pure fn abs() -> Vec2 {
Vec2(abs(self[0]),
abs(self[1]))
Vec2(abs(&self[0]),
abs(&self[1]))
}
}
@ -214,12 +217,6 @@ pub impl Vec2: ToStr {
//
pub struct Vec3 { x: float, y: float, z: float }
pub const vec3_zero :Vec3 = Vec3 { x: 0f, y: 0f, z: 0f };
pub const vec3_unit_x :Vec3 = Vec3 { x: 1f, y: 0f, z: 0f };
pub const vec3_unit_y :Vec3 = Vec3 { x: 0f, y: 1f, z: 0f };
pub const vec3_unit_z :Vec3 = Vec3 { x: 0f, y: 0f, z: 1f };
pub const vec3_identity :Vec3 = Vec3 { x: 1f, y: 1f, z: 1f };
//
// Constructor
//
@ -228,6 +225,14 @@ pub pure fn Vec3(x: float, y: float, z: float) -> Vec3 {
Vec3 { x: x, y: y, z: z }
}
pub mod Vec3 {
pub const zero :Vec3 = Vec3 { x: 0f, y: 0f, z: 0f };
pub const unit_x :Vec3 = Vec3 { x: 1f, y: 0f, z: 0f };
pub const unit_y :Vec3 = Vec3 { x: 0f, y: 1f, z: 0f };
pub const unit_z :Vec3 = Vec3 { x: 0f, y: 0f, z: 1f };
pub const identity :Vec3 = Vec3 { x: 1f, y: 1f, z: 1f };
}
pub impl Vec3: Vector3<float> {
#[inline]
fn cross(other: &Vec3) -> Vec3 {
@ -351,9 +356,9 @@ pub impl Vec3: Index<uint, float> {
pub impl Vec3: Abs {
#[inline]
pure fn abs() -> Vec3 {
Vec3(abs(self[0]),
abs(self[1]),
abs(self[2]))
Vec3(abs(&self[0]),
abs(&self[1]),
abs(&self[2]))
}
}
@ -401,12 +406,14 @@ pub impl Vec3: ToStr {
//
pub struct Vec4 { x: float, y: float, z: float, w: float }
pub const vec4_zero :Vec4 = Vec4 { x: 0f, y: 0f, z: 0f, w: 0f };
pub const vec4_unit_x :Vec4 = Vec4 { x: 1f, y: 0f, z: 0f, w: 0f };
pub const vec4_unit_y :Vec4 = Vec4 { x: 0f, y: 1f, z: 0f, w: 0f };
pub const vec4_unit_z :Vec4 = Vec4 { x: 0f, y: 0f, z: 1f, w: 0f };
pub const vec4_unit_w :Vec4 = Vec4 { x: 0f, y: 0f, z: 0f, w: 1f };
pub const vec4_identity :Vec4 = Vec4 { x: 1f, y: 1f, z: 1f, w: 1f };
pub mod Vec4 {
pub const zero :Vec4 = Vec4 { x: 0f, y: 0f, z: 0f, w: 0f };
pub const unit_x :Vec4 = Vec4 { x: 1f, y: 0f, z: 0f, w: 0f };
pub const unit_y :Vec4 = Vec4 { x: 0f, y: 1f, z: 0f, w: 0f };
pub const unit_z :Vec4 = Vec4 { x: 0f, y: 0f, z: 1f, w: 0f };
pub const unit_w :Vec4 = Vec4 { x: 0f, y: 0f, z: 0f, w: 1f };
pub const identity :Vec4 = Vec4 { x: 1f, y: 1f, z: 1f, w: 1f };
}
//
// Constructor
@ -542,10 +549,10 @@ pub impl Vec4: Index<uint, float> {
pub impl Vec4: Abs {
#[inline]
pure fn abs() -> Vec4 {
Vec4(abs(self[0]),
abs(self[1]),
abs(self[2]),
abs(self[3]))
Vec4(abs(&self[0]),
abs(&self[1]),
abs(&self[2]),
abs(&self[3]))
}
}