1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use number_traits::{Cast, Num, Signed};

#[inline]
pub fn inverse<'a, T: Copy + Signed>(out: &'a mut [T; 3], a: &[T; 3]) -> &'a mut [T; 3] {
    out[0] = -a[0];
    out[1] = -a[1];
    out[2] = -a[2];
    out
}
#[test]
fn test_inverse() {
    let mut v = [0, 0, 0];
    inverse(&mut v, &[1, 1, 1]);
    assert!(v[0] == -1);
    assert!(v[1] == -1);
    assert!(v[2] == -1);
}

#[inline]
pub fn lerp<'a, T, F>(out: &'a mut [T; 3], a: &[T; 3], b: &[T; 3], t: F) -> &'a mut [T; 3]
where
    T: Copy + Num + Cast<F>,
    F: Copy + Num + Cast<T>,
{
    let a0 = a[0].cast();
    let a1 = a[1].cast();
    let a2 = a[2].cast();
    let b0 = b[0].cast();
    let b1 = b[1].cast();
    let b2 = b[2].cast();

    out[0] = (a0 + (b0 - a0) * t).cast();
    out[1] = (a1 + (b1 - a1) * t).cast();
    out[2] = (a2 + (b2 - a2) * t).cast();
    out
}
#[test]
fn test_lerp() {
    let mut v = [0, 0, 0];
    lerp(&mut v, &[0, 0, 0], &[2, 4, 8], 0.5);
    assert_eq!(v[0], 1);
    assert_eq!(v[1], 2);
    assert_eq!(v[2], 4);
}

#[inline]
pub fn min<'a, T: Copy + Num>(out: &'a mut [T; 3], a: &[T; 3], b: &[T; 3]) -> &'a mut [T; 3] {
    out[0] = if b[0] < a[0] { b[0] } else { a[0] };
    out[1] = if b[1] < a[1] { b[1] } else { a[1] };
    out[2] = if b[2] < a[2] { b[2] } else { a[2] };
    out
}
#[test]
fn test_min() {
    let mut v = [0, 0, 0];
    min(&mut v, &[1, 0, 1], &[0, 1, 0]);
    assert!(v == [0, 0, 0]);
}

#[inline]
pub fn max<'a, T: Copy + Num>(out: &'a mut [T; 3], a: &[T; 3], b: &[T; 3]) -> &'a mut [T; 3] {
    out[0] = if b[0] > a[0] { b[0] } else { a[0] };
    out[1] = if b[1] > a[1] { b[1] } else { a[1] };
    out[2] = if b[2] > a[2] { b[2] } else { a[2] };
    out
}
#[test]
fn test_max() {
    let mut v = [0, 0, 0];
    max(&mut v, &[1, 0, 1], &[0, 1, 0]);
    assert!(v == [1, 1, 1]);
}

#[inline]
pub fn clamp<'a, T: Copy + Num>(
    out: &'a mut [T; 3],
    a: &[T; 3],
    min: &[T; 3],
    max: &[T; 3],
) -> &'a mut [T; 3] {
    out[0] = if a[0] < min[0] {
        min[0]
    } else if a[0] > max[0] {
        max[0]
    } else {
        a[0]
    };
    out[1] = if a[1] < min[1] {
        min[1]
    } else if a[1] > max[1] {
        max[1]
    } else {
        a[1]
    };
    out[2] = if a[2] < min[2] {
        min[2]
    } else if a[2] > max[2] {
        max[2]
    } else {
        a[2]
    };
    out
}
#[test]
fn test_clamp() {
    let mut v = [0, 0, 0];
    clamp(&mut v, &[2, 2, 2], &[0, 0, 0], &[1, 1, 1]);
    assert!(v == [1, 1, 1]);
}

#[inline]
pub fn eq<T: Copy + Num>(a: &[T; 3], b: &[T; 3]) -> bool {
    !ne(a, b)
}
#[test]
fn test_eq() {
    assert_eq!(eq(&[1f32, 1f32, 1f32], &[1f32, 1f32, 1f32]), true);
    assert_eq!(eq(&[0f32, 0f32, 0f32], &[1f32, 1f32, 1f32]), false);
}

#[inline]
pub fn ne<T: Copy + Num>(a: &[T; 3], b: &[T; 3]) -> bool {
    !a[0].approx_eq(&b[0]) || !a[1].approx_eq(&b[1]) || !a[2].approx_eq(&b[2])
}
#[test]
fn test_ne() {
    assert_eq!(ne(&[1f32, 1f32, 1f32], &[1f32, 1f32, 1f32]), false);
    assert_eq!(ne(&[0f32, 0f32, 0f32], &[1f32, 1f32, 1f32]), true);
}