Move relational vector traits to vec modules
This commit is contained in:
Brendan Zabarauskas
parent
ff336f0791
commit
5eff2e4992
8 changed files with 264 additions and 524 deletions
|
|
@ -1,218 +0,0 @@
|
|||
/**
|
||||
* Vector Relational Functions
|
||||
*
|
||||
* This module corresponds to Section 8.7 of the [GLSL 4.30.6 specification]
|
||||
* (http://www.opengl.org/registry/doc/GLSLangSpec.4.30.6.pdf).
|
||||
*/
|
||||
|
||||
use core::cmp::{Eq, Ord};
|
||||
use vec::{Vector, Vec2, Vec3, Vec4};
|
||||
|
||||
pub trait RelVector<BVec> {
|
||||
pure fn less_than(&self, other: &self) -> BVec;
|
||||
pure fn less_than_equal(&self, other: &self) -> BVec;
|
||||
pure fn greater_than(&self, other: &self) -> BVec;
|
||||
pure fn greater_than_equal(&self, other: &self) -> BVec;
|
||||
pure fn equal(&self, other: &self) -> BVec;
|
||||
pure fn not_equal(&self, other: &self) -> BVec;
|
||||
}
|
||||
|
||||
#[inline(always)] pub pure fn less_than <T:RelVector<BV>, BV>(x: &T, y: &T) -> BV { x.less_than(y) }
|
||||
#[inline(always)] pub pure fn less_than_equal <T:RelVector<BV>, BV>(x: &T, y: &T) -> BV { x.less_than_equal(y) }
|
||||
#[inline(always)] pub pure fn greater_than <T:RelVector<BV>, BV>(x: &T, y: &T) -> BV { x.greater_than(y) }
|
||||
#[inline(always)] pub pure fn greater_than_equal<T:RelVector<BV>, BV>(x: &T, y: &T) -> BV { x.greater_than_equal(y) }
|
||||
#[inline(always)] pub pure fn equal <T:RelVector<BV>, BV>(x: &T, y: &T) -> BV { x.equal(y) }
|
||||
#[inline(always)] pub pure fn not_equal <T:RelVector<BV>, BV>(x: &T, y: &T) -> BV { x.not_equal(y) }
|
||||
|
||||
pub impl<T:Copy Ord Eq> Vec2<T>: RelVector<Vec2<bool>> {
|
||||
#[inline(always)]
|
||||
pure fn less_than(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] < other[0],
|
||||
self[1] < other[1])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn less_than_equal(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] <= other[0],
|
||||
self[1] <= other[1])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] > other[0],
|
||||
self[1] > other[1])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than_equal(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] >= other[0],
|
||||
self[1] >= other[1])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn equal(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] == other[0],
|
||||
self[1] == other[1])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not_equal(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] != other[0],
|
||||
self[1] != other[1])
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<T:Copy Ord Eq> Vec3<T>: RelVector<Vec3<bool>> {
|
||||
#[inline(always)]
|
||||
pure fn less_than(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] < other[0],
|
||||
self[1] < other[1],
|
||||
self[2] < other[2])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn less_than_equal(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] <= other[0],
|
||||
self[1] <= other[1],
|
||||
self[2] <= other[2])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] > other[0],
|
||||
self[1] > other[1],
|
||||
self[2] > other[2])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than_equal(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] >= other[0],
|
||||
self[1] >= other[1],
|
||||
self[2] >= other[2])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn equal(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] == other[0],
|
||||
self[1] == other[1],
|
||||
self[2] == other[2])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not_equal(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] != other[0],
|
||||
self[1] != other[1],
|
||||
self[2] != other[2])
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<T:Copy Ord Eq> Vec4<T>: RelVector<Vec4<bool>> {
|
||||
#[inline(always)]
|
||||
pure fn less_than(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] < other[0],
|
||||
self[1] < other[1],
|
||||
self[2] < other[2],
|
||||
self[3] < other[3])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn less_than_equal(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] <= other[0],
|
||||
self[1] <= other[1],
|
||||
self[2] <= other[2],
|
||||
self[3] <= other[3])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] > other[0],
|
||||
self[1] > other[1],
|
||||
self[2] > other[2],
|
||||
self[3] > other[3])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than_equal(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] >= other[0],
|
||||
self[1] >= other[1],
|
||||
self[2] >= other[2],
|
||||
self[3] >= other[3])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn equal(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] == other[0],
|
||||
self[1] == other[1],
|
||||
self[2] == other[2],
|
||||
self[3] == other[3])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not_equal(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] != other[0],
|
||||
self[1] != other[1],
|
||||
self[2] != other[2],
|
||||
self[3] != other[3])
|
||||
}
|
||||
}
|
||||
|
||||
pub trait BooleanVector: Vector<bool> {
|
||||
pure fn any(&self) -> bool;
|
||||
pure fn all(&self) -> bool;
|
||||
pure fn not(&self) -> self;
|
||||
}
|
||||
|
||||
#[inline(always)] pub pure fn any<T:BooleanVector>(x: &T) -> bool { x.any() }
|
||||
#[inline(always)] pub pure fn all<T:BooleanVector>(x: &T) -> bool { x.all() }
|
||||
#[inline(always)] pub pure fn not<T:BooleanVector>(x: &T) -> T { x.not() }
|
||||
|
||||
pub impl Vec2<bool>: BooleanVector {
|
||||
#[inline(always)]
|
||||
pure fn any(&self) -> bool {
|
||||
self[0] || self[1]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn all(&self) -> bool {
|
||||
self[0] && self[1]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not(&self) -> Vec2<bool> {
|
||||
Vec2::new(!self[0], !self[1])
|
||||
}
|
||||
}
|
||||
|
||||
pub impl Vec3<bool>: BooleanVector {
|
||||
#[inline(always)]
|
||||
pure fn any(&self) -> bool {
|
||||
self[0] || self[1] || self[2]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn all(&self) -> bool {
|
||||
self[0] && self[1] && self[2]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not(&self) -> Vec3<bool> {
|
||||
Vec3::new(!self[0], !self[1], !self[2])
|
||||
}
|
||||
}
|
||||
|
||||
pub impl Vec4<bool>: BooleanVector {
|
||||
#[inline(always)]
|
||||
pure fn any(&self) -> bool {
|
||||
self[0] || self[1] || self[2] || self[3]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn all(&self) -> bool {
|
||||
self[0] && self[1] && self[2] && self[3]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not(&self) -> Vec4<bool> {
|
||||
Vec4::new(!self[0], !self[1], !self[2], !self[3])
|
||||
}
|
||||
}
|
||||
|
|
@ -1,231 +0,0 @@
|
|||
use funs::common::*;
|
||||
use angle::{Radians, Degrees};
|
||||
use vec::{Vec2, Vec3, Vec4};
|
||||
|
||||
#[test]
|
||||
fn test_abs() {
|
||||
assert 0.abs() == 0;
|
||||
assert 2.abs() == 2;
|
||||
assert (-2).abs() == 2;
|
||||
assert abs(&0) == 0;
|
||||
assert abs(&2) == 2;
|
||||
assert abs(&-2) == 2;
|
||||
|
||||
assert 0.0.abs() == 0.0;
|
||||
assert 2.5.abs() == 2.5;
|
||||
assert (-2.5).abs() == 2.5;
|
||||
assert abs(&0.0) == 0.0;
|
||||
assert abs(&2.5) == 2.5;
|
||||
assert abs(&-2.5) == 2.5;
|
||||
|
||||
assert Radians(0.0).abs() == Radians(0.0);
|
||||
assert Radians(2.5).abs() == Radians(2.5);
|
||||
assert (Radians(-2.5)).abs() == Radians(2.5);
|
||||
assert abs(&Radians(0.0)) == Radians(0.0);
|
||||
assert abs(&Radians(2.5)) == Radians(2.5);
|
||||
assert abs(&Radians(-2.5)) == Radians(2.5);
|
||||
|
||||
assert Degrees(0.0).abs() == Degrees(0.0);
|
||||
assert Degrees(2.5).abs() == Degrees(2.5);
|
||||
assert (Degrees(-2.5)).abs() == Degrees(2.5);
|
||||
assert abs(&Degrees(0.0)) == Degrees(0.0);
|
||||
assert abs(&Degrees(2.5)) == Degrees(2.5);
|
||||
assert abs(&Degrees(-2.5)) == Degrees(2.5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_sign() {
|
||||
assert 0.sign() == 0;
|
||||
assert 2.sign() == 1;
|
||||
assert (-2).sign() == -1;
|
||||
assert sign(&0) == 0;
|
||||
assert sign(&2) == 1;
|
||||
assert sign(&-2) == -1;
|
||||
|
||||
assert 0.0.sign() == 0.0;
|
||||
assert 2.5.sign() == 1.0;
|
||||
assert (-2.5).sign()== -1.0;
|
||||
assert sign(&0.0) == 0.0;
|
||||
assert sign(&2.5) == 1.0;
|
||||
assert sign(&-2.5) == -1.0;
|
||||
|
||||
assert Radians(0.0).sign() == Radians(0.0);
|
||||
assert Radians(2.5).sign() == Radians(1.0);
|
||||
assert (Radians(-2.5)).sign()== Radians(-1.0);
|
||||
assert sign(&Radians(0.0)) == Radians(0.0);
|
||||
assert sign(&Radians(2.5)) == Radians(1.0);
|
||||
assert sign(&Radians(-2.5)) == Radians(-1.0);
|
||||
|
||||
assert Degrees(0.0).sign() == Degrees(0.0);
|
||||
assert Degrees(2.5).sign() == Degrees(1.0);
|
||||
assert (Degrees(-2.5)).sign()== Degrees(-1.0);
|
||||
assert sign(&Degrees(0.0)) == Degrees(0.0);
|
||||
assert sign(&Degrees(2.5)) == Degrees(1.0);
|
||||
assert sign(&Degrees(-2.5)) == Degrees(-1.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_min() {
|
||||
assert 1u.min(&2u) == 1u;
|
||||
assert 1u8.min(&2u8) == 1u8;
|
||||
assert 1u16.min(&2u16) == 1u16;
|
||||
assert 1u32.min(&2u32) == 1u32;
|
||||
assert 1u64.min(&2u64) == 1u64;
|
||||
assert 1.min(&2) == 1;
|
||||
assert 1i8.min(&2i8) == 1i8;
|
||||
assert 1i16.min(&2i16) == 1i16;
|
||||
assert 1i32.min(&2i32) == 1i32;
|
||||
assert 1i64.min(&2i64) == 1i64;
|
||||
assert 1f.min(&2f) == 1f;
|
||||
assert 1f32.min(&2f32) == 1f32;
|
||||
assert 1f64.min(&2f64) == 1f64;
|
||||
|
||||
assert 2u.min(&1u) == 1u;
|
||||
assert 2u8.min(&1u8) == 1u8;
|
||||
assert 2u16.min(&1u16) == 1u16;
|
||||
assert 2u32.min(&1u32) == 1u32;
|
||||
assert 2u64.min(&1u64) == 1u64;
|
||||
assert 2.min(&1) == 1;
|
||||
assert 2i8.min(&1i8) == 1i8;
|
||||
assert 2i16.min(&1i16) == 1i16;
|
||||
assert 2i32.min(&1i32) == 1i32;
|
||||
assert 2i64.min(&1i64) == 1i64;
|
||||
assert 2f.min(&1f) == 1f;
|
||||
assert 2f32.min(&1f32) == 1f32;
|
||||
assert 2f64.min(&1f64) == 1f64;
|
||||
|
||||
assert min(&1u, &2u) == 1u;
|
||||
assert min(&1u8, &2u8) == 1u8;
|
||||
assert min(&1u16, &2u16) == 1u16;
|
||||
assert min(&1u32, &2u32) == 1u32;
|
||||
assert min(&1u64, &2u64) == 1u64;
|
||||
assert min(&1, &2) == 1;
|
||||
assert min(&1i8, &2i8) == 1i8;
|
||||
assert min(&1i16, &2i16) == 1i16;
|
||||
assert min(&1i32, &2i32) == 1i32;
|
||||
assert min(&1i64, &2i64) == 1i64;
|
||||
assert min(&1f, &2f) == 1f;
|
||||
assert min(&1f32, &2f32) == 1f32;
|
||||
assert min(&1f64, &2f64) == 1f64;
|
||||
|
||||
assert min(&2u, &1u) == 1u;
|
||||
assert min(&2u8, &1u8) == 1u8;
|
||||
assert min(&2u16, &1u16) == 1u16;
|
||||
assert min(&2u32, &1u32) == 1u32;
|
||||
assert min(&2u64, &1u64) == 1u64;
|
||||
assert min(&2, &1) == 1;
|
||||
assert min(&2i8, &1i8) == 1i8;
|
||||
assert min(&2i16, &1i16) == 1i16;
|
||||
assert min(&2i32, &1i32) == 1i32;
|
||||
assert min(&2i64, &1i64) == 1i64;
|
||||
assert min(&2f, &1f) == 1f;
|
||||
assert min(&2f32, &1f32) == 1f32;
|
||||
assert min(&2f64, &1f64) == 1f64;
|
||||
|
||||
assert Radians(1.0).min(&Radians(2.0)) == Radians(1.0);
|
||||
assert Radians(2.0).min(&Radians(1.0)) == Radians(1.0);
|
||||
assert min(&Radians(1.0), &Radians(2.0)) == Radians(1.0);
|
||||
assert min(&Radians(2.0), &Radians(1.0)) == Radians(1.0);
|
||||
|
||||
assert Degrees(1.0).min(&Degrees(2.0)) == Degrees(1.0);
|
||||
assert Degrees(2.0).min(&Degrees(1.0)) == Degrees(1.0);
|
||||
assert min(&Degrees(1.0), &Degrees(2.0)) == Degrees(1.0);
|
||||
assert min(&Degrees(2.0), &Degrees(1.0)) == Degrees(1.0);
|
||||
|
||||
assert min(&Vec2::new(1, 2), &Vec2::new(2, 1)) == Vec2::new(1, 1);
|
||||
assert min(&Vec3::new(1, 2, 3), &Vec3::new(3, 2, 1)) == Vec3::new(1, 2, 1);
|
||||
assert min(&Vec4::new(1, 2, 3, 4), &Vec4::new(4, 3, 2, 1)) == Vec4::new(1, 2, 2, 1);
|
||||
|
||||
assert min(&Vec2::new(2, 1), &Vec2::new(1, 2)) == Vec2::new(1, 1);
|
||||
assert min(&Vec3::new(3, 2, 1), &Vec3::new(1, 2, 3)) == Vec3::new(1, 2, 1);
|
||||
assert min(&Vec4::new(4, 3, 2, 1), &Vec4::new(1, 2, 3, 4)) == Vec4::new(1, 2, 2, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_max() {
|
||||
assert 1u.max(&2u) == 2u;
|
||||
assert 1u8.max(&2u8) == 2u8;
|
||||
assert 1u16.max(&2u16) == 2u16;
|
||||
assert 1u32.max(&2u32) == 2u32;
|
||||
assert 1u64.max(&2u64) == 2u64;
|
||||
assert 1.max(&2) == 2;
|
||||
assert 1i8.max(&2i8) == 2i8;
|
||||
assert 1i16.max(&2i16) == 2i16;
|
||||
assert 1i32.max(&2i32) == 2i32;
|
||||
assert 1i64.max(&2i64) == 2i64;
|
||||
assert 1f.max(&2f) == 2f;
|
||||
assert 1f32.max(&2f32) == 2f32;
|
||||
assert 1f64.max(&2f64) == 2f64;
|
||||
|
||||
assert 2u.max(&1u) == 2u;
|
||||
assert 2u8.max(&1u8) == 2u8;
|
||||
assert 2u16.max(&1u16) == 2u16;
|
||||
assert 2u32.max(&1u32) == 2u32;
|
||||
assert 2u64.max(&1u64) == 2u64;
|
||||
assert 2.max(&1) == 2;
|
||||
assert 2i8.max(&1i8) == 2i8;
|
||||
assert 2i16.max(&1i16) == 2i16;
|
||||
assert 2i32.max(&1i32) == 2i32;
|
||||
assert 2i64.max(&1i64) == 2i64;
|
||||
assert 2f.max(&1f) == 2f;
|
||||
assert 2f32.max(&1f32) == 2f32;
|
||||
assert 2f64.max(&1f64) == 2f64;
|
||||
|
||||
|
||||
assert max(&1u, &2u) == 2u;
|
||||
assert max(&1u8, &2u8) == 2u8;
|
||||
assert max(&1u16, &2u16) == 2u16;
|
||||
assert max(&1u32, &2u32) == 2u32;
|
||||
assert max(&1u64, &2u64) == 2u64;
|
||||
assert max(&1, &2) == 2;
|
||||
assert max(&1i8, &2i8) == 2i8;
|
||||
assert max(&1i16, &2i16) == 2i16;
|
||||
assert max(&1i32, &2i32) == 2i32;
|
||||
assert max(&1i64, &2i64) == 2i64;
|
||||
assert max(&1f, &2f) == 2f;
|
||||
assert max(&1f32, &2f32) == 2f32;
|
||||
assert max(&1f64, &2f64) == 2f64;
|
||||
|
||||
|
||||
assert max(&2u, &1u) == 2u;
|
||||
assert max(&2u8, &1u8) == 2u8;
|
||||
assert max(&2u16, &1u16) == 2u16;
|
||||
assert max(&2u32, &1u32) == 2u32;
|
||||
assert max(&2u64, &1u64) == 2u64;
|
||||
assert max(&2, &1) == 2;
|
||||
assert max(&2i8, &1i8) == 2i8;
|
||||
assert max(&2i16, &1i16) == 2i16;
|
||||
assert max(&2i32, &1i32) == 2i32;
|
||||
assert max(&2i64, &1i64) == 2i64;
|
||||
assert max(&2f, &1f) == 2f;
|
||||
assert max(&2f32, &1f32) == 2f32;
|
||||
assert max(&2f64, &1f64) == 2f64;
|
||||
|
||||
assert Radians(1.0).max(&Radians(2.0)) == Radians(2.0);
|
||||
assert Radians(2.0).max(&Radians(1.0)) == Radians(2.0);
|
||||
assert max(&Radians(1.0), &Radians(2.0)) == Radians(2.0);
|
||||
assert max(&Radians(2.0), &Radians(1.0)) == Radians(2.0);
|
||||
|
||||
assert Degrees(1.0).max(&Degrees(2.0)) == Degrees(2.0);
|
||||
assert Degrees(2.0).max(&Degrees(1.0)) == Degrees(2.0);
|
||||
assert max(&Degrees(1.0), &Degrees(2.0)) == Degrees(2.0);
|
||||
assert max(&Degrees(2.0), &Degrees(1.0)) == Degrees(2.0);
|
||||
|
||||
assert max(&Vec2::new(1, 2), &Vec2::new(2, 1)) == Vec2::new(2, 2);
|
||||
assert max(&Vec3::new(1, 2, 3), &Vec3::new(3, 2, 1)) == Vec3::new(3, 2, 3);
|
||||
assert max(&Vec4::new(1, 2, 3, 4), &Vec4::new(4, 3, 2, 1)) == Vec4::new(4, 3, 3, 4);
|
||||
|
||||
assert max(&Vec2::new(2, 1), &Vec2::new(1, 2)) == Vec2::new(2, 2);
|
||||
assert max(&Vec3::new(3, 2, 1), &Vec3::new(1, 2, 3)) == Vec3::new(3, 2, 3);
|
||||
assert max(&Vec4::new(4, 3, 2, 1), &Vec4::new(1, 2, 3, 4)) == Vec4::new(4, 3, 3, 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_clamp() {
|
||||
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_clampv() {
|
||||
|
||||
}
|
||||
|
|
@ -1,72 +0,0 @@
|
|||
use funs::relational::*;
|
||||
use vec::*;
|
||||
|
||||
#[test]
|
||||
fn test_boolv2() {
|
||||
let tf = Vec2::new(true, false);
|
||||
let ff = Vec2::new(false, false);
|
||||
let tt = Vec2::new(true, true);
|
||||
|
||||
assert tf.any() == true;
|
||||
assert tf.all() == false;
|
||||
assert tf.not() == Vec2::new(false, true);
|
||||
|
||||
assert ff.any() == false;
|
||||
assert ff.all() == false;
|
||||
assert ff.not() == Vec2::new(true, true);
|
||||
|
||||
assert tt.any() == true;
|
||||
assert tt.all() == true;
|
||||
assert tt.not() == Vec2::new(false, false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_boolv3() {
|
||||
let tft = Vec3::new(true, false, true);
|
||||
let fff = Vec3::new(false, false, false);
|
||||
let ttt = Vec3::new(true, true, true);
|
||||
|
||||
assert tft.any() == true;
|
||||
assert tft.all() == false;
|
||||
assert tft.not() == Vec3::new(false, true, false);
|
||||
|
||||
assert fff.any() == false;
|
||||
assert fff.all() == false;
|
||||
assert fff.not() == Vec3::new(true, true, true);
|
||||
|
||||
assert ttt.any() == true;
|
||||
assert ttt.all() == true;
|
||||
assert ttt.not() == Vec3::new(false, false, false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_boolv4() {
|
||||
let tftf = Vec4::new(true, false, true, false);
|
||||
let ffff = Vec4::new(false, false, false, false);
|
||||
let tttt = Vec4::new(true, true, true, true);
|
||||
|
||||
assert tftf.any() == true;
|
||||
assert tftf.all() == false;
|
||||
assert tftf.not() == Vec4::new(false, true, false, true);
|
||||
|
||||
assert ffff.any() == false;
|
||||
assert ffff.all() == false;
|
||||
assert ffff.not() == Vec4::new(true, true, true, true);
|
||||
|
||||
assert tttt.any() == true;
|
||||
assert tttt.all() == true;
|
||||
assert tttt.not() == Vec4::new(false, false, false, false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_boolv_fns() {
|
||||
// let tf = Vec2::new(true, false);
|
||||
// let ftf = Vec3::new(false, true, false);
|
||||
// let tftf = Vec4::new(true, false, true, false);
|
||||
|
||||
// FIXME: These tests won't compile! D:
|
||||
|
||||
// assert any(&tf) == true;
|
||||
// assert all(&ftf) == false;
|
||||
// assert not(&tftf) == Vec4::new(false, true, false, true);
|
||||
}
|
||||
|
|
@ -110,6 +110,25 @@ fn test_Vec2_euclidean() {
|
|||
assert mut_c == c.lerp(&d, 0.75f);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_Vec2_boolean() {
|
||||
let tf = Vec2::new(true, false);
|
||||
let ff = Vec2::new(false, false);
|
||||
let tt = Vec2::new(true, true);
|
||||
|
||||
assert tf.any() == true;
|
||||
assert tf.all() == false;
|
||||
assert tf.not() == Vec2::new(false, true);
|
||||
|
||||
assert ff.any() == false;
|
||||
assert ff.all() == false;
|
||||
assert ff.not() == Vec2::new(true, true);
|
||||
|
||||
assert tt.any() == true;
|
||||
assert tt.all() == true;
|
||||
assert tt.not() == Vec2::new(false, false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_Vec3() {
|
||||
// assert Vec3::dim == 3;
|
||||
|
|
@ -229,6 +248,25 @@ fn test_Vec3_euclidean() {
|
|||
assert mut_c == c.lerp(&d, 0.75f);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_Vec3_boolean() {
|
||||
let tft = Vec3::new(true, false, true);
|
||||
let fff = Vec3::new(false, false, false);
|
||||
let ttt = Vec3::new(true, true, true);
|
||||
|
||||
assert tft.any() == true;
|
||||
assert tft.all() == false;
|
||||
assert tft.not() == Vec3::new(false, true, false);
|
||||
|
||||
assert fff.any() == false;
|
||||
assert fff.all() == false;
|
||||
assert fff.not() == Vec3::new(true, true, true);
|
||||
|
||||
assert ttt.any() == true;
|
||||
assert ttt.all() == true;
|
||||
assert ttt.not() == Vec3::new(false, false, false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_Vec4() {
|
||||
// assert Vec4::dim == 4;
|
||||
|
|
@ -346,4 +384,23 @@ fn test_Vec4_euclidean() {
|
|||
let mut mut_c = c;
|
||||
mut_c.lerp_self(&d, &0.75f);
|
||||
assert mut_c == c.lerp(&d, 0.75f);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_Vec4_boolean() {
|
||||
let tftf = Vec4::new(true, false, true, false);
|
||||
let ffff = Vec4::new(false, false, false, false);
|
||||
let tttt = Vec4::new(true, true, true, true);
|
||||
|
||||
assert tftf.any() == true;
|
||||
assert tftf.all() == false;
|
||||
assert tftf.not() == Vec4::new(false, true, false, true);
|
||||
|
||||
assert ffff.any() == false;
|
||||
assert ffff.all() == false;
|
||||
assert ffff.not() == Vec4::new(true, true, true, true);
|
||||
|
||||
assert tttt.any() == true;
|
||||
assert tttt.all() == true;
|
||||
assert tttt.not() == Vec4::new(false, false, false, false);
|
||||
}
|
||||
21
src/vec.rs
21
src/vec.rs
|
|
@ -304,4 +304,25 @@ pub trait MutableEuclideanVector<T>: MutableNumericVector<&self/T>
|
|||
* Linearly intoperlate the vector towards `other`
|
||||
*/
|
||||
fn lerp_self(&mut self, other: &self, amount: T);
|
||||
}
|
||||
|
||||
/**
|
||||
* Component-wise vector comparison methods
|
||||
*/
|
||||
pub trait RelationalVector<T, BoolVec>: Vector<T> {
|
||||
pure fn less_than(&self, other: &self) -> BoolVec;
|
||||
pure fn less_than_equal(&self, other: &self) -> BoolVec;
|
||||
pure fn greater_than(&self, other: &self) -> BoolVec;
|
||||
pure fn greater_than_equal(&self, other: &self) -> BoolVec;
|
||||
pure fn equal(&self, other: &self) -> BoolVec;
|
||||
pure fn not_equal(&self, other: &self) -> BoolVec;
|
||||
}
|
||||
|
||||
/**
|
||||
* A vector with boolean components
|
||||
*/
|
||||
pub trait BooleanVector: Vector<bool> {
|
||||
pure fn any(&self) -> bool;
|
||||
pure fn all(&self) -> bool;
|
||||
pure fn not(&self) -> self;
|
||||
}
|
||||
57
src/vec2.rs
57
src/vec2.rs
|
|
@ -1,5 +1,5 @@
|
|||
use core::cast::transmute;
|
||||
use core::cmp::Eq;
|
||||
use core::cmp::{Eq, Ord};
|
||||
use core::ptr::to_unsafe_ptr;
|
||||
use core::vec::raw::buf_as_slice;
|
||||
|
||||
|
|
@ -244,4 +244,59 @@ pub impl<T:Copy FuzzyEq> Vec2<T>: FuzzyEq {
|
|||
self[0].fuzzy_eq(&other[0]) &&
|
||||
self[1].fuzzy_eq(&other[1])
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<T:Copy Ord Eq> Vec2<T>: RelationalVector<T, Vec2<bool>> {
|
||||
#[inline(always)]
|
||||
pure fn less_than(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] < other[0],
|
||||
self[1] < other[1])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn less_than_equal(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] <= other[0],
|
||||
self[1] <= other[1])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] > other[0],
|
||||
self[1] > other[1])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than_equal(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] >= other[0],
|
||||
self[1] >= other[1])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn equal(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] == other[0],
|
||||
self[1] == other[1])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not_equal(&self, other: &Vec2<T>) -> Vec2<bool> {
|
||||
Vec2::new(self[0] != other[0],
|
||||
self[1] != other[1])
|
||||
}
|
||||
}
|
||||
|
||||
pub impl Vec2<bool>: BooleanVector {
|
||||
#[inline(always)]
|
||||
pure fn any(&self) -> bool {
|
||||
self[0] || self[1]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn all(&self) -> bool {
|
||||
self[0] && self[1]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not(&self) -> Vec2<bool> {
|
||||
Vec2::new(!self[0], !self[1])
|
||||
}
|
||||
}
|
||||
63
src/vec3.rs
63
src/vec3.rs
|
|
@ -1,5 +1,5 @@
|
|||
use core::cast::transmute;
|
||||
use core::cmp::Eq;
|
||||
use core::cmp::{Eq, Ord};
|
||||
use core::ptr::to_unsafe_ptr;
|
||||
use core::vec::raw::buf_as_slice;
|
||||
|
||||
|
|
@ -269,4 +269,65 @@ pub impl<T:Copy FuzzyEq> Vec3<T>: FuzzyEq {
|
|||
self[1].fuzzy_eq(&other[1]) &&
|
||||
self[2].fuzzy_eq(&other[2])
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<T:Copy Ord Eq> Vec3<T>: RelationalVector<T, Vec3<bool>> {
|
||||
#[inline(always)]
|
||||
pure fn less_than(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] < other[0],
|
||||
self[1] < other[1],
|
||||
self[2] < other[2])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn less_than_equal(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] <= other[0],
|
||||
self[1] <= other[1],
|
||||
self[2] <= other[2])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] > other[0],
|
||||
self[1] > other[1],
|
||||
self[2] > other[2])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than_equal(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] >= other[0],
|
||||
self[1] >= other[1],
|
||||
self[2] >= other[2])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn equal(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] == other[0],
|
||||
self[1] == other[1],
|
||||
self[2] == other[2])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not_equal(&self, other: &Vec3<T>) -> Vec3<bool> {
|
||||
Vec3::new(self[0] != other[0],
|
||||
self[1] != other[1],
|
||||
self[2] != other[2])
|
||||
}
|
||||
}
|
||||
|
||||
pub impl Vec3<bool>: BooleanVector {
|
||||
#[inline(always)]
|
||||
pure fn any(&self) -> bool {
|
||||
self[0] || self[1] || self[2]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn all(&self) -> bool {
|
||||
self[0] && self[1] && self[2]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not(&self) -> Vec3<bool> {
|
||||
Vec3::new(!self[0], !self[1], !self[2])
|
||||
}
|
||||
}
|
||||
69
src/vec4.rs
69
src/vec4.rs
|
|
@ -1,5 +1,5 @@
|
|||
use core::cast::transmute;
|
||||
use core::cmp::Eq;
|
||||
use core::cmp::{Eq, Ord};
|
||||
use core::ptr::to_unsafe_ptr;
|
||||
use core::vec::raw::buf_as_slice;
|
||||
|
||||
|
|
@ -269,4 +269,71 @@ pub impl<T:Copy FuzzyEq> Vec4<T>: FuzzyEq {
|
|||
self[2].fuzzy_eq(&other[2]) &&
|
||||
self[3].fuzzy_eq(&other[3])
|
||||
}
|
||||
}
|
||||
|
||||
pub impl<T:Copy Ord Eq> Vec4<T>: RelationalVector<T, Vec4<bool>> {
|
||||
#[inline(always)]
|
||||
pure fn less_than(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] < other[0],
|
||||
self[1] < other[1],
|
||||
self[2] < other[2],
|
||||
self[3] < other[3])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn less_than_equal(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] <= other[0],
|
||||
self[1] <= other[1],
|
||||
self[2] <= other[2],
|
||||
self[3] <= other[3])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] > other[0],
|
||||
self[1] > other[1],
|
||||
self[2] > other[2],
|
||||
self[3] > other[3])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn greater_than_equal(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] >= other[0],
|
||||
self[1] >= other[1],
|
||||
self[2] >= other[2],
|
||||
self[3] >= other[3])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn equal(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] == other[0],
|
||||
self[1] == other[1],
|
||||
self[2] == other[2],
|
||||
self[3] == other[3])
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not_equal(&self, other: &Vec4<T>) -> Vec4<bool> {
|
||||
Vec4::new(self[0] != other[0],
|
||||
self[1] != other[1],
|
||||
self[2] != other[2],
|
||||
self[3] != other[3])
|
||||
}
|
||||
}
|
||||
|
||||
pub impl Vec4<bool>: BooleanVector {
|
||||
#[inline(always)]
|
||||
pure fn any(&self) -> bool {
|
||||
self[0] || self[1] || self[2] || self[3]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn all(&self) -> bool {
|
||||
self[0] && self[1] && self[2] && self[3]
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pure fn not(&self) -> Vec4<bool> {
|
||||
Vec4::new(!self[0], !self[1], !self[2], !self[3])
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue