From 3df7d557bda8d5f6607242155f7d83e33c62d27b Mon Sep 17 00:00:00 2001 From: Brendan Zabarauskas Date: Mon, 24 Sep 2012 12:54:24 +1000 Subject: [PATCH] Bring code into line with recent updates to Rust --- Makefile | 6 +- src/mat.rs | 366 ++++++++++++++++++------------------- src/math.rs | 22 +-- src/omath.rc | 2 +- src/projection.rs | 12 +- src/quat.rs | 124 ++++++------- src/vec.rs | 438 ++++++++++++++++++++++----------------------- test/test_mat.rs | 182 +++++++++---------- test/test_omath.rc | 4 +- test/test_quat.rs | 18 +- test/test_vec.rs | 150 ++++++++-------- 11 files changed, 663 insertions(+), 661 deletions(-) diff --git a/Makefile b/Makefile index 9216074..ba36247 100644 --- a/Makefile +++ b/Makefile @@ -13,6 +13,7 @@ TEST_CRATE = $(TEST).rc $(TARGET): @echo "Building $(TARGET)" + @mkdir -p $(BUILD_DIR) @rustc $(SRC_DIR)/$(SRC_CRATE) --lib -g --out-dir=$(BUILD_DIR) @echo "Success! \o/" @@ -21,10 +22,11 @@ all: $(TARGET) test: all @echo "..." @echo "Building $(TEST)" + @mkdir -p $(TEST_BUILD_DIR) @rustc --test -L lib $(TEST_DIR)/$(TEST_CRATE) -g --out-dir=$(TEST_BUILD_DIR) @echo "Success! \o/" @$(TEST_BUILD_DIR)/$(TEST) clean: - rm -R -f $(BUILD_DIR)/* - rm -R -f $(TEST_BUILD_DIR)/* \ No newline at end of file + rm -R -f $(BUILD_DIR) + rm -R -f $(TEST_BUILD_DIR) \ No newline at end of file diff --git a/src/mat.rs b/src/mat.rs index 076263d..b71f09a 100644 --- a/src/mat.rs +++ b/src/mat.rs @@ -1,10 +1,10 @@ -import std::cmp::FuzzyEq; -import cmp::Ord; -import num::Num; -// import to_str::ToStr; -import math::Sqrt; -import quat::quat; -import vec::*; +use std::cmp::FuzzyEq; +use cmp::Ord; +use num::Num; +// use to_str::ToStr; +use math::Sqrt; +use quat::Quat; +use vec::*; // // NxN Matrix @@ -44,15 +44,15 @@ trait Matrix { // trait Matrix3 { pure fn scale(&&vec:V3) -> self; - pure fn to_mat4() -> mat4; - pure fn to_quat() -> quat; + pure fn to_Mat4() -> Mat4; + pure fn to_Quat() -> Quat; } // // 4x4 Matrix // trait Matrix4 { - pure fn scale(&&vec:V3) -> self; // I don't like the use of `vec3` here + pure fn scale(&&vec:V3) -> self; // I don't like the use of `Vec3` here pure fn translate(&&vec:V3) -> self; } @@ -64,92 +64,92 @@ trait Matrix4 { // // Mat2: A 2x2, column major matrix // -struct mat2 { data:[vec2 * 2] } +struct Mat2 { data:[Vec2 * 2] } -const mat2_zero :mat2 = mat2 { data: [ vec2_zero, +const mat2_zero :Mat2 = Mat2 { data: [ vec2_zero, vec2_zero ] }; -const mat2_identity :mat2 = mat2 { data: [ vec2_unit_x, +const mat2_identity :Mat2 = Mat2 { data: [ vec2_unit_x, vec2_unit_y ] }; // // Mat2 Constructor // -#[inline(always)] -pure fn mat2(m00:float, m01:float, - m10:float, m11:float) -> mat2 { - mat2 { data: [ vec2(m00, m01), - vec2(m10, m11) ] } +#[inline] +pure fn Mat2(m00:float, m01:float, + m10:float, m11:float) -> Mat2 { + Mat2 { data: [ Vec2(m00, m01), + Vec2(m10, m11) ] } } // // Construct Mat2 from column vectors // -#[inline(always)] -pure fn mat2_v(col0:vec2, col1:vec2) -> mat2 { - mat2 { data: [ col0, col1 ] } +#[inline] +pure fn mat2_v(col0:Vec2, col1:Vec2) -> Mat2 { + Mat2 { data: [ col0, col1 ] } } // // Matrix2x2 Implementation // -impl mat2: Matrix { - #[inline(always)] +impl Mat2: Matrix { + #[inline] pure fn rows() -> uint { 2 } - #[inline(always)] + #[inline] pure fn cols() -> uint { 2 } - #[inline(always)] + #[inline] pure fn is_col_major() -> bool { true } - #[inline(always)] - pure fn index(&&i: uint) -> vec2 { + #[inline] + pure fn index(&&i: uint) -> Vec2 { self.data[i] } - #[inline(always)] - pure fn row(&&i:uint) -> vec2 { - vec2(self[0][i], + #[inline] + pure fn row(&&i:uint) -> Vec2 { + Vec2(self[0][i], self[1][i]) } - #[inline(always)] - pure fn col(&&i:uint) -> vec2 { + #[inline] + pure fn col(&&i:uint) -> Vec2 { self.data[i] } - #[inline(always)] - pure fn neg() -> mat2 { + #[inline] + pure fn neg() -> Mat2 { mat2_v(-self[0], -self[1]) } - #[inline(always)] - pure fn mul_f(&&value:float) -> mat2 { + #[inline] + pure fn mul_f(&&value:float) -> Mat2 { mat2_v(self[0].mul_f(value), self[1].mul_f(value)) } - #[inline(always)] - pure fn mul_v(&&other:vec2) -> vec2 { - vec2(self[0][0]*other[0] + self[1][0]*other[1], + #[inline] + pure fn mul_v(&&other:Vec2) -> Vec2 { + Vec2(self[0][0]*other[0] + self[1][0]*other[1], self[0][1]*other[0] + self[1][1]*other[1]) } - #[inline(always)] - pure fn add_m(&&other:mat2) -> mat2 { + #[inline] + pure fn add_m(&&other:Mat2) -> Mat2 { mat2_v(self[0].add_v(other[0]), self[1].add_v(other[1])) } - #[inline(always)] - pure fn sub_m(&&other:mat2) -> mat2 { + #[inline] + pure fn sub_m(&&other:Mat2) -> Mat2 { mat2_v(self[0].sub_v(other[0]), self[1].sub_v(other[1])) } - #[inline(always)] - pure fn mul_m(&&other:mat2) -> mat2 { - mat2(self[0][0]*other[0][0] + self[1][0]*other[0][1], + #[inline] + pure fn mul_m(&&other:Mat2) -> Mat2 { + Mat2(self[0][0]*other[0][0] + self[1][0]*other[0][1], self[0][1]*other[0][0] + self[1][1]*other[0][1], self[0][0]*other[1][0] + self[1][0]*other[1][1], @@ -157,50 +157,50 @@ impl mat2: Matrix { } // TODO - inversion is harrrd D: - // #[inline(always)] - // pure fn invert(&&other:mat2) -> mat2 {} + // #[inline] + // pure fn invert(&&other:Mat2) -> Mat2 {} - #[inline(always)] - pure fn transpose() -> mat2 { - mat2(self[0][0], self[1][0], + #[inline] + pure fn transpose() -> Mat2 { + Mat2(self[0][0], self[1][0], self[0][1], self[1][1]) } - #[inline(always)] - pure fn exact_eq(&&other:mat2) -> bool { + #[inline] + pure fn exact_eq(&&other:Mat2) -> bool { self[0].exact_eq(other[0]) && self[1].exact_eq(other[1]) } - #[inline(always)] - pure fn fuzzy_eq(&&other:mat2) -> bool { + #[inline] + pure fn fuzzy_eq(&&other:Mat2) -> bool { self[0].fuzzy_eq(other[0]) && self[1].fuzzy_eq(other[1]) } - #[inline(always)] - pure fn eq(&&other:mat2) -> bool { + #[inline] + pure fn eq(&&other:Mat2) -> bool { self.fuzzy_eq(other) } - #[inline(always)] + #[inline] pure fn is_identity() -> bool { self.fuzzy_eq(mat2_identity) } - #[inline(always)] + #[inline] pure fn is_symmetric() -> bool { self[0][1].fuzzy_eq(&self[1][0]) && self[1][0].fuzzy_eq(&self[0][1]) } - #[inline(always)] + #[inline] pure fn is_diagonal() -> bool { self[0][1].fuzzy_eq(&0f) && self[1][0].fuzzy_eq(&0f) } - #[inline(always)] + #[inline] pure fn is_rotated() -> bool { !self.fuzzy_eq(mat2_identity) } @@ -214,101 +214,101 @@ impl mat2: Matrix { // // Mat3: A 3x3, column major matrix // -struct mat3 { data:[vec3 * 3] } +struct Mat3 { data:[Vec3 * 3] } -const mat3_zero :mat3 = mat3 { data: [ vec3_zero, +const mat3_zero :Mat3 = Mat3 { data: [ vec3_zero, vec3_zero, vec3_zero ] }; -const mat3_identity :mat3 = mat3 { data: [ vec3_unit_x, +const mat3_identity :Mat3 = Mat3 { data: [ vec3_unit_x, vec3_unit_y, vec3_unit_z ] }; // // Mat3 Constructor // -#[inline(always)] -pure fn mat3(m00:float, m01:float, m02:float, +#[inline] +pure fn Mat3(m00:float, m01:float, m02:float, m10:float, m11:float, m12:float, - m20:float, m21:float, m22:float) -> mat3 { - mat3 { data: [ vec3(m00, m01, m02), - vec3(m10, m11, m12), - vec3(m20, m21, m22) ] } + m20:float, m21:float, m22:float) -> Mat3 { + Mat3 { data: [ Vec3(m00, m01, m02), + Vec3(m10, m11, m12), + Vec3(m20, m21, m22) ] } } // // Construct Mat3 from column vectors // -#[inline(always)] -pure fn mat3_v(col0:vec3, col1:vec3, col2:vec3) -> mat3 { - mat3 { data: [ col0, col1, col2 ] } +#[inline] +pure fn mat3_v(col0:Vec3, col1:Vec3, col2:Vec3) -> Mat3 { + Mat3 { data: [ col0, col1, col2 ] } } // // Matrix3x3 Implementation // -impl mat3: Matrix { - #[inline(always)] +impl Mat3: Matrix { + #[inline] pure fn rows() -> uint { 3 } - #[inline(always)] + #[inline] pure fn cols() -> uint { 3 } - #[inline(always)] + #[inline] pure fn is_col_major() -> bool { true } - #[inline(always)] - pure fn index(&&i: uint) -> vec3 { + #[inline] + pure fn index(&&i: uint) -> Vec3 { self.data[i] } - #[inline(always)] - pure fn row(&&i:uint) -> vec3 { - vec3(self[0][i], + #[inline] + pure fn row(&&i:uint) -> Vec3 { + Vec3(self[0][i], self[1][i], self[2][i]) } - #[inline(always)] - pure fn col(&&i:uint) -> vec3 { + #[inline] + pure fn col(&&i:uint) -> Vec3 { self.data[i] } - #[inline(always)] - pure fn neg() -> mat3 { + #[inline] + pure fn neg() -> Mat3 { mat3_v(-self[0], -self[1], -self[2]) } - #[inline(always)] - pure fn mul_f(&&value:float) -> mat3 { + #[inline] + pure fn mul_f(&&value:float) -> Mat3 { mat3_v(self[0].mul_f(value), self[1].mul_f(value), self[2].mul_f(value)) } - #[inline(always)] - pure fn mul_v(&&other:vec3) -> vec3 { - vec3(self[0][0]*other[0] + self[1][0]*other[1] + self[2][0]*other[2], + #[inline] + pure fn mul_v(&&other:Vec3) -> Vec3 { + Vec3(self[0][0]*other[0] + self[1][0]*other[1] + self[2][0]*other[2], self[0][1]*other[0] + self[1][1]*other[1] + self[2][1]*other[2], self[0][2]*other[0] + self[1][2]*other[1] + self[2][2]*other[2]) } - #[inline(always)] - pure fn add_m(&&other:mat3) -> mat3 { + #[inline] + pure fn add_m(&&other:Mat3) -> Mat3 { mat3_v(self[0].add_v(other[0]), self[1].add_v(other[1]), self[2].add_v(other[2])) } - #[inline(always)] - pure fn sub_m(&&other:mat3) -> mat3 { + #[inline] + pure fn sub_m(&&other:Mat3) -> Mat3 { mat3_v(self[0].sub_v(other[0]), self[1].sub_v(other[1]), self[2].sub_v(other[2])) } - #[inline(always)] - pure fn mul_m(&&other:mat3) -> mat3 { - mat3(self[0][0]*other[0][0] + self[1][0]*other[0][1] + self[2][0]*other[0][2], + #[inline] + pure fn mul_m(&&other:Mat3) -> Mat3 { + Mat3(self[0][0]*other[0][0] + self[1][0]*other[0][1] + self[2][0]*other[0][2], self[0][1]*other[0][0] + self[1][1]*other[0][1] + self[2][1]*other[0][2], self[0][2]*other[0][0] + self[1][2]*other[0][1] + self[2][2]*other[0][2], @@ -322,41 +322,41 @@ impl mat3: Matrix { } // TODO - inversion is harrrd D: - // #[inline(always)] - // pure fn invert(&&other:mat3) -> mat3 {} + // #[inline] + // pure fn invert(&&other:Mat3) -> Mat3 {} - #[inline(always)] - pure fn transpose() -> mat3 { - mat3(self[0][0], self[1][0], self[2][0], + #[inline] + pure fn transpose() -> Mat3 { + Mat3(self[0][0], self[1][0], self[2][0], self[0][1], self[1][1], self[2][1], self[0][2], self[1][2], self[2][2]) } - #[inline(always)] - pure fn exact_eq(&&other:mat3) -> bool { + #[inline] + pure fn exact_eq(&&other:Mat3) -> bool { self[0].exact_eq(other[0]) && self[1].exact_eq(other[1]) && self[2].exact_eq(other[2]) } - #[inline(always)] - pure fn fuzzy_eq(&&other:mat3) -> bool { + #[inline] + pure fn fuzzy_eq(&&other:Mat3) -> bool { self[0].fuzzy_eq(other[0]) && self[1].fuzzy_eq(other[1]) && self[2].fuzzy_eq(other[2]) } - #[inline(always)] - pure fn eq(&&other:mat3) -> bool { + #[inline] + pure fn eq(&&other:Mat3) -> bool { self.fuzzy_eq(other) } - #[inline(always)] + #[inline] pure fn is_identity() -> bool { self.fuzzy_eq(mat3_identity) } - #[inline(always)] + #[inline] pure fn is_symmetric() -> bool { self[0][1].fuzzy_eq(&self[1][0]) && self[0][2].fuzzy_eq(&self[2][0]) && @@ -368,7 +368,7 @@ impl mat3: Matrix { self[2][1].fuzzy_eq(&self[1][2]) } - #[inline(always)] + #[inline] pure fn is_diagonal() -> bool { self[0][1].fuzzy_eq(&0f) && self[0][2].fuzzy_eq(&0f) && @@ -380,31 +380,31 @@ impl mat3: Matrix { self[2][1].fuzzy_eq(&0f) } - #[inline(always)] + #[inline] pure fn is_rotated() -> bool { !self.fuzzy_eq(mat3_identity) } } -impl mat3: Matrix3 { - #[inline(always)] - pure fn scale(&&vec:vec3) -> mat3 { - self.mul_m(mat3(vec.x(), 0f, 0f, +impl Mat3: Matrix3 { + #[inline] + pure fn scale(&&vec:Vec3) -> Mat3 { + self.mul_m(Mat3(vec.x(), 0f, 0f, 0f, vec.y(), 0f, 0f, 0f, vec.z())) } - #[inline(always)] - pure fn to_mat4() -> mat4 { - mat4(self[0][0], self[0][1], self[0][2], 0f, + #[inline] + pure fn to_Mat4() -> Mat4 { + Mat4(self[0][0], self[0][1], self[0][2], 0f, self[1][0], self[1][1], self[1][2], 0f, self[2][0], self[2][1], self[2][2], 0f, 0f, 0f, 0f, 1f) } - pure fn to_quat() -> quat { + pure fn to_Quat() -> Quat { // Implemented using a mix of ideas from jMonkeyEngine and Ken Shoemake's - // paper on Quaternions: http://www.cs.ucr.edu/~vbz/resources/quatut.pdf + // paper on Quaternions: http://www.cs.ucr.edu/~vbz/resources/Quatut.pdf let mut s:float; let w:float, x:float, y:float, z:float; @@ -439,7 +439,7 @@ impl mat3: Matrix3 { y = self[1][2] - self[2][1] * s; z = self[0][1] - self[1][0] * s; } - return quat(w, x, y, z); + return Quat(w, x, y, z); } } @@ -451,13 +451,13 @@ impl mat3: Matrix3 { // // Mat4: A 4x4, column major matrix // -struct mat4 { data:[vec4 * 4] } +struct Mat4 { data:[Vec4 * 4] } -const mat4_zero :mat4 = mat4 { data: [ vec4_zero, +const mat4_zero :Mat4 = Mat4 { data: [ vec4_zero, vec4_zero, vec4_zero, vec4_zero ] }; -const mat4_identity :mat4 = mat4 { data: [ vec4_unit_x, +const mat4_identity :Mat4 = Mat4 { data: [ vec4_unit_x, vec4_unit_y, vec4_unit_z, vec4_unit_w ] }; @@ -465,96 +465,96 @@ const mat4_identity :mat4 = mat4 { data: [ vec4_unit_x, // // Mat4 Constructor // -#[inline(always)] -pure fn mat4(m00:float, m01:float, m02:float, m03:float, +#[inline] +pure fn Mat4(m00:float, m01:float, m02:float, m03:float, m10:float, m11:float, m12:float, m13:float, m20:float, m21:float, m22:float, m23:float, - m30:float, m31:float, m32:float, m33:float) -> mat4 { - mat4 { data: [ vec4(m00, m01, m02, m03), - vec4(m10, m11, m12, m13), - vec4(m20, m21, m22, m23), - vec4(m30, m31, m32, m33) ] } + m30:float, m31:float, m32:float, m33:float) -> Mat4 { + Mat4 { data: [ Vec4(m00, m01, m02, m03), + Vec4(m10, m11, m12, m13), + Vec4(m20, m21, m22, m23), + Vec4(m30, m31, m32, m33) ] } } // // Construct Mat4 from column vectors // -#[inline(always)] -pure fn mat4_v(col0:vec4, col1:vec4, col2:vec4, col3:vec4) -> mat4 { - mat4 { data: [ col0, col1, col2, col3 ] } +#[inline] +pure fn mat4_v(col0:Vec4, col1:Vec4, col2:Vec4, col3:Vec4) -> Mat4 { + Mat4 { data: [ col0, col1, col2, col3 ] } } // // Matrix4x4 Implementation // -impl mat4: Matrix { - #[inline(always)] +impl Mat4: Matrix { + #[inline] pure fn rows() -> uint { 4 } - #[inline(always)] + #[inline] pure fn cols() -> uint { 4 } - #[inline(always)] + #[inline] pure fn is_col_major() -> bool { true } - #[inline(always)] - pure fn index(&&i: uint) -> vec4 { + #[inline] + pure fn index(&&i: uint) -> Vec4 { self.data[i] } - #[inline(always)] - pure fn row(&&i:uint) -> vec4 { - vec4(self[0][i], + #[inline] + pure fn row(&&i:uint) -> Vec4 { + Vec4(self[0][i], self[1][i], self[2][i], self[3][i]) } - #[inline(always)] - pure fn col(&&i:uint) -> vec4 { + #[inline] + pure fn col(&&i:uint) -> Vec4 { self.data[i] } - #[inline(always)] - pure fn neg() -> mat4 { + #[inline] + pure fn neg() -> Mat4 { mat4_v(-self[0], -self[1], -self[2], -self[3]) } - #[inline(always)] - pure fn mul_f(&&value:float) -> mat4 { + #[inline] + pure fn mul_f(&&value:float) -> Mat4 { mat4_v(self[0].mul_f(value), self[1].mul_f(value), self[2].mul_f(value), self[3].mul_f(value)) } - #[inline(always)] - pure fn mul_v(&&other:vec4) -> vec4 { - vec4(self[0][0]*other[0] + self[1][0]*other[1] + self[2][0]*other[2] + self[3][0]*other[3], + #[inline] + pure fn mul_v(&&other:Vec4) -> Vec4 { + Vec4(self[0][0]*other[0] + self[1][0]*other[1] + self[2][0]*other[2] + self[3][0]*other[3], self[0][1]*other[0] + self[1][1]*other[1] + self[2][1]*other[2] + self[3][1]*other[3], self[0][2]*other[0] + self[1][2]*other[1] + self[2][2]*other[2] + self[3][2]*other[3], self[0][3]*other[0] + self[1][3]*other[1] + self[2][3]*other[2] + self[3][3]*other[3]) } - #[inline(always)] - pure fn add_m(&&other:mat4) -> mat4 { + #[inline] + pure fn add_m(&&other:Mat4) -> Mat4 { mat4_v(self[0].add_v(other[0]), self[1].add_v(other[1]), self[2].add_v(other[2]), self[3].add_v(other[3])) } - #[inline(always)] - pure fn sub_m(&&other:mat4) -> mat4 { + #[inline] + pure fn sub_m(&&other:Mat4) -> Mat4 { mat4_v(self[0].sub_v(other[0]), self[1].sub_v(other[1]), self[2].sub_v(other[2]), self[3].sub_v(other[3])) } - #[inline(always)] - pure fn mul_m(&&other:mat4) -> mat4 { - mat4(self[0][0]*other[0][0] + self[1][0]*other[0][1] + self[2][0]*other[0][2] + self[3][0]*other[0][3], + #[inline] + pure fn mul_m(&&other:Mat4) -> Mat4 { + Mat4(self[0][0]*other[0][0] + self[1][0]*other[0][1] + self[2][0]*other[0][2] + self[3][0]*other[0][3], self[0][1]*other[0][0] + self[1][1]*other[0][1] + self[2][1]*other[0][2] + self[3][1]*other[0][3], self[0][2]*other[0][0] + self[1][2]*other[0][1] + self[2][2]*other[0][2] + self[3][2]*other[0][3], self[0][3]*other[0][0] + self[1][3]*other[0][1] + self[2][3]*other[0][2] + self[3][3]*other[0][3], @@ -576,44 +576,44 @@ impl mat4: Matrix { } // TODO - inversion is harrrd D: - // #[inline(always)] - // pure fn invert(&&other:mat4) -> mat4 {} + // #[inline] + // pure fn invert(&&other:Mat4) -> Mat4 {} - #[inline(always)] - pure fn transpose() -> mat4 { - mat4(self[0][0], self[1][0], self[2][0], self[3][0], + #[inline] + pure fn transpose() -> Mat4 { + Mat4(self[0][0], self[1][0], self[2][0], self[3][0], self[0][1], self[1][1], self[2][1], self[3][1], self[0][2], self[1][2], self[2][2], self[3][2], self[0][3], self[1][3], self[2][3], self[3][3]) } - #[inline(always)] - pure fn exact_eq(&&other:mat4) -> bool { + #[inline] + pure fn exact_eq(&&other:Mat4) -> bool { self[0].exact_eq(other[0]) && self[1].exact_eq(other[1]) && self[2].exact_eq(other[2]) && self[3].exact_eq(other[3]) } - #[inline(always)] - pure fn fuzzy_eq(&&other:mat4) -> bool { + #[inline] + pure fn fuzzy_eq(&&other:Mat4) -> bool { self[0].fuzzy_eq(other[0]) && self[1].fuzzy_eq(other[1]) && self[2].fuzzy_eq(other[2]) && self[3].fuzzy_eq(other[3]) } - #[inline(always)] - pure fn eq(&&other:mat4) -> bool { + #[inline] + pure fn eq(&&other:Mat4) -> bool { self.fuzzy_eq(other) } - #[inline(always)] + #[inline] pure fn is_identity() -> bool { self.fuzzy_eq(mat4_identity) } - #[inline(always)] + #[inline] pure fn is_symmetric() -> bool { self[0][1].fuzzy_eq(&self[1][0]) && self[0][2].fuzzy_eq(&self[2][0]) && @@ -632,7 +632,7 @@ impl mat4: Matrix { self[3][2].fuzzy_eq(&self[2][3]) } - #[inline(always)] + #[inline] pure fn is_diagonal() -> bool { self[0][1].fuzzy_eq(&0f) && self[0][2].fuzzy_eq(&0f) && @@ -651,27 +651,27 @@ impl mat4: Matrix { self[3][2].fuzzy_eq(&0f) } - #[inline(always)] + #[inline] pure fn is_rotated() -> bool { !self.fuzzy_eq(mat4_identity) } } -impl mat4: Matrix4 { - #[inline(always)] - pure fn scale(&&vec:vec3) -> mat4 { - self.mul_m(mat4(vec.x(), 0f, 0f, 0f, +impl Mat4: Matrix4 { + #[inline] + pure fn scale(&&vec:Vec3) -> Mat4 { + self.mul_m(Mat4(vec.x(), 0f, 0f, 0f, 0f, vec.y(), 0f, 0f, 0f, 0f, vec.z(), 0f, 0f, 0f, 0f, 1f)) } - #[inline(always)] - pure fn translate(&&vec:vec3) -> mat4 { + #[inline] + pure fn translate(&&vec:Vec3) -> Mat4 { mat4_v(self[0], self[1], self[2], - vec4(self[3][0] + vec.x(), + Vec4(self[3][0] + vec.x(), self[3][1] + vec.y(), self[3][2] + vec.z(), self[3][3])) diff --git a/src/math.rs b/src/math.rs index 768f1ea..7a028ce 100644 --- a/src/math.rs +++ b/src/math.rs @@ -1,4 +1,4 @@ -import cmp::Ord; +use cmp::Ord; // // Abs @@ -8,7 +8,7 @@ trait Abs { } impl int: Abs { - #[inline(always)] + #[inline] pure fn abs() -> int { if self >= 0 { self } else {-self } @@ -16,7 +16,7 @@ impl int: Abs { } impl float: Abs { - #[inline(always)] + #[inline] pure fn abs() -> float { if self >= 0f { self } else {-self } @@ -24,7 +24,7 @@ impl float: Abs { } impl f32: Abs { - #[inline(always)] + #[inline] pure fn abs() -> f32 { if self >= 0f32 { self } else {-self } @@ -32,7 +32,7 @@ impl f32: Abs { } impl f64: Abs { - #[inline(always)] + #[inline] pure fn abs() -> f64 { if self >= 0f64 { self } else {-self } @@ -42,7 +42,7 @@ impl f64: Abs { // // Min // -#[inline(always)] +#[inline] pure fn min(&&a:T, &&b:T) -> T { if a < b { a } else { b } @@ -51,7 +51,7 @@ pure fn min(&&a:T, &&b:T) -> T { // // Max // -#[inline(always)] +#[inline] pure fn max(&&a:T, &&b:T) -> T { if a > b { a } else { b } @@ -65,28 +65,28 @@ trait Sqrt { } // impl int: Sqrt { -// #[inline(always)] +// #[inline] // pure fn sqrt() -> int { // sqrt(self) // } // } impl float: Sqrt { - #[inline(always)] + #[inline] pure fn sqrt() -> float { float::sqrt(self) } } impl f32: Sqrt { - #[inline(always)] + #[inline] pure fn sqrt() -> f32 { f32::sqrt(self) } } impl f64: Sqrt { - #[inline(always)] + #[inline] pure fn sqrt() -> f64 { f64::sqrt(self) } diff --git a/src/omath.rc b/src/omath.rc index 94096bd..0d81c8a 100644 --- a/src/omath.rc +++ b/src/omath.rc @@ -5,7 +5,7 @@ #[comment = "Linear algebra library for Rust. Incomplete and probably buggy."]; #[crate_type = "lib"]; -use std; +extern mod std; mod mat; mod math; diff --git a/src/projection.rs b/src/projection.rs index e3cd1e0..026a8c9 100644 --- a/src/projection.rs +++ b/src/projection.rs @@ -1,6 +1,6 @@ -import float::consts::pi; -import float::tan; -import mat::mat4; +use float::consts::pi; +use float::tan; +use mat::Mat4; // // Create a perspective projection matrix @@ -8,7 +8,7 @@ import mat::mat4; // fov is in degrees // http://www.opengl.org/wiki/GluPerspective_code // -pure fn perspective(fovy:float, aspectRatio:float, near:float, far:float) -> mat4 { +pure fn perspective(fovy:float, aspectRatio:float, near:float, far:float) -> Mat4 { let ymax = near * tan(fovy * pi / 360f); let xmax = ymax * aspectRatio; return frustum(-xmax, xmax, -ymax, ymax, near, far); @@ -21,7 +21,7 @@ pure fn perspective(fovy:float, aspectRatio:float, near:float, far:float) -> mat // // TODO: double check algorithm // -pure fn frustum(left:float, right:float, bottom:float, top:float, near:float, far:float) -> mat4 { +pure fn frustum(left:float, right:float, bottom:float, top:float, near:float, far:float) -> Mat4 { let m00 = (2f * near) / (right - left); let m01 = 0f; let m02 = 0f; @@ -39,7 +39,7 @@ pure fn frustum(left:float, right:float, bottom:float, top:float, near:float, fa let m32 = -(2f * far * near) / (far - near); let m33 = 0f; - return mat4(m00, m01, m02, m03, + return Mat4(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33); diff --git a/src/quat.rs b/src/quat.rs index e55d4c8..acf6f94 100644 --- a/src/quat.rs +++ b/src/quat.rs @@ -1,10 +1,10 @@ -import std::cmp::FuzzyEq; -import cmp::Ord; -import num::Num; -import to_str::ToStr; -import math::Sqrt; -import mat::{mat3, mat4}; -import vec::vec3; +use std::cmp::FuzzyEq; +use cmp::Ord; +use num::Num; +use to_str::ToStr; +use math::Sqrt; +use mat::{Mat3, Mat4}; +use vec::Vec3; // TODO: Unittests @@ -25,7 +25,7 @@ trait Quaternion { pure fn mul_f(&&value:T) -> self; pure fn div_f(&&value:T) -> self; - // pure fn mul_v(&&vec3) -> vec3; + // pure fn mul_v(&&Vec3) -> Vec3; pure fn add_q(&&other:self) -> self; pure fn sub_q(&&other:self) -> self; @@ -40,8 +40,8 @@ trait Quaternion { pure fn magnitude2() -> T; pure fn magnitude() -> T; - pure fn to_mat3() -> mat3; - pure fn to_mat4() -> mat4; + pure fn to_Mat3() -> Mat3; + pure fn to_Mat4() -> Mat4; } @@ -52,113 +52,113 @@ trait Quaternion { // // Quat struct definition // -struct quat { data:[float * 4] } +struct Quat { data:[float * 4] } -const quat_zero :quat = quat { data: [ 0f, 0f, 0f, 0f ] }; -const quat_identity :quat = quat { data: [ 1f, 0f, 0f, 0f ] }; +const quat_zero :Quat = Quat { data: [ 0f, 0f, 0f, 0f ] }; +const quat_identity :Quat = Quat { data: [ 1f, 0f, 0f, 0f ] }; // // Quat Constructor // -#[inline(always)] -pure fn quat(w:float, x:float, y:float, z:float) -> quat { - quat { data: [ w, x, y, z ] } +#[inline] +pure fn Quat(w:float, x:float, y:float, z:float) -> Quat { + Quat { data: [ w, x, y, z ] } } // // Quaternion Implementation // -impl quat: Quaternion { - #[inline(always)] +impl Quat: Quaternion { + #[inline] pure fn dim() -> uint { 4 } - #[inline(always)] + #[inline] pure fn index(&&i: uint) -> float { self.data[i] } - #[inline(always)] - pure fn neg() -> quat { - quat(-self[0], -self[1], -self[2], -self[3]) + #[inline] + pure fn neg() -> Quat { + Quat(-self[0], -self[1], -self[2], -self[3]) } - #[inline(always)] pure fn w() -> float { self.data[0] } - #[inline(always)] pure fn x() -> float { self.data[1] } - #[inline(always)] pure fn y() -> float { self.data[2] } - #[inline(always)] pure fn z() -> float { self.data[3] } + #[inline] pure fn w() -> float { self.data[0] } + #[inline] pure fn x() -> float { self.data[1] } + #[inline] pure fn y() -> float { self.data[2] } + #[inline] pure fn z() -> float { self.data[3] } - #[inline(always)] - pure fn mul_f(&&value:float) -> quat { - quat(self[0] * value, + #[inline] + pure fn mul_f(&&value:float) -> Quat { + Quat(self[0] * value, self[1] * value, self[2] * value, self[3] * value) } - #[inline(always)] - pure fn div_f(&&value:float) -> quat { - quat(self[0] / value, + #[inline] + pure fn div_f(&&value:float) -> Quat { + Quat(self[0] / value, self[1] / value, self[2] / value, self[3] / value) } - #[inline(always)] - pure fn add_q(&&other:quat) -> quat{ - quat(self[0] + other[0], + #[inline] + pure fn add_q(&&other:Quat) -> Quat{ + Quat(self[0] + other[0], self[1] + other[1], self[2] + other[2], self[3] + other[3]) } - #[inline(always)] - pure fn sub_q(&&other:quat) -> quat{ - quat(self[0] - other[0], + #[inline] + pure fn sub_q(&&other:Quat) -> Quat{ + Quat(self[0] - other[0], self[1] - other[1], self[2] - other[2], self[3] - other[3]) } - #[inline(always)] - pure fn mul_q(&&other:quat) -> quat { - quat(self.w()*other.w() - self.x()*other.x() - self.y()*other.y() - self.z()*other.z(), + #[inline] + pure fn mul_q(&&other:Quat) -> Quat { + Quat(self.w()*other.w() - self.x()*other.x() - self.y()*other.y() - self.z()*other.z(), self.w()*other.x() + self.x()*other.w() + self.y()*other.z() - self.z()*other.y(), self.w()*other.y() + self.y()*other.w() + self.z()*other.x() - self.x()*other.z(), self.w()*other.z() + self.z()*other.w() + self.x()*other.y() - self.y()*other.x()) } - #[inline(always)] - pure fn exact_eq(&&other:quat) -> bool { + #[inline] + pure fn exact_eq(&&other:Quat) -> bool { self[0] == other[0] && self[1] == other[1] && self[2] == other[2] && self[3] == other[3] } - #[inline(always)] - pure fn fuzzy_eq(&&other: quat) -> bool { + #[inline] + pure fn fuzzy_eq(&&other: Quat) -> bool { self[0].fuzzy_eq(&other[0]) && self[1].fuzzy_eq(&other[1]) && self[2].fuzzy_eq(&other[2]) && self[3].fuzzy_eq(&other[3]) } - #[inline(always)] - pure fn eq(&&other:quat) -> bool { + #[inline] + pure fn eq(&&other:Quat) -> bool { self.fuzzy_eq(other) } - #[inline(always)] - pure fn conjugate() -> quat { - quat(self.w(), -self.x(), -self.y(), -self.z()) + #[inline] + pure fn conjugate() -> Quat { + Quat(self.w(), -self.x(), -self.y(), -self.z()) } - #[inline(always)] - pure fn inverse() -> quat { + #[inline] + pure fn inverse() -> Quat { self.conjugate().mul_f((1f / self.magnitude2())) } - #[inline(always)] + #[inline] pure fn magnitude2() -> float { self.w() * self.w() + self.x() * self.x() + @@ -166,13 +166,13 @@ impl quat: Quaternion { self.z() * self.z() } - #[inline(always)] + #[inline] pure fn magnitude() -> float { self.magnitude2().sqrt() } - #[inline(always)] - pure fn to_mat3() -> mat3 { + #[inline] + pure fn to_Mat3() -> Mat3 { let x2 = self.x() + self.x(); let y2 = self.y() + self.y(); let z2 = self.z() + self.z(); @@ -189,22 +189,22 @@ impl quat: Quaternion { let wz2 = z2 * self.w(); let wx2 = x2 * self.w(); - return mat3(1f - yy2 - zz2, xy2 - wz2, xz2 + wy2, + return Mat3(1f - yy2 - zz2, xy2 - wz2, xz2 + wy2, xy2 + wz2, 1f - xx2 - zz2, yz2 - wx2, xz2 - wy2, yz2 + wx2, 1f - xx2 - yy2); } - #[inline(always)] - pure fn to_mat4() -> mat4 { - self.to_mat3().to_mat4() + #[inline] + pure fn to_Mat4() -> Mat4 { + self.to_Mat3().to_Mat4() } } // // Convert To String // -impl quat: ToStr { +impl Quat: ToStr { fn to_str() -> ~str { - fmt!("quat[ %f, %f, %f, %f ]", self.w(), self.x(), self.y(), self.z()) + fmt!("Quat[ %f, %f, %f, %f ]", self.w(), self.x(), self.y(), self.z()) } } \ No newline at end of file diff --git a/src/vec.rs b/src/vec.rs index 8a53ee9..73d9eba 100644 --- a/src/vec.rs +++ b/src/vec.rs @@ -1,8 +1,8 @@ -import std::cmp::FuzzyEq; -import cmp::Ord; -import num::Num; -import math::{Abs, min, max, Sqrt}; -import to_str::ToStr; +use std::cmp::FuzzyEq; +use cmp::Ord; +use num::Num; +use math::{Abs, min, max, Sqrt}; +use to_str::ToStr; // // N-dimensional Vector @@ -96,155 +96,155 @@ trait Vector4 { // // Vec2 // -struct vec2 { data:[float * 2] } +struct Vec2 { data:[float * 2] } -const vec2_zero :vec2 = vec2 { data: [ 0f, 0f ] }; -const vec2_unit_x :vec2 = vec2 { data: [ 1f, 0f ] }; -const vec2_unit_y :vec2 = vec2 { data: [ 0f, 1f ] }; -const vec2_identity :vec2 = vec2 { data: [ 1f, 1f ] }; +const vec2_zero :Vec2 = Vec2 { data: [ 0f, 0f ] }; +const vec2_unit_x :Vec2 = Vec2 { data: [ 1f, 0f ] }; +const vec2_unit_y :Vec2 = Vec2 { data: [ 0f, 1f ] }; +const vec2_identity :Vec2 = Vec2 { data: [ 1f, 1f ] }; // // Constructor // -#[inline(always)] -pure fn vec2(x:float, y:float) -> vec2 { - vec2 { data: [ x, y ] } +#[inline] +pure fn Vec2(x:float, y:float) -> Vec2 { + Vec2 { data: [ x, y ] } } -impl vec2: Vector2 { - // #[inline(always)] - // static pure fn _new(x:float, y:float) -> vec2 { - // vec2 { data: [ x, y ] } +impl Vec2: Vector2 { + // #[inline] + // static pure fn _new(x:float, y:float) -> Vec2 { + // Vec2 { data: [ x, y ] } // } - #[inline(always)] pure fn x() -> float { self.data[0] } - #[inline(always)] pure fn y() -> float { self.data[1] } + #[inline] pure fn x() -> float { self.data[0] } + #[inline] pure fn y() -> float { self.data[1] } - // #[inline(always)] static pure fn unit_x() -> vec2 { vec2(1f, 0f) } - // #[inline(always)] static pure fn unit_y() -> vec2 { vec2(0f, 1f) } - // #[inline(always)] static pure fn unit_z() -> vec2 { vec2(0f, 0f) } + // #[inline] static pure fn unit_x() -> Vec2 { Vec2(1f, 0f) } + // #[inline] static pure fn unit_y() -> Vec2 { Vec2(0f, 1f) } + // #[inline] static pure fn unit_z() -> Vec2 { Vec2(0f, 0f) } } -impl vec2: Vector { - #[inline(always)] +impl Vec2: Vector { + #[inline] static pure fn dim() -> uint { 2 } - #[inline(always)] + #[inline] pure fn index(&&i: uint) -> float { self.data[i] } - #[inline(always)] - pure fn neg() -> vec2 { - vec2(-self[0], -self[1]) + #[inline] + pure fn neg() -> Vec2 { + Vec2(-self[0], -self[1]) } - #[inline(always)] - pure fn add_f(&&value:float) -> vec2 { - vec2(self[0] + value, + #[inline] + pure fn add_f(&&value:float) -> Vec2 { + Vec2(self[0] + value, self[1] + value) } - #[inline(always)] - pure fn sub_f(&&value:float) -> vec2 { - vec2(self[0] - value, + #[inline] + pure fn sub_f(&&value:float) -> Vec2 { + Vec2(self[0] - value, self[1] - value) } - #[inline(always)] - pure fn mul_f(&&value:float) -> vec2 { - vec2(self[0] * value, + #[inline] + pure fn mul_f(&&value:float) -> Vec2 { + Vec2(self[0] * value, self[1] * value) } - #[inline(always)] - pure fn div_f(&&value:float) -> vec2 { - vec2(self[0] / value, + #[inline] + pure fn div_f(&&value:float) -> Vec2 { + Vec2(self[0] / value, self[1] / value) } - #[inline(always)] - pure fn add_v(&&other: vec2) -> vec2{ - vec2(self[0] + other[0], + #[inline] + pure fn add_v(&&other: Vec2) -> Vec2{ + Vec2(self[0] + other[0], self[1] + other[1]) } - #[inline(always)] - pure fn sub_v(&&other: vec2) -> vec2{ - vec2(self[0] - other[0], + #[inline] + pure fn sub_v(&&other: Vec2) -> Vec2{ + Vec2(self[0] - other[0], self[1] - other[1]) } - #[inline(always)] - pure fn dot(&&other: vec2) -> float { + #[inline] + pure fn dot(&&other: Vec2) -> float { self[0] * other[0] + self[1] * other[1] } - #[inline(always)] - pure fn exact_eq(&&other:vec2) -> bool { + #[inline] + pure fn exact_eq(&&other:Vec2) -> bool { self[0] == other[0] && self[1] == other[1] } - #[inline(always)] - pure fn fuzzy_eq(&&other: vec2) -> bool { + #[inline] + pure fn fuzzy_eq(&&other: Vec2) -> bool { self[0].fuzzy_eq(&other[0]) && self[1].fuzzy_eq(&other[1]) } - #[inline(always)] - pure fn eq(&&other:vec2) -> bool { + #[inline] + pure fn eq(&&other:Vec2) -> bool { self.fuzzy_eq(other) } - #[inline(always)] + #[inline] pure fn magnitude2() -> float { self[0] * self[0] + self[1] * self[1] } - #[inline(always)] + #[inline] pure fn magnitude() -> float { self.magnitude2().sqrt() } - #[inline(always)] - pure fn normalize() -> vec2 { + #[inline] + pure fn normalize() -> Vec2 { let n = 1f / self.magnitude(); return self.mul_f(n); } - #[inline(always)] - pure fn lerp(&&other:vec2, &&value:float) -> vec2 { + #[inline] + pure fn lerp(&&other:Vec2, &&value:float) -> Vec2 { self.add_v((other.sub_v(self)).mul_f(value)) } - #[inline(always)] - pure fn abs() -> vec2 { - vec2(self[0].abs(), + #[inline] + pure fn abs() -> Vec2 { + Vec2(self[0].abs(), self[1].abs()) } - #[inline(always)] - pure fn min(&&other:vec2) -> vec2 { - vec2(min(self[0], other[0]), + #[inline] + pure fn min(&&other:Vec2) -> Vec2 { + Vec2(min(self[0], other[0]), min(self[1], other[1])) } - #[inline(always)] - pure fn max(&&other:vec2) -> vec2 { - vec2(max(self[0], other[0]), + #[inline] + pure fn max(&&other:Vec2) -> Vec2 { + Vec2(max(self[0], other[0]), max(self[1], other[1])) } - #[inline(always)] static pure fn zero() -> vec2 { vec2(1f, 1f) } - #[inline(always)] static pure fn identity() -> vec2 { vec2(1f, 1f) } + #[inline] static pure fn zero() -> Vec2 { Vec2(1f, 1f) } + #[inline] static pure fn identity() -> Vec2 { Vec2(1f, 1f) } } -impl vec2: ToStr { +impl Vec2: ToStr { fn to_str() -> ~str { - fmt!("vec2[ %f, %f ]", self[0], self[1]) + fmt!("Vec2[ %f, %f ]", self[0], self[1]) } } @@ -256,177 +256,177 @@ impl vec2: ToStr { // // Vec3 // -struct vec3 { data:[float * 3] } +struct Vec3 { data:[float * 3] } -const vec3_zero :vec3 = vec3 { data: [ 0f, 0f, 0f ] }; -const vec3_unit_x :vec3 = vec3 { data: [ 1f, 0f, 0f ] }; -const vec3_unit_y :vec3 = vec3 { data: [ 0f, 1f, 0f ] }; -const vec3_unit_z :vec3 = vec3 { data: [ 0f, 0f, 1f ] }; -const vec3_identity :vec3 = vec3 { data: [ 1f, 1f, 1f ] }; +const vec3_zero :Vec3 = Vec3 { data: [ 0f, 0f, 0f ] }; +const vec3_unit_x :Vec3 = Vec3 { data: [ 1f, 0f, 0f ] }; +const vec3_unit_y :Vec3 = Vec3 { data: [ 0f, 1f, 0f ] }; +const vec3_unit_z :Vec3 = Vec3 { data: [ 0f, 0f, 1f ] }; +const vec3_identity :Vec3 = Vec3 { data: [ 1f, 1f, 1f ] }; // // Constructor // -#[inline(always)] -pure fn vec3(x:float, y:float, z:float) -> vec3 { - vec3 { data: [ x, y, z ] } +#[inline] +pure fn Vec3(x:float, y:float, z:float) -> Vec3 { + Vec3 { data: [ x, y, z ] } } -impl vec3: Vector3 { - // #[inline(always)] - // static pure fn _new(x:float, y:float, z:float) -> vec3 { - // vec2 { data: [ x, y, z ] } +impl Vec3: Vector3 { + // #[inline] + // static pure fn _new(x:float, y:float, z:float) -> Vec3 { + // Vec2 { data: [ x, y, z ] } // } - #[inline(always)] pure fn x() -> float { self.data[0] } - #[inline(always)] pure fn y() -> float { self.data[1] } - #[inline(always)] pure fn z() -> float { self.data[2] } + #[inline] pure fn x() -> float { self.data[0] } + #[inline] pure fn y() -> float { self.data[1] } + #[inline] pure fn z() -> float { self.data[2] } - #[inline(always)] - fn cross(&&other:vec3) -> vec3 { - vec3((self[1] * other[2]) - (self[2] * other[1]), + #[inline] + fn cross(&&other:Vec3) -> Vec3 { + Vec3((self[1] * other[2]) - (self[2] * other[1]), (self[2] * other[0]) - (self[0] * other[2]), (self[0] * other[1]) - (self[1] * other[0])) } - // #[inline(always)] static pure fn unit_x() -> vec3 { vec3(1f, 0f, 0f) } - // #[inline(always)] static pure fn unit_y() -> vec3 { vec3(0f, 1f, 0f) } - // #[inline(always)] static pure fn unit_z() -> vec3 { vec3(0f, 0f, 1f) } + // #[inline] static pure fn unit_x() -> Vec3 { Vec3(1f, 0f, 0f) } + // #[inline] static pure fn unit_y() -> Vec3 { Vec3(0f, 1f, 0f) } + // #[inline] static pure fn unit_z() -> Vec3 { Vec3(0f, 0f, 1f) } } -impl vec3: Vector { - #[inline(always)] +impl Vec3: Vector { + #[inline] static pure fn dim() -> uint { 3 } - #[inline(always)] + #[inline] pure fn index(&&i: uint) -> float { self.data[i] } - #[inline(always)] - pure fn neg() -> vec3 { - vec3(-self[0], -self[1], -self[2]) + #[inline] + pure fn neg() -> Vec3 { + Vec3(-self[0], -self[1], -self[2]) } - #[inline(always)] - pure fn add_f(&&value:float) -> vec3 { - vec3(self[0] + value, + #[inline] + pure fn add_f(&&value:float) -> Vec3 { + Vec3(self[0] + value, self[1] + value, self[2] + value) } - #[inline(always)] - pure fn sub_f(&&value:float) -> vec3 { - vec3(self[0] - value, + #[inline] + pure fn sub_f(&&value:float) -> Vec3 { + Vec3(self[0] - value, self[1] - value, self[2] - value) } - #[inline(always)] - pure fn mul_f(&&value:float) -> vec3 { - vec3(self[0] * value, + #[inline] + pure fn mul_f(&&value:float) -> Vec3 { + Vec3(self[0] * value, self[1] * value, self[2] * value) } - #[inline(always)] - pure fn div_f(&&value:float) -> vec3 { - vec3(self[0] / value, + #[inline] + pure fn div_f(&&value:float) -> Vec3 { + Vec3(self[0] / value, self[1] / value, self[2] / value) } - #[inline(always)] - pure fn add_v(&&other: vec3) -> vec3{ - vec3(self[0] + other[0], + #[inline] + pure fn add_v(&&other: Vec3) -> Vec3{ + Vec3(self[0] + other[0], self[1] + other[1], self[2] + other[2]) } - #[inline(always)] - pure fn sub_v(&&other: vec3) -> vec3{ - vec3(self[0] - other[0], + #[inline] + pure fn sub_v(&&other: Vec3) -> Vec3{ + Vec3(self[0] - other[0], self[1] - other[1], self[2] - other[2]) } - #[inline(always)] - pure fn dot(&&other: vec3) -> float { + #[inline] + pure fn dot(&&other: Vec3) -> float { self[0] * other[0] + self[1] * other[1] + self[2] * other[2] } - #[inline(always)] - pure fn exact_eq(&&other:vec3) -> bool { + #[inline] + pure fn exact_eq(&&other:Vec3) -> bool { self[0] == other[0] && self[1] == other[1] && self[2] == other[2] } - #[inline(always)] - pure fn fuzzy_eq(&&other: vec3) -> bool { + #[inline] + pure fn fuzzy_eq(&&other: Vec3) -> bool { self[0].fuzzy_eq(&other[0]) && self[1].fuzzy_eq(&other[1]) && self[2].fuzzy_eq(&other[2]) } - #[inline(always)] - pure fn eq(&&other:vec3) -> bool { + #[inline] + pure fn eq(&&other:Vec3) -> bool { self.fuzzy_eq(other) } - #[inline(always)] + #[inline] pure fn magnitude2() -> float { self[0] * self[0] + self[1] * self[1] + self[2] * self[2] } - #[inline(always)] + #[inline] pure fn magnitude() -> float { self.magnitude2().sqrt() } - #[inline(always)] - pure fn normalize() -> vec3 { + #[inline] + pure fn normalize() -> Vec3 { let n = 1f / self.magnitude(); return self.mul_f(n); } - #[inline(always)] - pure fn lerp(&&other:vec3, &&value:float) -> vec3 { + #[inline] + pure fn lerp(&&other:Vec3, &&value:float) -> Vec3 { self.add_v((other.sub_v(self)).mul_f(value)) } - #[inline(always)] - pure fn abs() -> vec3 { - vec3(self[0].abs(), + #[inline] + pure fn abs() -> Vec3 { + Vec3(self[0].abs(), self[1].abs(), self[2].abs()) } - #[inline(always)] - pure fn min(&&other:vec3) -> vec3 { - vec3(min(self[0], other[0]), + #[inline] + pure fn min(&&other:Vec3) -> Vec3 { + Vec3(min(self[0], other[0]), min(self[1], other[1]), min(self[2], other[2])) } - #[inline(always)] - pure fn max(&&other:vec3) -> vec3 { - vec3(max(self[0], other[0]), + #[inline] + pure fn max(&&other:Vec3) -> Vec3 { + Vec3(max(self[0], other[0]), max(self[1], other[1]), max(self[2], other[2])) } - #[inline(always)] static pure fn zero() -> vec3 { vec3(1f, 1f, 1f) } - #[inline(always)] static pure fn identity() -> vec3 { vec3(1f, 1f, 1f) } + #[inline] static pure fn zero() -> Vec3 { Vec3(1f, 1f, 1f) } + #[inline] static pure fn identity() -> Vec3 { Vec3(1f, 1f, 1f) } } -impl vec3: ToStr { +impl Vec3: ToStr { fn to_str() -> ~str { - fmt!("vec3[ %f, %f, %f ]", self[0], self[1], self[2]) + fmt!("Vec3[ %f, %f, %f ]", self[0], self[1], self[2]) } } @@ -438,132 +438,132 @@ impl vec3: ToStr { // // Vec4 // -struct vec4 { data:[float * 4] } +struct Vec4 { data:[float * 4] } -const vec4_zero :vec4 = vec4 { data: [ 0f, 0f, 0f, 0f ] }; -const vec4_unit_x :vec4 = vec4 { data: [ 1f, 0f, 0f, 0f ] }; -const vec4_unit_y :vec4 = vec4 { data: [ 0f, 1f, 0f, 0f ] }; -const vec4_unit_z :vec4 = vec4 { data: [ 0f, 0f, 1f, 0f ] }; -const vec4_unit_w :vec4 = vec4 { data: [ 0f, 0f, 0f, 1f ] }; -const vec4_identity :vec4 = vec4 { data: [ 1f, 1f, 1f, 1f ] }; +const vec4_zero :Vec4 = Vec4 { data: [ 0f, 0f, 0f, 0f ] }; +const vec4_unit_x :Vec4 = Vec4 { data: [ 1f, 0f, 0f, 0f ] }; +const vec4_unit_y :Vec4 = Vec4 { data: [ 0f, 1f, 0f, 0f ] }; +const vec4_unit_z :Vec4 = Vec4 { data: [ 0f, 0f, 1f, 0f ] }; +const vec4_unit_w :Vec4 = Vec4 { data: [ 0f, 0f, 0f, 1f ] }; +const vec4_identity :Vec4 = Vec4 { data: [ 1f, 1f, 1f, 1f ] }; // // Constructor // -#[inline(always)] -pure fn vec4(x:float, y:float, z:float, w:float) -> vec4 { - vec4 { data: [ x, y, z, w ] } +#[inline] +pure fn Vec4(x:float, y:float, z:float, w:float) -> Vec4 { + Vec4 { data: [ x, y, z, w ] } } -impl vec4: Vector4 { - // #[inline(always)] - // static pure fn _new(x:float, y:float, z:float, w:float) -> vec3 { - // vec2 { data: [ x, y, z, w ] } +impl Vec4: Vector4 { + // #[inline] + // static pure fn _new(x:float, y:float, z:float, w:float) -> Vec3 { + // Vec2 { data: [ x, y, z, w ] } // } - #[inline(always)] pure fn x() -> float { self.data[0] } - #[inline(always)] pure fn y() -> float { self.data[1] } - #[inline(always)] pure fn z() -> float { self.data[2] } - #[inline(always)] pure fn w() -> float { self.data[3] } + #[inline] pure fn x() -> float { self.data[0] } + #[inline] pure fn y() -> float { self.data[1] } + #[inline] pure fn z() -> float { self.data[2] } + #[inline] pure fn w() -> float { self.data[3] } - // #[inline(always)] static pure fn unit_x() -> vec4 { vec4(1f, 0f, 0f, 0f) } - // #[inline(always)] static pure fn unit_y() -> vec4 { vec4(0f, 1f, 0f, 0f) } - // #[inline(always)] static pure fn unit_z() -> vec4 { vec4(0f, 0f, 1f, 0f) } - // #[inline(always)] static pure fn unit_w() -> vec4 { vec4(0f, 0f, 0f, 1f) } + // #[inline] static pure fn unit_x() -> Vec4 { Vec4(1f, 0f, 0f, 0f) } + // #[inline] static pure fn unit_y() -> Vec4 { Vec4(0f, 1f, 0f, 0f) } + // #[inline] static pure fn unit_z() -> Vec4 { Vec4(0f, 0f, 1f, 0f) } + // #[inline] static pure fn unit_w() -> Vec4 { Vec4(0f, 0f, 0f, 1f) } } -impl vec4: Vector { - #[inline(always)] +impl Vec4: Vector { + #[inline] static pure fn dim() -> uint { 4 } - #[inline(always)] + #[inline] pure fn index(&&i: uint) -> float { self.data[i] } - #[inline(always)] - pure fn neg() -> vec4 { - vec4(-self[0], -self[1], -self[2], -self[3]) + #[inline] + pure fn neg() -> Vec4 { + Vec4(-self[0], -self[1], -self[2], -self[3]) } - #[inline(always)] - pure fn add_f(&&value:float) -> vec4 { - vec4(self[0] + value, + #[inline] + pure fn add_f(&&value:float) -> Vec4 { + Vec4(self[0] + value, self[1] + value, self[2] + value, self[3] + value) } - #[inline(always)] - pure fn sub_f(&&value:float) -> vec4 { - vec4(self[0] - value, + #[inline] + pure fn sub_f(&&value:float) -> Vec4 { + Vec4(self[0] - value, self[1] - value, self[2] - value, self[3] - value) } - #[inline(always)] - pure fn mul_f(&&value:float) -> vec4 { - vec4(self[0] * value, + #[inline] + pure fn mul_f(&&value:float) -> Vec4 { + Vec4(self[0] * value, self[1] * value, self[2] * value, self[3] * value) } - #[inline(always)] - pure fn div_f(&&value:float) -> vec4 { - vec4(self[0] / value, + #[inline] + pure fn div_f(&&value:float) -> Vec4 { + Vec4(self[0] / value, self[1] / value, self[2] / value, self[3] / value) } - #[inline(always)] - pure fn add_v(&&other: vec4) -> vec4{ - vec4(self[0] + other[0], + #[inline] + pure fn add_v(&&other: Vec4) -> Vec4{ + Vec4(self[0] + other[0], self[1] + other[1], self[2] + other[2], self[3] + other[3]) } - #[inline(always)] - pure fn sub_v(&&other: vec4) -> vec4{ - vec4(self[0] - other[0], + #[inline] + pure fn sub_v(&&other: Vec4) -> Vec4{ + Vec4(self[0] - other[0], self[1] - other[1], self[2] - other[2], self[3] - other[3]) } - #[inline(always)] - pure fn dot(&&other:vec4) -> float { + #[inline] + pure fn dot(&&other:Vec4) -> float { self[0] * other[0] + self[1] * other[1] + self[2] * other[2] + self[3] * other[3] } - #[inline(always)] - pure fn exact_eq(&&other:vec4) -> bool { + #[inline] + pure fn exact_eq(&&other:Vec4) -> bool { self[0] == other[0] && self[1] == other[1] && self[2] == other[2] && self[3] == other[3] } - #[inline(always)] - pure fn fuzzy_eq(&&other: vec4) -> bool { + #[inline] + pure fn fuzzy_eq(&&other: Vec4) -> bool { self[0].fuzzy_eq(&other[0]) && self[1].fuzzy_eq(&other[1]) && self[2].fuzzy_eq(&other[2]) && self[3].fuzzy_eq(&other[3]) } - #[inline(always)] - pure fn eq(&&other:vec4) -> bool { + #[inline] + pure fn eq(&&other:Vec4) -> bool { self.fuzzy_eq(other) } - #[inline(always)] + #[inline] pure fn magnitude2() -> float { self[0] * self[0] + self[1] * self[1] + @@ -571,52 +571,52 @@ impl vec4: Vector { self[3] * self[3] } - #[inline(always)] + #[inline] pure fn magnitude() -> float { self.magnitude2().sqrt() } - #[inline(always)] - pure fn normalize() -> vec4 { + #[inline] + pure fn normalize() -> Vec4 { let n = 1f / self.magnitude(); return self.mul_f(n); } - #[inline(always)] - pure fn lerp(&&other:vec4, &&value:float) -> vec4 { + #[inline] + pure fn lerp(&&other:Vec4, &&value:float) -> Vec4 { self.add_v((other.sub_v(self)).mul_f(value)) } - #[inline(always)] - pure fn abs() -> vec4 { - vec4(self[0].abs(), + #[inline] + pure fn abs() -> Vec4 { + Vec4(self[0].abs(), self[1].abs(), self[2].abs(), self[3].abs()) } - #[inline(always)] - pure fn min(&&other:vec4) -> vec4 { - vec4(min(self[0], other[0]), + #[inline] + pure fn min(&&other:Vec4) -> Vec4 { + Vec4(min(self[0], other[0]), min(self[1], other[1]), min(self[2], other[2]), min(self[3], other[3])) } - #[inline(always)] - pure fn max(&&other:vec4) -> vec4 { - vec4(max(self[0], other[0]), + #[inline] + pure fn max(&&other:Vec4) -> Vec4 { + Vec4(max(self[0], other[0]), max(self[1], other[1]), max(self[2], other[2]), max(self[3], other[3])) } - #[inline(always)] static pure fn zero() -> vec4 { vec4(1f, 1f, 1f, 1f) } - #[inline(always)] static pure fn identity() -> vec4 { vec4(1f, 1f, 1f, 1f) } + #[inline] static pure fn zero() -> Vec4 { Vec4(1f, 1f, 1f, 1f) } + #[inline] static pure fn identity() -> Vec4 { Vec4(1f, 1f, 1f, 1f) } } -impl vec4: ToStr { +impl Vec4: ToStr { fn to_str() -> ~str { - fmt!("vec4[ %f, %f, %f, %f ]", self[0], self[1], self[2], self[3]) + fmt!("Vec4[ %f, %f, %f, %f ]", self[0], self[1], self[2], self[3]) } } \ No newline at end of file diff --git a/test/test_mat.rs b/test/test_mat.rs index da70330..3f7df27 100644 --- a/test/test_mat.rs +++ b/test/test_mat.rs @@ -1,48 +1,48 @@ -import omath::mat::*; -import omath::vec::*; +use omath::mat::*; +use omath::vec::*; // TODO #[test] -fn test_mat2() { - let a = mat2 { data: [ vec2 { data: [ 1f, 3f ] }, - vec2 { data: [ 2f, 4f ] } ] }; - let b = mat2 { data: [ vec2 { data: [ 2f, 4f ] }, - vec2 { data: [ 3f, 5f ] } ] }; - let v1 = vec2(1f, 2f); +fn test_Mat2() { + let a = Mat2 { data: [ Vec2 { data: [ 1f, 3f ] }, + Vec2 { data: [ 2f, 4f ] } ] }; + let b = Mat2 { data: [ Vec2 { data: [ 2f, 4f ] }, + Vec2 { data: [ 3f, 5f ] } ] }; + let v1 = Vec2(1f, 2f); let f1 = 0.5f; - assert a == mat2(1f, 3f, + assert a == Mat2(1f, 3f, 2f, 4f); - assert a == mat2_v(vec2(1f, 3f), - vec2(2f, 4f)); + assert a == mat2_v(Vec2(1f, 3f), + Vec2(2f, 4f)); - assert a[0] == vec2(1f, 3f); - assert a[1] == vec2(2f, 4f); + assert a[0] == Vec2(1f, 3f); + assert a[1] == Vec2(2f, 4f); - assert a.row(0) == vec2(1f, 2f); - assert a.row(1) == vec2(3f, 4f); + assert a.row(0) == Vec2(1f, 2f); + assert a.row(1) == Vec2(3f, 4f); - assert a.col(0) == vec2(1f, 3f); - assert a.col(1) == vec2(2f, 4f); + assert a.col(0) == Vec2(1f, 3f); + assert a.col(1) == Vec2(2f, 4f); - assert a.neg() == mat2(-1f, -3f, + assert a.neg() == Mat2(-1f, -3f, -2f, -4f); assert -a == a.neg(); - assert a.mul_f(f1) == mat2(0.5f, 1.5f, + assert a.mul_f(f1) == Mat2(0.5f, 1.5f, 1.0f, 2.0f); - assert a.mul_v(v1) == vec2(5f, 11f); + assert a.mul_v(v1) == Vec2(5f, 11f); - assert a.add_m(b) == mat2(3f, 7f, + assert a.add_m(b) == Mat2(3f, 7f, 5f, 9f); - assert a.sub_m(b) == mat2(-1f, -1f, + assert a.sub_m(b) == Mat2(-1f, -1f, -1f, -1f); - assert a.mul_m(b) == mat2(10.0, 22.0, + assert a.mul_m(b) == Mat2(10.0, 22.0, 13.0, 29.0); - assert a.transpose() == mat2(1f, 2f, + assert a.transpose() == Mat2(1f, 2f, 3f, 4f); // exact_eq @@ -59,7 +59,7 @@ fn test_mat2() { assert !a.is_diagonal(); assert a.is_rotated(); - let c = mat2(2f, 1f, + let c = Mat2(2f, 1f, 1f, 2f); assert !c.is_identity(); assert c.is_symmetric(); @@ -68,57 +68,57 @@ fn test_mat2() { } #[test] -fn test_mat3() { - let a = mat3 { data: [ vec3 { data: [ 1f, 4f, 7f ] }, - vec3 { data: [ 2f, 5f, 8f ] }, - vec3 { data: [ 3f, 6f, 9f ] } ] }; - let b = mat3 { data: [ vec3 { data: [ 2f, 5f, 8f ] }, - vec3 { data: [ 3f, 6f, 9f ] }, - vec3 { data: [ 4f, 7f, 10f ] } ] }; - let v1 = vec3(1f, 2f, 3f); +fn test_Mat3() { + let a = Mat3 { data: [ Vec3 { data: [ 1f, 4f, 7f ] }, + Vec3 { data: [ 2f, 5f, 8f ] }, + Vec3 { data: [ 3f, 6f, 9f ] } ] }; + let b = Mat3 { data: [ Vec3 { data: [ 2f, 5f, 8f ] }, + Vec3 { data: [ 3f, 6f, 9f ] }, + Vec3 { data: [ 4f, 7f, 10f ] } ] }; + let v1 = Vec3(1f, 2f, 3f); let f1 = 0.5f; - assert a == mat3(1f, 4f, 7f, + assert a == Mat3(1f, 4f, 7f, 2f, 5f, 8f, 3f, 6f, 9f); - assert a == mat3_v(vec3(1f, 4f, 7f), - vec3(2f, 5f, 8f), - vec3(3f, 6f, 9f)); + assert a == mat3_v(Vec3(1f, 4f, 7f), + Vec3(2f, 5f, 8f), + Vec3(3f, 6f, 9f)); - assert a[0] == vec3(1f, 4f, 7f); - assert a[1] == vec3(2f, 5f, 8f); - assert a[2] == vec3(3f, 6f, 9f); + assert a[0] == Vec3(1f, 4f, 7f); + assert a[1] == Vec3(2f, 5f, 8f); + assert a[2] == Vec3(3f, 6f, 9f); - assert a.row(0) == vec3(1f, 2f, 3f); - assert a.row(1) == vec3(4f, 5f, 6f); - assert a.row(2) == vec3(7f, 8f, 9f); + assert a.row(0) == Vec3(1f, 2f, 3f); + assert a.row(1) == Vec3(4f, 5f, 6f); + assert a.row(2) == Vec3(7f, 8f, 9f); - assert a.col(0) == vec3(1f, 4f, 7f); - assert a.col(1) == vec3(2f, 5f, 8f); - assert a.col(2) == vec3(3f, 6f, 9f); + assert a.col(0) == Vec3(1f, 4f, 7f); + assert a.col(1) == Vec3(2f, 5f, 8f); + assert a.col(2) == Vec3(3f, 6f, 9f); - assert a.neg() == mat3(-1f, -4f, -7f, + assert a.neg() == Mat3(-1f, -4f, -7f, -2f, -5f, -8f, -3f, -6f, -9f); assert -a == a.neg(); - assert a.mul_f(f1) == mat3(0.5f, 2.0f, 3.5f, + assert a.mul_f(f1) == Mat3(0.5f, 2.0f, 3.5f, 1.0f, 2.5f, 4.0f, 1.5f, 3.0f, 4.5f); - assert a.mul_v(v1) == vec3(14f, 32f, 50f); + assert a.mul_v(v1) == Vec3(14f, 32f, 50f); - assert a.add_m(b) == mat3(3f, 9f, 15f, + assert a.add_m(b) == Mat3(3f, 9f, 15f, 5f, 11f, 17f, 7f, 13f, 19f); - assert a.sub_m(b) == mat3(-1f, -1f, -1f, + assert a.sub_m(b) == Mat3(-1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f); - assert a.mul_m(b) == mat3(36f, 81f, 126f, + assert a.mul_m(b) == Mat3(36f, 81f, 126f, 42f, 96f, 150f, 48f, 111f, 174f); - assert a.transpose() == mat3(1f, 2f, 3f, + assert a.transpose() == Mat3(1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f, 9f); @@ -136,7 +136,7 @@ fn test_mat3() { assert !a.is_diagonal(); assert a.is_rotated(); - let c = mat3(3f, 2f, 1f, + let c = Mat3(3f, 2f, 1f, 2f, 3f, 2f, 1f, 2f, 3f); assert !c.is_identity(); @@ -144,78 +144,78 @@ fn test_mat3() { assert !c.is_diagonal(); assert c.is_rotated(); - assert a.to_mat4() == mat4(1f, 4f, 7f, 0f, + assert a.to_Mat4() == Mat4(1f, 4f, 7f, 0f, 2f, 5f, 8f, 0f, 3f, 6f, 9f, 0f, 0f, 0f, 0f, 1f); - // to_quaternion + // to_Quaternion } #[test] -fn test_mat4() { - let a = mat4 { data: [ vec4 { data: [ 1f, 5f, 9f, 13f ] }, - vec4 { data: [ 2f, 6f, 10f, 14f ] }, - vec4 { data: [ 3f, 7f, 11f, 15f ] }, - vec4 { data: [ 4f, 8f, 12f, 16f ] } ] }; - let b = mat4 { data: [ vec4 { data: [ 2f, 6f, 10f, 14f ] }, - vec4 { data: [ 3f, 7f, 11f, 15f ] }, - vec4 { data: [ 4f, 8f, 12f, 16f ] }, - vec4 { data: [ 5f, 9f, 13f, 17f ] } ] }; - let v1 = vec4(1f, 2f, 3f, 4f); +fn test_Mat4() { + let a = Mat4 { data: [ Vec4 { data: [ 1f, 5f, 9f, 13f ] }, + Vec4 { data: [ 2f, 6f, 10f, 14f ] }, + Vec4 { data: [ 3f, 7f, 11f, 15f ] }, + Vec4 { data: [ 4f, 8f, 12f, 16f ] } ] }; + let b = Mat4 { data: [ Vec4 { data: [ 2f, 6f, 10f, 14f ] }, + Vec4 { data: [ 3f, 7f, 11f, 15f ] }, + Vec4 { data: [ 4f, 8f, 12f, 16f ] }, + Vec4 { data: [ 5f, 9f, 13f, 17f ] } ] }; + let v1 = Vec4(1f, 2f, 3f, 4f); let f1 = 0.5f; - assert a == mat4(1f, 5f, 9f, 13f, + assert a == Mat4(1f, 5f, 9f, 13f, 2f, 6f, 10f, 14f, 3f, 7f, 11f, 15f, 4f, 8f, 12f, 16f); - assert a == mat4_v(vec4(1f, 5f, 9f, 13f), - vec4(2f, 6f, 10f, 14f), - vec4(3f, 7f, 11f, 15f), - vec4(4f, 8f, 12f, 16f)); + assert a == mat4_v(Vec4(1f, 5f, 9f, 13f), + Vec4(2f, 6f, 10f, 14f), + Vec4(3f, 7f, 11f, 15f), + Vec4(4f, 8f, 12f, 16f)); - assert a[0] == vec4(1f, 5f, 9f, 13f); - assert a[1] == vec4(2f, 6f, 10f, 14f); - assert a[2] == vec4(3f, 7f, 11f, 15f); - assert a[3] == vec4(4f, 8f, 12f, 16f); + assert a[0] == Vec4(1f, 5f, 9f, 13f); + assert a[1] == Vec4(2f, 6f, 10f, 14f); + assert a[2] == Vec4(3f, 7f, 11f, 15f); + assert a[3] == Vec4(4f, 8f, 12f, 16f); - assert a.row(0) == vec4( 1f, 2f, 3f, 4f); - assert a.row(1) == vec4( 5f, 6f, 7f, 8f); - assert a.row(2) == vec4( 9f, 10f, 11f, 12f); - assert a.row(3) == vec4(13f, 14f, 15f, 16f); + assert a.row(0) == Vec4( 1f, 2f, 3f, 4f); + assert a.row(1) == Vec4( 5f, 6f, 7f, 8f); + assert a.row(2) == Vec4( 9f, 10f, 11f, 12f); + assert a.row(3) == Vec4(13f, 14f, 15f, 16f); - assert a.col(0) == vec4(1f, 5f, 9f, 13f); - assert a.col(1) == vec4(2f, 6f, 10f, 14f); - assert a.col(2) == vec4(3f, 7f, 11f, 15f); - assert a.col(3) == vec4(4f, 8f, 12f, 16f); + assert a.col(0) == Vec4(1f, 5f, 9f, 13f); + assert a.col(1) == Vec4(2f, 6f, 10f, 14f); + assert a.col(2) == Vec4(3f, 7f, 11f, 15f); + assert a.col(3) == Vec4(4f, 8f, 12f, 16f); - assert a.neg() == mat4(-1f, -5f, -9f, -13f, + assert a.neg() == Mat4(-1f, -5f, -9f, -13f, -2f, -6f, -10f, -14f, -3f, -7f, -11f, -15f, -4f, -8f, -12f, -16f); assert -a == a.neg(); - assert a.mul_f(f1) == mat4(0.5f, 2.5f, 4.5f, 6.5f, + assert a.mul_f(f1) == Mat4(0.5f, 2.5f, 4.5f, 6.5f, 1.0f, 3.0f, 5.0f, 7.0f, 1.5f, 3.5f, 5.5f, 7.5f, 2.0f, 4.0f, 6.0f, 8.0f); - assert a.mul_v(v1) == vec4(30.0, 70.0, 110.0, 150.0); + assert a.mul_v(v1) == Vec4(30.0, 70.0, 110.0, 150.0); - assert a.add_m(b) == mat4(3f, 11f, 19f, 27f, + assert a.add_m(b) == Mat4(3f, 11f, 19f, 27f, 5f, 13f, 21f, 29f, 7f, 15f, 23f, 31f, 9f, 17f, 25f, 33f); - assert a.sub_m(b) == mat4(-1f, -1f, -1f, -1f, + assert a.sub_m(b) == Mat4(-1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f, -1f); - assert a.mul_m(b) == mat4(100f, 228f, 356f, 484f, + assert a.mul_m(b) == Mat4(100f, 228f, 356f, 484f, 110f, 254f, 398f, 542f, 120f, 280f, 440f, 600f, 130f, 306f, 482f, 658f); - assert a.transpose() == mat4( 1f, 2f, 3f, 4f, + assert a.transpose() == Mat4( 1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f, 9f, 10f, 11f, 12f, 13f, 14f, 15f, 16f); @@ -234,7 +234,7 @@ fn test_mat4() { assert !a.is_diagonal(); assert a.is_rotated(); - let c = mat4(4f, 3f, 2f, 1f, + let c = Mat4(4f, 3f, 2f, 1f, 3f, 4f, 3f, 2f, 2f, 3f, 4f, 3f, 1f, 2f, 3f, 4f); diff --git a/test/test_omath.rc b/test/test_omath.rc index 312257e..c8002aa 100644 --- a/test/test_omath.rc +++ b/test/test_omath.rc @@ -5,8 +5,8 @@ #[comment = "Unittests for omath"]; #[crate_type = "unittests"]; -use std; -use omath; +extern mod std; +extern mod omath; mod test_mat; mod test_math; diff --git a/test/test_quat.rs b/test/test_quat.rs index 13442a2..5a8f3c4 100644 --- a/test/test_quat.rs +++ b/test/test_quat.rs @@ -1,20 +1,20 @@ -import omath::mat::*; -import omath::quat::*; -import omath::vec::*; +use omath::mat::*; +use omath::quat::*; +use omath::vec::*; // TODO #[test] -fn test_quat() { - let a = quat { data: [ 1f, 2f, 3f, 4f ] }; - // let b = quat { data: [ 5f, 6f, 7f, 8f ] }; +fn test_Quat() { + let a = Quat { data: [ 1f, 2f, 3f, 4f ] }; + // let b = Quat { data: [ 5f, 6f, 7f, 8f ] }; // let f1 = 1.5f; // let f2 = 0.5f; - assert a == quat(1f, 2f, 3f, 4f); + 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[0] == 1f; assert a[1] == 2f; diff --git a/test/test_vec.rs b/test/test_vec.rs index 094d0f3..1992f94 100644 --- a/test/test_vec.rs +++ b/test/test_vec.rs @@ -1,39 +1,39 @@ -import std::cmp::FuzzyEq; -import omath::vec::*; +use std::cmp::FuzzyEq; +use omath::vec::*; // TODO #[test] -fn test_vec2() { - // assert vec2::dim == 2; +fn test_Vec2() { + // assert Vec2::dim == 2; - let a = vec2 { data: [ 1f, 2f ] }; - let b = vec2 { data: [ 3f, 4f ] }; + let a = Vec2 { data: [ 1f, 2f ] }; + let b = Vec2 { data: [ 3f, 4f ] }; let f1 = 1.5f; let f2 = 0.5f; - assert a == vec2(1f, 2f); + 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[0] == 1f; assert a[1] == 2f; assert a.x() == 1f; assert a.y() == 2f; - assert -a == vec2(-1f, -2f); - assert a.neg() == vec2(-1f, -2f); + assert -a == Vec2(-1f, -2f); + assert a.neg() == Vec2(-1f, -2f); - assert a.add_f(f1) == vec2( 2.5f, 3.5f); - assert a.sub_f(f1) == vec2(-0.5f, 0.5f); - assert a.mul_f(f1) == vec2( 1.5f, 3.0f); - assert a.div_f(f2) == vec2( 2.0f, 4.0f); + assert a.add_f(f1) == Vec2( 2.5f, 3.5f); + assert a.sub_f(f1) == Vec2(-0.5f, 0.5f); + assert a.mul_f(f1) == Vec2( 1.5f, 3.0f); + assert a.div_f(f2) == Vec2( 2.0f, 4.0f); - assert a.add_v(b) == vec2( 4f, 6f); - assert a.sub_v(b) == vec2(-2f, -2f); + assert a.add_v(b) == Vec2( 4f, 6f); + assert a.sub_v(b) == Vec2(-2f, -2f); // exact_eq // fuzzy_eq @@ -42,32 +42,32 @@ fn test_vec2() { assert a.magnitude2().fuzzy_eq(&5f); assert a.magnitude().fuzzy_eq(&2.236068f); - let c = vec2(-2.0f, -1.0f); - let d = vec2( 1.0f, 0.0f); + let c = Vec2(-2.0f, -1.0f); + let d = Vec2( 1.0f, 0.0f); let f3 = 0.75f; - assert c.lerp(d, f3) == vec2(0.250f, -0.250f); - assert c.abs() == vec2( 2.0f, 1.0f); - assert c.min(d) == vec2(-2.0f, -1.0f); - assert c.max(d) == vec2( 1.0f, 0.0f); + assert c.lerp(d, f3) == Vec2(0.250f, -0.250f); + assert c.abs() == Vec2( 2.0f, 1.0f); + assert c.min(d) == Vec2(-2.0f, -1.0f); + assert c.max(d) == Vec2( 1.0f, 0.0f); } #[test] -fn test_vec3() { - // assert vec3::dim == 3; +fn test_Vec3() { + // assert Vec3::dim == 3; - let a = vec3 { data: [ 1f, 2f, 3f ] }; - let b = vec3 { data: [ 4f, 5f, 6f ] }; + let a = Vec3 { data: [ 1f, 2f, 3f ] }; + let b = Vec3 { data: [ 4f, 5f, 6f ] }; let f1 = 1.5f; let f2 = 0.5f; - assert a == vec3(1f, 2f, 3f); + 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[0] == 1f; assert a[1] == 2f; @@ -76,18 +76,18 @@ fn test_vec3() { assert a.y() == 2f; assert a.z() == 3f; - assert a.cross(b) == vec3(-3f, 6f, -3f); + assert a.cross(b) == Vec3(-3f, 6f, -3f); - assert -a == vec3(-1f, -2f, -3f); - assert a.neg() == vec3(-1f, -2f, -3f); + assert -a == Vec3(-1f, -2f, -3f); + assert a.neg() == Vec3(-1f, -2f, -3f); - assert a.add_f(f1) == vec3( 2.5f, 3.5f, 4.5f); - assert a.sub_f(f1) == vec3(-0.5f, 0.5f, 1.5f); - assert a.mul_f(f1) == vec3( 1.5f, 3.0f, 4.5f); - assert a.div_f(f2) == vec3( 2.0f, 4.0f, 6.0f); + assert a.add_f(f1) == Vec3( 2.5f, 3.5f, 4.5f); + assert a.sub_f(f1) == Vec3(-0.5f, 0.5f, 1.5f); + assert a.mul_f(f1) == Vec3( 1.5f, 3.0f, 4.5f); + assert a.div_f(f2) == Vec3( 2.0f, 4.0f, 6.0f); - assert a.add_v(b) == vec3( 5f, 7f, 9f); - assert a.sub_v(b) == vec3(-3f, -3f, -3f); + assert a.add_v(b) == Vec3( 5f, 7f, 9f); + assert a.sub_v(b) == Vec3(-3f, -3f, -3f); // exact_eq // fuzzy_eq @@ -96,33 +96,33 @@ fn test_vec3() { assert a.magnitude2().fuzzy_eq(&14f); assert a.magnitude().fuzzy_eq(&3.74165738677f); - let c = vec3(-2.0f, -1.0f, 1.0f); - let d = vec3( 1.0f, 0.0f, 0.5f); + let c = Vec3(-2.0f, -1.0f, 1.0f); + let d = Vec3( 1.0f, 0.0f, 0.5f); let f3 = 0.75f; - assert c.lerp(d, f3) == vec3(0.250f, -0.250f, 0.625f); - assert c.abs() == vec3( 2.0f, 1.0f, 1.0f); - assert c.min(d) == vec3(-2.0f, -1.0f, 0.5f); - assert c.max(d) == vec3( 1.0f, 0.0f, 1.0f); + assert c.lerp(d, f3) == Vec3(0.250f, -0.250f, 0.625f); + assert c.abs() == Vec3( 2.0f, 1.0f, 1.0f); + assert c.min(d) == Vec3(-2.0f, -1.0f, 0.5f); + assert c.max(d) == Vec3( 1.0f, 0.0f, 1.0f); } #[test] -fn test_vec4() { - // assert vec4::dim == 4; +fn test_Vec4() { + // assert Vec4::dim == 4; - let a = vec4 { data: [ 1f, 2f, 3f, 4f ] }; - let b = vec4 { data: [ 5f, 6f, 7f, 8f ] }; + let a = Vec4 { data: [ 1f, 2f, 3f, 4f ] }; + let b = Vec4 { data: [ 5f, 6f, 7f, 8f ] }; let f1 = 1.5f; let f2 = 0.5f; - assert a == vec4(1f, 2f, 3f, 4f); + 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[0] == 1f; assert a[1] == 2f; @@ -133,16 +133,16 @@ fn test_vec4() { assert a.z() == 3f; assert a.w() == 4f; - assert -a == vec4(-1f, -2f, -3f, -4f); - assert a.neg() == vec4(-1f, -2f, -3f, -4f); + assert -a == Vec4(-1f, -2f, -3f, -4f); + assert a.neg() == Vec4(-1f, -2f, -3f, -4f); - assert a.add_f(f1) == vec4( 2.5f, 3.5f, 4.5f, 5.5f); - assert a.sub_f(f1) == vec4(-0.5f, 0.5f, 1.5f, 2.5f); - assert a.mul_f(f1) == vec4( 1.5f, 3.0f, 4.5f, 6.0f); - assert a.div_f(f2) == vec4( 2.0f, 4.0f, 6.0f, 8.0f); + assert a.add_f(f1) == Vec4( 2.5f, 3.5f, 4.5f, 5.5f); + assert a.sub_f(f1) == Vec4(-0.5f, 0.5f, 1.5f, 2.5f); + assert a.mul_f(f1) == Vec4( 1.5f, 3.0f, 4.5f, 6.0f); + assert a.div_f(f2) == Vec4( 2.0f, 4.0f, 6.0f, 8.0f); - assert a.add_v(b) == vec4( 6f, 8f, 10f, 12f); - assert a.sub_v(b) == vec4(-4f, -4f, -4f, -4f); + assert a.add_v(b) == Vec4( 6f, 8f, 10f, 12f); + assert a.sub_v(b) == Vec4(-4f, -4f, -4f, -4f); assert a.dot(b) == 70f; @@ -153,12 +153,12 @@ fn test_vec4() { assert a.magnitude2().fuzzy_eq(&30f); assert a.magnitude().fuzzy_eq(&5.477226f); - let c = vec4(-2.0f, -1.0f, 1.0f, 2.0f); - let d = vec4( 1.0f, 0.0f, 0.5f, 1.0f); + let c = Vec4(-2.0f, -1.0f, 1.0f, 2.0f); + let d = Vec4( 1.0f, 0.0f, 0.5f, 1.0f); let f3 = 0.75f; - assert c.lerp(d, f3) == vec4(0.250f, -0.250f, 0.625f, 1.250f); - assert c.abs() == vec4( 2.0f, 1.0f, 1.0f, 2.0f); - assert c.min(d) == vec4(-2.0f, -1.0f, 0.5f, 1.0f); - assert c.max(d) == vec4( 1.0f, 0.0f, 1.0f, 2.0f); + assert c.lerp(d, f3) == Vec4(0.250f, -0.250f, 0.625f, 1.250f); + assert c.abs() == Vec4( 2.0f, 1.0f, 1.0f, 2.0f); + assert c.min(d) == Vec4(-2.0f, -1.0f, 0.5f, 1.0f); + assert c.max(d) == Vec4( 1.0f, 0.0f, 1.0f, 2.0f); } \ No newline at end of file