vector-traits 0.6.2

Rust traits for 2D and 3D vector types.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276

// SPDX-License-Identifier: MIT OR Apache-2.0
// Copyright (c) 2023, 2025 lacklustr@protonmail.com https://github.com/eadf

// This file is part of vector-traits.

use crate::prelude::{
    Affine2D, Affine3D, HasXY,
    glam_ext::{Mat4A, Vec2A, vec2a},
};

#[test]
fn test_vec2a() {
    let a_tuple: Vec2A = (1.0, 2.0).into();
    let a: Vec2A = vec2a(1.0, 2.0);
    assert_eq!(a, a_tuple);

    let b: Vec2A = [1.0, 2.0].into();
    let c: Vec2A = glam::vec2(1.0, 2.0).into();
    let d: glam::Vec2 = c.into();
    {
        let a0 = [1.0, 2.0];
        let d1 = Vec2A::from(a0);
        assert_eq!(d, d1.0);
        let a1: [f32; 2] = <[f32; 2]>::from(d1);
        assert_eq!(a0, a1);
    }

    assert_eq!(a.x(), b.x());
    assert_eq!(a.y(), b.y());
    assert_eq!(a.x(), c.x());
    assert_eq!(a.y(), c.y());
    assert_eq!(a.0, d);

    let a_copy = Vec2A::new(1.0, 2.0);
    assert_eq!(a.x(), b.x());
    assert_eq!(a.y(), b.y());
    let mut a = Vec2A::new(1.0, 2.0);
    a *= a_copy;
    a /= a_copy;
    assert_eq!(a, a_copy);
    a *= 2.0;
    a /= 2.0;
    assert_eq!(a, a_copy);
    let a = 2.0 * a * 2.0;
    let a = a / 2.0 / 2.0;
    assert_eq!(a, a_copy);

    let s = format!("{:?}", a.clone());
    assert_eq!("Vec2A(1,2)", s);
}

#[test]
fn test_glam_xy() {
    crate::tests::vector_2d::test_xy::<glam::Vec2>(1.0, 2.0);
    crate::tests::vector_2d::test_xy::<glam::DVec2>(1.0, 2.0);
    crate::tests::vector_2d::test_xy::<Vec2A>(1.0, 2.0);
    crate::tests::vector_2d::test_xy::<glam::Vec3A>(1.0, 2.0);
    crate::tests::vector_2d::test_xy::<glam::Vec3>(1.0, 2.0);
    crate::tests::vector_2d::test_xy::<glam::DVec3>(1.0, 2.0);

    // test deref_mut() for Vec2A
    let mut v: Vec2A = glam::Vec2::new(1.0, 2.0).into();
    let _v: &mut glam::Vec2 = &mut v;
}

#[test]
fn test_glam_xyz() {
    crate::tests::vector_3d::test_xyz::<glam::Vec3>(1.0, 2.0, 3.0);
    crate::tests::vector_3d::test_xyz::<glam::DVec3>(1.0, 2.0, 3.0);
    crate::tests::vector_3d::test_xyz::<glam::Vec3A>(1.0, 2.0, 3.0);
}

#[test]
fn test_glam_gxy() {
    crate::tests::vector_2d::test_gxy::<glam::Vec2>(1.0, 2.0, 3.0);
    crate::tests::vector_2d::test_gxy::<Vec2A>(1.0, 2.0, 3.0);
    crate::tests::vector_2d::test_gxy::<glam::DVec2>(1.0, 2.0, 3.0);
    crate::tests::vector_2d::test_generic_xy::<glam::Vec2>(1.0, 2.0, 3.0, 0.00000001);
    crate::tests::vector_2d::test_generic_xy::<Vec2A>(1.0, 2.0, 3.0, 0.00000001);
    crate::tests::vector_2d::test_generic_xy::<glam::DVec2>(1.0, 2.0, 3.0, 0.0000000000001);
}

