Release v0.23.0 (#371)

sebcrozet · web-flow · commit d955f7527847 · 2025-08-08T17:22:27.000+02:00
* chore: update to nalgebra 0.34

* Release v0.23.0

* fix benches compilation
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.23.0
+
+- Update to nalgebra 0.34.
+
 ## 0.22.1
 
 ### Added
diff --git a/crates/parry2d-f64/Cargo.toml b/crates/parry2d-f64/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "parry2d-f64"
-version = "0.22.1"
+version = "0.23.0"
 authors = ["Sébastien Crozet <developer@crozet.re>"]
 
 description = "2 dimensional collision detection library in Rust. 64-bit precision version."
@@ -73,7 +73,7 @@ num-traits = { version = "0.2", default-features = false }
 slab = { version = "0.4", optional = true }
 arrayvec = { version = "0.7", default-features = false }
 simba = { version = "0.9", default-features = false }
-nalgebra = { version = "0.33", default-features = false, features = ["libm"] }
+nalgebra = { version = "0.34", default-features = false, features = ["libm"] }
 approx = { version = "0.5", default-features = false }
 serde = { version = "1.0", optional = true, features = ["derive"] }
 rkyv = { version = "0.7.41", optional = true }
@@ -95,4 +95,4 @@ smallvec = "1"
 simba = { version = "0.9", default-features = false }
 oorandom = "11"
 ptree = "0.4.0"
-rand = { version = "0.8" }
+rand = { version = "0.9" }
diff --git a/crates/parry2d/Cargo.toml b/crates/parry2d/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "parry2d"
-version = "0.22.1"
+version = "0.23.0"
 authors = ["Sébastien Crozet <developer@crozet.re>"]
 
 description = "2 dimensional collision detection library in Rust."
@@ -73,7 +73,7 @@ num-traits = { version = "0.2", default-features = false }
 slab = { version = "0.4", optional = true }
 arrayvec = { version = "0.7", default-features = false }
 simba = { version = "0.9", default-features = false }
-nalgebra = { version = "0.33", default-features = false, features = ["libm"] }
+nalgebra = { version = "0.34", default-features = false, features = ["libm"] }
 approx = { version = "0.5", default-features = false }
 serde = { version = "1.0", optional = true, features = ["derive"] }
 rkyv = { version = "0.7.41", optional = true }
@@ -95,7 +95,7 @@ smallvec = "1"
 simba = { version = "0.9", default-features = false }
 oorandom = "11"
 ptree = "0.4.0"
-rand = { version = "0.8" }
+rand = { version = "0.9" }
 macroquad = "0.4.12"
 
 [package.metadata.docs.rs]
diff --git a/crates/parry3d-f64/Cargo.toml b/crates/parry3d-f64/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "parry3d-f64"
-version = "0.22.1"
+version = "0.23.0"
 authors = ["Sébastien Crozet <developer@crozet.re>"]
 
 description = "3 dimensional collision detection library in Rust. 64-bits precision version."
@@ -73,7 +73,7 @@ num-traits = { version = "0.2", default-features = false }
 slab = { version = "0.4", optional = true }
 arrayvec = { version = "0.7", default-features = false }
 simba = { version = "0.9", default-features = false }
-nalgebra = { version = "0.33", default-features = false, features = ["libm"] }
+nalgebra = { version = "0.34", default-features = false, features = ["libm"] }
 approx = { version = "0.5", default-features = false }
 serde = { version = "1.0", optional = true, features = ["derive", "rc"] }
 rkyv = { version = "0.7.41", optional = true }
@@ -98,7 +98,7 @@ thiserror = { version = "2", default-features = false }
 [dev-dependencies]
 oorandom = "11"
 ptree = "0.4.0"
-rand = { version = "0.8" }
+rand = { version = "0.9" }
 
 [package.metadata.docs.rs]
 rustdoc-args = ["-Zunstable-options", "--generate-link-to-definition"]
diff --git a/crates/parry3d/Cargo.toml b/crates/parry3d/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "parry3d"
-version = "0.22.1"
+version = "0.23.0"
 authors = ["Sébastien Crozet <developer@crozet.re>"]
 
 description = "3 dimensional collision detection library in Rust."
@@ -74,7 +74,7 @@ num-traits = { version = "0.2", default-features = false }
 slab = { version = "0.4", optional = true }
 arrayvec = { version = "0.7", default-features = false }
 simba = { version = "0.9", default-features = false }
-nalgebra = { version = "0.33", default-features = false, features = ["libm"] }
+nalgebra = { version = "0.34", default-features = false, features = ["libm"] }
 approx = { version = "0.5", default-features = false }
 serde = { version = "1.0", optional = true, features = ["derive", "rc"] }
 rkyv = { version = "0.7.41", optional = true }
@@ -103,10 +103,10 @@ glam = { version = "0.30.4", optional = true }
 [dev-dependencies]
 oorandom = "11"
 ptree = "0.4.0"
-rand = { version = "0.8" }
+rand = { version = "0.9" }
 macroquad = "0.4.12"
-nalgebra = { version = "0.33", default-features = false, features = ["rand"] }
-rand_isaac = "0.3"
+nalgebra = { version = "0.34", default-features = false, features = ["rand"] }
+rand_isaac = "0.4"
 
 [package.metadata.docs.rs]
 rustdoc-args = ["-Zunstable-options", "--generate-link-to-definition"]
diff --git a/crates/parry3d/benches/common/default_gen.rs b/crates/parry3d/benches/common/default_gen.rs
@@ -7,7 +7,7 @@ use parry3d::math::{Point, Real, Vector};
 use parry3d::query::Ray;
 use parry3d::shape::ConvexPolyhedron;
 use parry3d::shape::{Ball, Capsule, Cone, Cuboid, Cylinder, Segment, Triangle};
-use rand::distributions::{Distribution, Standard};
+use rand::distr::{Distribution, StandardUniform};
 use rand::Rng;
 
 pub trait DefaultGen {
@@ -22,7 +22,7 @@ macro_rules! impl_rand_default_gen (
     ($t: ty) => {
         impl DefaultGen for $t {
             fn generate<R: Rng>(rng: &mut R) -> $t {
-                rng.gen::<$t>()
+                rng.random::<$t>()
             }
         }
     }
@@ -56,101 +56,101 @@ impl_rand_default_gen!(bool);
 
 impl DefaultGen for Ball
 where
-    Standard: Distribution<Real>,
+    StandardUniform: Distribution<Real>,
 {
     fn generate<R: Rng>(rng: &mut R) -> Ball {
-        Ball::new(rng.gen::<f32>().abs())
+        Ball::new(rng.random::<f32>().abs())
     }
 }
 
 impl DefaultGen for Cuboid
 where
-    Standard: Distribution<Vector<Real>>,
+    StandardUniform: Distribution<Vector<Real>>,
 {
     fn generate<R: Rng>(rng: &mut R) -> Cuboid {
-        Cuboid::new(rng.gen::<Vector<Real>>().abs())
+        Cuboid::new(rng.random::<Vector<Real>>().abs())
     }
 }
 
 impl DefaultGen for Capsule
 where
-    Standard: Distribution<Real>,
+    StandardUniform: Distribution<Real>,
 {
     fn generate<R: Rng>(rng: &mut R) -> Capsule {
         Capsule::new(
-            rng.gen::<Point<Real>>(),
-            rng.gen::<Point<Real>>(),
-            rng.gen::<Real>().abs(),
+            rng.random::<Point<Real>>(),
+            rng.random::<Point<Real>>(),
+            rng.random::<Real>().abs(),
         )
     }
 }
 
 impl DefaultGen for Cone
 where
-    Standard: Distribution<Real>,
+    StandardUniform: Distribution<Real>,
 {
     fn generate<R: Rng>(rng: &mut R) -> Cone {
-        Cone::new(rng.gen::<Real>().abs(), rng.gen::<Real>().abs())
+        Cone::new(rng.random::<Real>().abs(), rng.random::<Real>().abs())
     }
 }
 
 impl DefaultGen for Cylinder
 where
-    Standard: Distribution<Real>,
+    StandardUniform: Distribution<Real>,
 {
     fn generate<R: Rng>(rng: &mut R) -> Cylinder {
-        Cylinder::new(rng.gen::<Real>().abs(), rng.gen::<Real>().abs())
+        Cylinder::new(rng.random::<Real>().abs(), rng.random::<Real>().abs())
     }
 }
 
 impl DefaultGen for Segment
 where
-    Standard: Distribution<Point<Real>>,
+    StandardUniform: Distribution<Point<Real>>,
 {
     fn generate<R: Rng>(rng: &mut R) -> Segment {
-        Segment::new(rng.gen(), rng.gen())
+        Segment::new(rng.random(), rng.random())
     }
 }
 
 impl DefaultGen for Triangle
 where
-    Standard: Distribution<Point<Real>>,
+    StandardUniform: Distribution<Point<Real>>,
 {
     fn generate<R: Rng>(rng: &mut R) -> Triangle {
-        Triangle::new(rng.gen(), rng.gen(), rng.gen())
+        Triangle::new(rng.random(), rng.random(), rng.random())
     }
 }
 
 impl DefaultGen for ConvexPolyhedron
 where
-    Standard: Distribution<Real>,
+    StandardUniform: Distribution<Real>,
 {
     fn generate<R: Rng>(rng: &mut R) -> ConvexPolyhedron {
         // It is recommended to have at most 100 points.
         // Otherwise, a smarter structure like the DK hierarchy would be needed.
-        let pts: Vec<_> = (0..100).map(|_| rng.gen()).collect();
+        let pts: Vec<_> = (0..100).map(|_| rng.random()).collect();
         ConvexPolyhedron::from_convex_hull(&pts).unwrap()
     }
 }
 
 impl DefaultGen for Ray
 where
-    Standard: Distribution<Vector<Real>>,
+    StandardUniform: Distribution<Vector<Real>>,
 {
     fn generate<R: Rng>(rng: &mut R) -> Ray {
         // The generate ray will always point to the origin.
-        let shift = rng.gen::<Vector<Real>>() * na::convert::<_, Real>(10.0f64);
+        let shift = rng.random::<Vector<Real>>() * na::convert::<_, Real>(10.0f64);
         Ray::new(Point::origin() + shift, -shift)
     }
 }
 
 impl DefaultGen for Aabb
 where
-    Standard: Distribution<Vector<Real>>,
+    StandardUniform: Distribution<Vector<Real>>,
 {
     fn generate<R: Rng>(rng: &mut R) -> Aabb {
         // an Aabb centered at the origin.
-        let half_extents = rng.gen::<Vector<Real>>().abs();
+        let half_extents = rng.random::<Vector<Real>>().abs();
         Aabb::new(
             Point::origin() + (-half_extents),
             Point::origin() + half_extents,
@@ -160,10 +160,10 @@ where
 
 impl DefaultGen for BoundingSphere
 where
-    Standard: Distribution<Real>,
+    StandardUniform: Distribution<Real>,
 {
     fn generate<R: Rng>(rng: &mut R) -> BoundingSphere {
         // a bounding sphere centered at the origin.
-        BoundingSphere::new(Point::origin(), rng.gen::<Real>().abs())
+        BoundingSphere::new(Point::origin(), rng.random::<Real>().abs())
     }
 }
diff --git a/crates/parry3d/benches/common/generators.rs b/crates/parry3d/benches/common/generators.rs
@@ -3,7 +3,9 @@ use parry3d::shape::TriMesh;
 use rand::Rng;
 
 pub fn generate_trimesh_around_origin<R: Rng>(rng: &mut R) -> TriMesh {
-    let pts = (0..3000).map(|_| rng.gen::<Point3<f32>>() * 3.0).collect();
+    let pts = (0..3000)
+        .map(|_| rng.random::<Point3<f32>>() * 3.0)
+        .collect();
     let indices = (0..1000).map(|i| [i * 3, i * 3 + 1, i * 3 + 2]).collect();
 
     TriMesh::new(pts, indices).unwrap()

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ use parry3d::math::{Point, Real, Vector};`
`7`	`7`	`use parry3d::query::Ray;`
`8`	`8`	`use parry3d::shape::ConvexPolyhedron;`
`9`	`9`	`use parry3d::shape::{Ball, Capsule, Cone, Cuboid, Cylinder, Segment, Triangle};`
`10`		`-use rand::distributions::{Distribution, Standard};`
	`10`	`+use rand::distr::{Distribution, StandardUniform};`
`11`	`11`	`use rand::Rng;`
`12`	`12`
`13`	`13`	`pub trait DefaultGen {`
`@@ -22,7 +22,7 @@ macro_rules! impl_rand_default_gen (`
`22`	`22`	`($t: ty) => {`
`23`	`23`	`impl DefaultGen for $t {`
`24`	`24`	`fn generate<R: Rng>(rng: &mut R) -> $t {`
`25`		`- rng.gen::<$t>()`
	`25`	`+ rng.random::<$t>()`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`	`}`
`@@ -56,101 +56,101 @@ impl_rand_default_gen!(bool);`
`56`	`56`
`57`	`57`	`impl DefaultGen for Ball`
`58`	`58`	`where`
`59`		`- Standard: Distribution<Real>,`
	`59`	`+ StandardUniform: Distribution<Real>,`
`60`	`60`	`{`
`61`	`61`	`fn generate<R: Rng>(rng: &mut R) -> Ball {`
`62`		`- Ball::new(rng.gen::<f32>().abs())`
	`62`	`+ Ball::new(rng.random::<f32>().abs())`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`impl DefaultGen for Cuboid`
`67`	`67`	`where`
`68`		`- Standard: Distribution<Vector<Real>>,`
	`68`	`+ StandardUniform: Distribution<Vector<Real>>,`
`69`	`69`	`{`
`70`	`70`	`fn generate<R: Rng>(rng: &mut R) -> Cuboid {`
`71`		`- Cuboid::new(rng.gen::<Vector<Real>>().abs())`
	`71`	`+ Cuboid::new(rng.random::<Vector<Real>>().abs())`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`impl DefaultGen for Capsule`
`76`	`76`	`where`
`77`		`- Standard: Distribution<Real>,`
	`77`	`+ StandardUniform: Distribution<Real>,`
`78`	`78`	`{`
`79`	`79`	`fn generate<R: Rng>(rng: &mut R) -> Capsule {`
`80`	`80`	`Capsule::new(`
`81`		`- rng.gen::<Point<Real>>(),`
`82`		`- rng.gen::<Point<Real>>(),`
`83`		`- rng.gen::<Real>().abs(),`
	`81`	`+ rng.random::<Point<Real>>(),`
	`82`	`+ rng.random::<Point<Real>>(),`
	`83`	`+ rng.random::<Real>().abs(),`
`84`	`84`	`)`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`impl DefaultGen for Cone`
`89`	`89`	`where`
`90`		`- Standard: Distribution<Real>,`
	`90`	`+ StandardUniform: Distribution<Real>,`
`91`	`91`	`{`
`92`	`92`	`fn generate<R: Rng>(rng: &mut R) -> Cone {`
`93`		`- Cone::new(rng.gen::<Real>().abs(), rng.gen::<Real>().abs())`
	`93`	`+ Cone::new(rng.random::<Real>().abs(), rng.random::<Real>().abs())`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`impl DefaultGen for Cylinder`
`98`	`98`	`where`
`99`		`- Standard: Distribution<Real>,`
	`99`	`+ StandardUniform: Distribution<Real>,`
`100`	`100`	`{`
`101`	`101`	`fn generate<R: Rng>(rng: &mut R) -> Cylinder {`
`102`		`- Cylinder::new(rng.gen::<Real>().abs(), rng.gen::<Real>().abs())`
	`102`	`+ Cylinder::new(rng.random::<Real>().abs(), rng.random::<Real>().abs())`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`impl DefaultGen for Segment`
`107`	`107`	`where`
`108`		`- Standard: Distribution<Point<Real>>,`
	`108`	`+ StandardUniform: Distribution<Point<Real>>,`
`109`	`109`	`{`
`110`	`110`	`fn generate<R: Rng>(rng: &mut R) -> Segment {`
`111`		`- Segment::new(rng.gen(), rng.gen())`
	`111`	`+ Segment::new(rng.random(), rng.random())`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`impl DefaultGen for Triangle`
`116`	`116`	`where`
`117`		`- Standard: Distribution<Point<Real>>,`
	`117`	`+ StandardUniform: Distribution<Point<Real>>,`
`118`	`118`	`{`
`119`	`119`	`fn generate<R: Rng>(rng: &mut R) -> Triangle {`
`120`		`- Triangle::new(rng.gen(), rng.gen(), rng.gen())`
	`120`	`+ Triangle::new(rng.random(), rng.random(), rng.random())`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`impl DefaultGen for ConvexPolyhedron`
`125`	`125`	`where`
`126`		`- Standard: Distribution<Real>,`
	`126`	`+ StandardUniform: Distribution<Real>,`
`127`	`127`	`{`
`128`	`128`	`fn generate<R: Rng>(rng: &mut R) -> ConvexPolyhedron {`
`129`	`129`	`// It is recommended to have at most 100 points.`
`130`	`130`	`// Otherwise, a smarter structure like the DK hierarchy would be needed.`
`131`		`- let pts: Vec<_> = (0..100).map(\|_\| rng.gen()).collect();`
	`131`	`+ let pts: Vec<_> = (0..100).map(\|_\| rng.random()).collect();`
`132`	`132`	`ConvexPolyhedron::from_convex_hull(&pts).unwrap()`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`impl DefaultGen for Ray`
`137`	`137`	`where`
`138`		`- Standard: Distribution<Vector<Real>>,`
	`138`	`+ StandardUniform: Distribution<Vector<Real>>,`
`139`	`139`	`{`
`140`	`140`	`fn generate<R: Rng>(rng: &mut R) -> Ray {`
`141`	`141`	`// The generate ray will always point to the origin.`
`142`		`- let shift = rng.gen::<Vector<Real>>() * na::convert::<_, Real>(10.0f64);`
	`142`	`+ let shift = rng.random::<Vector<Real>>() * na::convert::<_, Real>(10.0f64);`
`143`	`143`	`Ray::new(Point::origin() + shift, -shift)`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`impl DefaultGen for Aabb`
`148`	`148`	`where`
`149`		`- Standard: Distribution<Vector<Real>>,`
	`149`	`+ StandardUniform: Distribution<Vector<Real>>,`
`150`	`150`	`{`
`151`	`151`	`fn generate<R: Rng>(rng: &mut R) -> Aabb {`
`152`	`152`	`// an Aabb centered at the origin.`
`153`		`- let half_extents = rng.gen::<Vector<Real>>().abs();`
	`153`	`+ let half_extents = rng.random::<Vector<Real>>().abs();`
`154`	`154`	`Aabb::new(`
`155`	`155`	`Point::origin() + (-half_extents),`
`156`	`156`	`Point::origin() + half_extents,`
`@@ -160,10 +160,10 @@ where`
`160`	`160`
`161`	`161`	`impl DefaultGen for BoundingSphere`
`162`	`162`	`where`
`163`		`- Standard: Distribution<Real>,`
	`163`	`+ StandardUniform: Distribution<Real>,`
`164`	`164`	`{`
`165`	`165`	`fn generate<R: Rng>(rng: &mut R) -> BoundingSphere {`
`166`	`166`	`// a bounding sphere centered at the origin.`
`167`		`- BoundingSphere::new(Point::origin(), rng.gen::<Real>().abs())`
	`167`	`+ BoundingSphere::new(Point::origin(), rng.random::<Real>().abs())`
`168`	`168`	`}`
`169`	`169`	`}`