AtlatestRepositorysigil-geometry

sigil-geometry / tree / testtest-vec.sgl

1;;; Tests for (sigil geometry vec)
2
3(import (sigil test)
4 (sigil geometry))
5
6;; On a mismatch, fail through assert-equal on lists so the report shows
7;; both values.
8(define (assert-vec3 expected actual)
9 (unless (vec3-approx=? expected actual)
10 (assert-equal (vec3->list expected) (vec3->list actual))))
12(define (assert-float expected actual)
13 (unless (float-approx=? expected actual)
14 (assert-equal expected actual)))
16(test-group "vec3 - construction and access"
17 (test "components read back"
18 (let ((v (vec3 1 2 3)))
19 (assert-equal '(1.0 2.0 3.0) (vec3->list v))
20 (assert-float 2.0 (vec3-y v))))
22 (test "make-vec3 is zeros"
23 (assert-equal '(0.0 0.0 0.0) (vec3->list (make-vec3))))
25 (test "values round to float32"
26 ;; 0.1 is not a float32; the nearest one is 0.100000001490116...
27 (assert-false (= 0.1 (vec3-x (vec3 0.1 0 0))))
28 (assert-float 0.1 (vec3-x (vec3 0.1 0 0))))
30 (test "vec3? checks the size"
31 (assert-true (vec3? (vec3 1 2 3)))
32 (assert-false (vec3? (vec4 1 2 3 4)))
33 (assert-false (vec3? '(1 2 3))))
35 (test "set! and copy"
36 (let* ((a (vec3 1 2 3)) (b (vec3-copy a)))
37 (vec3-set! a 7 8 9)
38 (assert-vec3 (vec3 1 2 3) b)
39 (assert-vec3 (vec3 7 8 9) (vec3-copy! b a)))))
41(test-group "vec3 - arithmetic"
42 (test "add, sub, mul, scale, negate"
43 (let ((a (vec3 1 2 3)) (b (vec3 4 5 6)))
44 (assert-vec3 (vec3 5 7 9) (vec3-add a b))
45 (assert-vec3 (vec3 -3 -3 -3) (vec3-sub a b))
46 (assert-vec3 (vec3 4 10 18) (vec3-mul a b))
47 (assert-vec3 (vec3 2 4 6) (vec3-scale a 2))
48 (assert-vec3 (vec3 -1 -2 -3) (vec3-negate a))
49 (assert-vec3 (vec3 9 12 15) (vec3-add-scaled a b 2))))
51 (test "dot and cross"
52 (assert-float 32.0 (vec3-dot (vec3 1 2 3) (vec3 4 5 6)))
53 (assert-vec3 (vec3 0 0 1) (vec3-cross (vec3 1 0 0) (vec3 0 1 0)))
54 (assert-vec3 (vec3 1 0 0) (vec3-cross (vec3 0 1 0) (vec3 0 0 1)))
55 (assert-vec3 (vec3 0 1 0) (vec3-cross (vec3 0 0 1) (vec3 1 0 0)))
56 (assert-vec3 (vec3 -3 6 -3) (vec3-cross (vec3 1 2 3) (vec3 4 5 6))))
58 (test "length and distance"
59 (assert-float 5.0 (vec3-length (vec3 3 4 0)))
60 (assert-float 25.0 (vec3-length-squared (vec3 0 3 4)))
61 (assert-float 13.0 (vec3-distance (vec3 1 1 1) (vec3 4 5 13)))
62 (assert-float 169.0 (vec3-distance-squared (vec3 1 1 1) (vec3 4 5 13))))
64 (test "normalize"
65 (assert-vec3 (vec3 0.6 0.8 0) (vec3-normalize (vec3 3 4 0)))
66 (assert-float 1.0 (vec3-length (vec3-normalize (vec3 -2 7 1)))))
68 (test "normalizing a zero vector gives zero, not an error"
69 (assert-vec3 (vec3 0 0 0) (vec3-normalize (make-vec3))))
71 (test "lerp"
72 (let ((a (vec3 0 10 -4)) (b (vec3 10 20 4)))
73 (assert-vec3 a (vec3-lerp a b 0))
74 (assert-vec3 b (vec3-lerp a b 1))
75 (assert-vec3 (vec3 2.5 12.5 -2) (vec3-lerp a b 0.25))))
77 (test "min and max"
78 (assert-vec3 (vec3 1 -5 3) (vec3-min (vec3 1 2 3) (vec3 4 -5 6)))
79 (assert-vec3 (vec3 4 2 6) (vec3-max (vec3 1 2 3) (vec3 4 -5 6)))))
81(test-group "vec3 - ! forms"
82 (test "write into dst and return it"
83 (let* ((dst (make-vec3)) (r (vec3-add! dst (vec3 1 2 3) (vec3 1 1 1))))
84 (assert-true (eq? dst r))
85 (assert-vec3 (vec3 2 3 4) dst)))
87 (test "dst may alias an input"
88 (let ((a (vec3 1 2 3)))
89 (vec3-cross! a a (vec3 4 5 6))
90 (assert-vec3 (vec3 -3 6 -3) a))
91 (let ((b (vec3 4 5 6)))
92 (vec3-cross! b (vec3 1 2 3) b)
93 (assert-vec3 (vec3 -3 6 -3) b))
94 (let ((a (vec3 3 4 0)))
95 (vec3-normalize! a a)
96 (assert-vec3 (vec3 0.6 0.8 0) a))
97 (let ((a (vec3 0 10 -4)))
98 (vec3-lerp! a a (vec3 10 20 4) 0.5)
99 (assert-vec3 (vec3 5 15 0) a))))
101(test-group "vec2"
102 (test "basics"
103 (let ((a (vec2 3 4)) (b (vec2 1 2)))
104 (assert-equal '(4.0 6.0) (vec2->list (vec2-add a b)))
105 (assert-equal '(2.0 2.0) (vec2->list (vec2-sub a b)))
106 (assert-equal '(3.0 8.0) (vec2->list (vec2-mul a b)))
107 (assert-equal '(-3.0 -4.0) (vec2->list (vec2-negate a)))
108 (assert-float 11.0 (vec2-dot a b))
109 (assert-float 5.0 (vec2-length a))
110 (assert-float 25.0 (vec2-length-squared a))
111 (assert-float 2.8284271 (vec2-distance a b))
112 (assert-true (vec2-approx=? (vec2 0.6 0.8) (vec2-normalize a)))
113 (assert-true (vec2-approx=? (vec2 2 3) (vec2-lerp b a 0.5)))
114 (assert-true (vec2-approx=? (vec2 6 8) (vec2-scale a 2)))
115 (assert-equal 8 (bytevector-length (make-vec2)))
116 (assert-true (vec2? (vec2-copy a))))))
118(test-group "vec4"
119 (test "basics"
120 (let ((a (vec4 1 2 3 4)) (b (vec4 4 3 2 1)))
121 (assert-equal '(5.0 5.0 5.0 5.0) (vec4->list (vec4-add a b)))
122 (assert-equal '(-3.0 -1.0 1.0 3.0) (vec4->list (vec4-sub a b)))
123 (assert-equal '(4.0 6.0 6.0 4.0) (vec4->list (vec4-mul a b)))
124 (assert-equal '(2.0 4.0 6.0 8.0) (vec4->list (vec4-scale a 2)))
125 (assert-equal '(-1.0 -2.0 -3.0 -4.0) (vec4->list (vec4-negate a)))
126 (assert-float 20.0 (vec4-dot a b))
127 (assert-float 30.0 (vec4-length-squared a))
128 (assert-float 1.0 (vec4-length (vec4-normalize a)))
129 (assert-true (vec4-approx=? (vec4 2.5 2.5 2.5 2.5) (vec4-lerp a b 0.5)))
130 (assert-float 4.0 (vec4-w a))
131 (assert-equal 16 (bytevector-length (vec4-copy a))))))
133(test-group "angles"
134 (test "degrees and radians"
135 (assert-float 3.141592653589793 (degrees->radians 180))
136 (assert-float 90.0 (radians->degrees (/ 3.141592653589793 2)))))
138;; NaN built at run time: inf - inf. Sigil 0.22.7 answers #t to (<= nan x),
139;; (>= nan x) and (= nan x), so every comparison here must be built on `<`.
140(define nan-value (- (* 1e300 1e300) (* 1e300 1e300)))
142(test-group "NaN is never approx=?"
143 (test "the constructed value is NaN (< and > both refuse it)"
144 ;; guards the premise of the tests below
145 ;; no real number is both >= 2 and <= 1
146 (assert-false (< nan-value 2.0))
147 (assert-false (> nan-value 1.0)))
149 (test "scalars"
150 (assert-false (float-approx=? 1.0 nan-value))
151 (assert-false (float-approx=? nan-value 1.0))
152 (assert-false (float-approx=? nan-value nan-value)))
154 (test "vectors"
155 (assert-false (vec2-approx=? (vec2 1 2) (vec2 nan-value 2)))
156 (assert-false (vec3-approx=? (vec3 1 2 3) (vec3 1 2 nan-value)))
157 (assert-false (vec3-approx=? (vec3 nan-value nan-value nan-value)
158 (vec3 nan-value nan-value nan-value)))
159 (assert-false (vec4-approx=? (vec4 1 2 3 4) (vec4 1 nan-value 3 4)))))