#[test]
fn test_glam_gxyz() {
    crate::tests::vector_3d::test_gxyz::<glam::Vec3>(1.0, 2.0, 3.0);
    crate::tests::vector_3d::test_gxyz::<glam::Vec3A>(1.0, 2.0, 3.0);
    crate::tests::vector_3d::test_gxyz::<glam::DVec3>(1.0, 2.0, 3.0);
    crate::tests::vector_3d::test_generic_xyz::<glam::Vec3>(1.0, 2.0, 3.0, 4.0, 0.0001);
    crate::tests::vector_3d::test_generic_xyz::<glam::Vec3A>(1.0, 2.0, 3.0, 4.0, 0.0001);
    crate::tests::vector_3d::test_generic_xyz::<glam::DVec3>(1.0, 2.0, 3.0, 4.0, 0.0000000000001);
}

#[test]
fn test_glam_matrix() {
    use std::ops::DerefMut;

    crate::tests::affine::test_affine2d_v1::<glam::Vec2>();
    crate::tests::affine::test_affine2d_v1::<glam::DVec2>();
    crate::tests::affine::test_affine2d_v1::<Vec2A>();
    crate::tests::affine::test_affine2d_v2::<glam::Vec2>();
    crate::tests::affine::test_affine2d_v2::<glam::DVec2>();
    crate::tests::affine::test_affine2d_v2::<Vec2A>();

    crate::tests::affine::test_affine3d_v1::<glam::Vec3>("glam32_3d");
    crate::tests::affine::test_affine3d_v1::<glam::Vec3A>("glam32A_3d");
    crate::tests::affine::test_affine3d_v1::<glam::DVec3>("glam64_3d");

    // test Mul, From, deref() deref_mut() for Mat4A
    let mut _m: Mat4A = glam::Mat4::identity().into();
    let _m: &mut glam::Mat4 = _m.deref_mut();
    let _m: glam::Mat3A = glam::Mat3A::identity();
    assert_eq!(_m, _m);

    let _m: Mat4A = Mat4A::identity();

    let m = _m * _m;
    assert_eq!(m, _m);
}

#[test]
fn test_glam_aabb2_vec2a() {
    crate::tests::aabb_2d::test_aabb2_comprehensive::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_from_corners::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_from_center_and_half_extents::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_from_center_and_size::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_from_points::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_pad::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_fast_pad::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_is_empty::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_from_point::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_extend_with::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_extend::<Vec2A>();
    crate::tests::aabb_2d::test_aabb2_contains_point_inclusive::<Vec2A>();
    crate::tests::aabb_2d::test_extents::<Vec2A>();
}

#[test]
fn test_glam_aabb2_vec2() {
    crate::tests::aabb_2d::test_aabb2_comprehensive::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_from_corners::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_from_center_and_half_extents::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_from_center_and_size::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_from_points::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_pad::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_fast_pad::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_is_empty::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_from_point::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_extend_with::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_extend::<glam::Vec2>();
    crate::tests::aabb_2d::test_aabb2_contains_point_inclusive::<glam::Vec2>();
    crate::tests::aabb_2d::test_extents::<glam::Vec2>();
}

#[test]
fn test_glam_aabb2_dvec2() {
    crate::tests::aabb_2d::test_aabb2_comprehensive::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_from_corners::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_from_center_and_half_extents::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_from_center_and_size::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_from_points::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_pad::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_fast_pad::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_is_empty::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_from_point::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_extend_with::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_extend::<glam::DVec2>();
    crate::tests::aabb_2d::test_aabb2_contains_point_inclusive::<glam::DVec2>();
    crate::tests::aabb_2d::test_extents::<glam::DVec2>();
}

#[test]
fn test_glam_aabb3_vec3a() {
    crate::tests::aabb_3d::test_aabb3_comprehensive::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_from_corners::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_from_center_and_half_extents::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_from_center_and_size::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_from_points::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_pad::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_fast_pad::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_is_empty::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_from_point::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_extend_with::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_extend::<glam::Vec3A>();
    crate::tests::aabb_3d::test_aabb3_contains_point_inclusive::<glam::Vec3A>();
    crate::tests::aabb_3d::test_extents::<glam::Vec3A>();
}

