ray_tracing_core 0.1.1

Ray Tracing based on Peter Shirley's mini books
Documentation 
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

use crate::types::{FSize, Vector3, Vector4};
use std::cmp::PartialOrd;
use std::ops::Range;

/// floating point comparison
#[allow(dead_code)]
pub fn assert_eq_float(a: f64, b: f64, eps: f64) {
    assert!(
        f64::abs(a - b) < eps,
        "floating point values are not equal: {} != {}",
        a,
        b
    );
}

/// Vector3 floating point comparison
#[allow(dead_code)]
pub fn assert_eq_vector3(a: &Vector3, b: &Vector3, eps: FSize) {
    for i in 0..3 {
        assert_eq_float(a[i], b[i], eps);
    }
}

/// Vector3 floating point comparison
#[allow(dead_code)]
pub fn assert_eq_vector4(a: &Vector4, b: &Vector4, eps: FSize) {
    for i in 0..4 {
        assert_eq_float(a[i], b[i], eps);
    }
}

/// floating point value in range
#[allow(dead_code)]
pub fn assert_in_range<T>(value: T, range: Range<T>)
where
    T: PartialOrd,
{
    assert!(
        range.contains(&value),
        "floating point value is not in range"
    );
}

/// Vector3 in range
#[allow(dead_code)]
pub fn assert_in_range_vector3(v: Vector3, range: Range<Vector3>) {
    for i in 0..3 {
        assert_in_range(v[i], range.start[i]..range.end[i]);
    }
}

/// Vector3 in range
#[allow(dead_code)]
pub fn assert_in_range_vector4(v: Vector4, range: Range<Vector4>) {
    for i in 0..4 {
        assert_in_range(v[i], range.start[i]..range.end[i]);
    }
}

#[cfg(test)]
mod test_helper_test {
    use super::*;

    #[test]
    fn assert_eq_float_test() {
        assert_eq_float(1.0, 0.99, 0.1);
    }

    #[test]
    #[should_panic(expected = "floating point values are not equal")]
    fn assert_eq_float_test_fail() {
        assert_eq_float(1.0, 0.99, 0.001);
    }

    #[test]
    fn assert_equ_vector3_test() {
        assert_eq_vector3(
            &Vector3::new(1.0, 2.0, 3.0),
            &Vector3::new(0.99, 2.01, 3.0),
            0.1,
        );
    }

    #[test]
    #[should_panic(expected = "floating point values are not equal")]
    fn assert_eq_vector3_test_fail() {
        assert_eq_vector3(
            &Vector3::new(1.0, 2.0, 3.0),
            &Vector3::new(1.0, 1.99, 3.0),
            0.001,
        );
    }

    #[test]
    fn assert_in_range_test() {
        assert_in_range(0.5, 0.0..1.0);
    }

    #[test]
    #[should_panic(expected = "floating point value is not in range")]
    fn assert_in_range_test_fail() {
        assert_in_range(1.5, 0.0..1.0);
    }

    #[test]
    fn assert_in_range_vector3_test() {
        assert_in_range_vector3(
            Vector3::new(0.1, 0.5, 0.9),
            Vector3::new(0.0, 0.0, 0.0)..Vector3::new(1.0, 1.0, 1.0),
        );
    }

    #[test]
    #[should_panic(expected = "floating point value is not in range")]
    fn assert_in_range_vector3_test_fail() {
        assert_in_range_vector3(
            Vector3::new(0.1, 1.5, 0.9),
            Vector3::new(0.0, 0.0, 0.0)..Vector3::new(1.0, 1.0, 1.0),
        );
    }
}