boxddd 0.3.0

Safe, ergonomic Rust bindings for Box3D
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

use boxddd::error::InvalidValueReason;
use boxddd::{
    BoxHull, Capsule, Compound, Error, HeightField, Hull, MeshData, MeshDataOptions, ShapeDef,
    Sphere, SurfaceMaterial, Transform, Vec3,
};

#[test]
fn surface_material_default_matches_box3d_default() {
    let material = SurfaceMaterial::default();
    assert_eq!(material.friction, 0.6);
    assert_eq!(material.restitution, 0.0);
    assert_eq!(material.rolling_resistance, 0.0);
    assert_eq!(material.tangent_velocity, Vec3::ZERO);
}

#[test]
fn value_and_resource_geometry_reject_invalid_inputs() {
    assert_eq!(
        Capsule::new(Vec3::ZERO, Vec3::X, f32::NAN).validate(),
        Err(Error::InvalidValue {
            context: "capsule.radius",
            reason: InvalidValueReason::NonFinite,
        })
    );
    assert_eq!(
        Sphere::new(Vec3::ZERO, 0.0).validate(),
        Err(Error::InvalidValue {
            context: "sphere.radius",
            reason: InvalidValueReason::OutOfRange,
        })
    );
    assert!(Hull::from_points([Vec3::ZERO, Vec3::X, Vec3::Y], 8).is_err());
    assert!(Hull::cylinder(1.0, 1.0, 0.0, 2).is_err());
    assert!(Hull::cylinder(1.0, 1.0, 0.0, 33).is_err());
    assert_eq!(
        Hull::cone(1.0, 0.0, 1.0, 4).unwrap_err(),
        Error::InvalidValue {
            context: "hull.cone.radius1",
            reason: InvalidValueReason::OutOfRange,
        }
    );
    assert_eq!(
        Hull::cone(1.0, 1.0, 0.0, 4).unwrap_err(),
        Error::InvalidValue {
            context: "hull.cone.radius2",
            reason: InvalidValueReason::OutOfRange,
        }
    );
    for slices in [3, 33] {
        assert_eq!(
            Hull::cone(1.0, 1.0, 1.0, slices).unwrap_err(),
            Error::InvalidValue {
                context: "hull.cone.slices",
                reason: InvalidValueReason::OutOfRange,
            }
        );
    }
    assert_eq!(
        BoxHull::cube(0.0).unwrap_err(),
        Error::InvalidValue {
            context: "box_hull.half_width",
            reason: InvalidValueReason::OutOfRange,
        }
    );
    assert_eq!(
        BoxHull::new(1.0, f32::NAN, 1.0).unwrap_err(),
        Error::InvalidValue {
            context: "box_hull.half_widths",
            reason: InvalidValueReason::NonFinite,
        }
    );
    assert_eq!(
        BoxHull::offset(1.0, 1.0, 1.0, [f32::INFINITY, 0.0, 0.0]).unwrap_err(),
        Error::InvalidValue {
            context: "box_hull.offset",
            reason: InvalidValueReason::NonFinite,
        }
    );
    assert_eq!(
        BoxHull::transformed(
            1.0,
            1.0,
            1.0,
            Transform::new(Vec3::ZERO, boxddd::Quat::new(Vec3::ZERO, 0.0)),
        )
        .unwrap_err(),
        Error::InvalidValue {
            context: "box_hull.transform",
            reason: InvalidValueReason::Malformed,
        }
    );
    assert_eq!(
        BoxHull::scaled([1.0, 1.0, 1.0], Transform::IDENTITY, [1.0, f32::NAN, 1.0],).unwrap_err(),
        Error::InvalidValue {
            context: "box_hull.post_scale",
            reason: InvalidValueReason::NonFinite,
        }
    );
    assert!(MeshData::box_mesh(Vec3::ZERO, [1.0, 0.0, 1.0], true).is_err());
    assert!(
        MeshData::from_triangles(
            vec![Vec3::ZERO, Vec3::X, Vec3::Y],
            vec![0, 1, 3],
            None,
            MeshDataOptions::default(),
        )
        .is_err()
    );
    assert!(
        MeshData::from_triangles(
            vec![Vec3::ZERO, Vec3::X, Vec3::Y],
            vec![0, 1, 2],
            Some(&[0, 1]),
            MeshDataOptions::default(),
        )
        .is_err()
    );
    assert!(
        MeshData::from_triangles(
            vec![Vec3::ZERO, Vec3::X, Vec3::new(2.0, 0.0, 0.0)],
            vec![0, 1, 2],
            None,
            MeshDataOptions::default(),
        )
        .is_err()
    );
    assert!(
        MeshData::from_triangles(
            vec![Vec3::ZERO, Vec3::X, Vec3::Y],
            vec![0, 1, 2],
            None,
            MeshDataOptions::default().weld_tolerance(f32::NAN),
        )
        .is_err()
    );
    assert!(MeshData::wave_mesh(2, 2, 1.0, f32::NAN, 1.0, 1.0).is_err());
    assert!(MeshData::torus_mesh(2, 8, 1.0, 0.25).is_err());
    assert!(MeshData::hollow_box_mesh(Vec3::ZERO, [1.0, 0.0, 1.0]).is_err());
    assert!(MeshData::platform_mesh(Vec3::ZERO, 1.0, 0.0, 2.0).is_err());
    assert!(HeightField::grid(1, 2, [1.0, 1.0, 1.0], false).is_err());
    assert!(
        HeightField::from_samples(2, 2, vec![0.0, 1.0, 2.0], [1.0, 1.0, 1.0], None, false).is_err()
    );
    assert!(
        HeightField::from_samples(
            2,
            2,
            vec![0.0, 1.0, 2.0, f32::NAN],
            [1.0, 1.0, 1.0],
            None,
            false,
        )
        .is_err()
    );
    assert!(
        HeightField::from_samples(
            2,
            2,
            vec![0.0, 1.0, 2.0, 3.0],
            [1.0, 1.0, 1.0],
            Some(&[0, 1]),
            false,
        )
        .is_err()
    );
    assert!(HeightField::wave(2, 2, [1.0, 1.0, 1.0], f32::NAN, 1.0, false).is_err());
    assert!(
        Compound::single_sphere(
            Sphere::new(Vec3::ZERO, f32::INFINITY),
            SurfaceMaterial::default()
        )
        .is_err()
    );
    assert!(Compound::builder().build().is_err());
    let mesh = MeshData::box_mesh(Vec3::ZERO, [1.0, 1.0, 1.0], true).unwrap();
    let mut compound_builder = Compound::builder();
    compound_builder
        .add_sphere(Sphere::new(Vec3::ZERO, 0.25), SurfaceMaterial::default())
        .unwrap();
    assert!(
        compound_builder
            .add_mesh(
                &mesh,
                Transform::IDENTITY,
                [0.0, 1.0, 1.0],
                [SurfaceMaterial::default()],
            )
            .is_err()
    );
    assert_eq!(
        SurfaceMaterial {
            friction: -1.0,
            ..Default::default()
        }
        .validate(),
        Err(Error::InvalidValue {
            context: "surface_material.friction",
            reason: InvalidValueReason::OutOfRange,
        })
    );
    assert_eq!(
        SurfaceMaterial {
            restitution: -1.0,
            ..Default::default()
        }
        .validate(),
        Err(Error::InvalidValue {
            context: "surface_material.restitution",
            reason: InvalidValueReason::OutOfRange,
        })
    );
    assert_eq!(
        SurfaceMaterial {
            rolling_resistance: -1.0,
            ..Default::default()
        }
        .validate(),
        Err(Error::InvalidValue {
            context: "surface_material.rolling_resistance",
            reason: InvalidValueReason::OutOfRange,
        })
    );
    assert_eq!(
        ShapeDef::builder().friction(-1.0).build().unwrap_err(),
        Error::InvalidValue {
            context: "surface_material.friction",
            reason: InvalidValueReason::OutOfRange,
        }
    );
    assert_eq!(
        ShapeDef::builder().restitution(-1.0).build().unwrap_err(),
        Error::InvalidValue {
            context: "surface_material.restitution",
            reason: InvalidValueReason::OutOfRange,
        }
    );
}