#[test]
fn test_glam_aabb3_vec3() {
    crate::tests::aabb_3d::test_aabb3_comprehensive::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_from_corners::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_from_center_and_half_extents::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_from_center_and_size::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_from_points::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_pad::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_fast_pad::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_is_empty::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_from_point::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_extend_with::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_extend::<glam::Vec3>();
    crate::tests::aabb_3d::test_aabb3_contains_point_inclusive::<glam::Vec3>();
    crate::tests::aabb_3d::test_extents::<glam::Vec3>();
}

#[test]
fn test_glam_aabb3_dvec3() {
    crate::tests::aabb_3d::test_aabb3_comprehensive::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_from_corners::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_from_center_and_half_extents::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_from_center_and_size::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_from_points::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_pad::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_fast_pad::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_is_empty::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_from_point::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_extend_with::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_extend::<glam::DVec3>();
    crate::tests::aabb_3d::test_aabb3_contains_point_inclusive::<glam::DVec3>();
    crate::tests::aabb_3d::test_extents::<glam::DVec3>();
}

#[test]
fn test_glam_plane_f32() {
    crate::tests::plane::test_get_plane_xy::<glam::Vec3>();
    crate::tests::plane::test_get_plane_xz::<glam::Vec3>();
    crate::tests::plane::test_get_plane_yz::<glam::Vec3>();
    crate::tests::plane::test_get_bad_plane::<glam::Vec3>();
    crate::tests::plane::test_get_plane_relaxed::<glam::Vec3>();

    crate::tests::plane::test_get_plane_xy::<glam::Vec3A>();
    crate::tests::plane::test_get_plane_xz::<glam::Vec3A>();
    crate::tests::plane::test_get_plane_yz::<glam::Vec3A>();
    crate::tests::plane::test_get_bad_plane::<glam::Vec3A>();
    crate::tests::plane::test_get_plane_relaxed::<glam::Vec3A>();

    crate::tests::affine::test_affine3d_plane_xy::<glam::Vec3>();
    crate::tests::affine::test_affine3d_plane_xz::<glam::Vec3>();
    crate::tests::affine::test_affine3d_plane_yz::<glam::Vec3>();

    crate::tests::affine::test_affine3d_plane_xy::<glam::Vec3A>();
    crate::tests::affine::test_affine3d_plane_xz::<glam::Vec3A>();
    crate::tests::affine::test_affine3d_plane_yz::<glam::Vec3A>();
}
#[test]
fn test_glam_plane_f64() {
    crate::tests::plane::test_get_plane_xy::<glam::DVec3>();
    crate::tests::plane::test_get_plane_xz::<glam::DVec3>();
    crate::tests::plane::test_get_plane_yz::<glam::DVec3>();
    crate::tests::plane::test_get_bad_plane::<glam::DVec3>();
    crate::tests::plane::test_get_plane_relaxed::<glam::DVec3>();

    crate::tests::affine::test_affine3d_plane_xy::<glam::DVec3>();
    crate::tests::affine::test_affine3d_plane_xz::<glam::DVec3>();
    crate::tests::affine::test_affine3d_plane_yz::<glam::DVec3>();
}

#[test]
fn test_glam_affine_f32() {
    crate::tests::affine::test_affine3d_scale_and_translation::<glam::Vec3A>();
    crate::tests::affine::test_affine3d_scale_and_translation::<glam::Vec3>();
}

#[test]
fn test_glam_affine_f64() {
    crate::tests::affine::test_affine3d_scale_and_translation::<glam::DVec3>();
}

#[test]
fn test_glam_simd_conversion_f32() {
    crate::tests::vector_3d::test_simd_conversion::<glam::Vec3>();
}

#[test]
fn test_glam_simd_conversion_f64() {
    crate::tests::vector_3d::test_simd_conversion::<glam::DVec3>();
}