Rename cdl to parry.

src/geometry/broad_phase_multi_sap.rs

@@ -3,8 +3,8 @@ use crate::dynamics::RigidBodySet;
 use crate::geometry::{ColliderHandle, ColliderSet, RemovedCollider};
 use crate::math::{Point, Real, Vector, DIM};
 use bit_vec::BitVec;
-use cdl::bounding_volume::{BoundingVolume, AABB};
-use cdl::utils::hashmap::HashMap;
+use parry::bounding_volume::{BoundingVolume, AABB};
+use parry::utils::hashmap::HashMap;
 use std::cmp::Ordering;
 use std::ops::{Index, IndexMut};
 
@@ -477,8 +477,8 @@ pub struct BroadPhase {
     #[cfg_attr(
         feature = "serde-serialize",
         serde(
-            serialize_with = "cdl::utils::hashmap::serialize_hashmap_capacity",
-            deserialize_with = "cdl::utils::hashmap::deserialize_hashmap_capacity"
+            serialize_with = "parry::utils::hashmap::serialize_hashmap_capacity",
+            deserialize_with = "parry::utils::hashmap::deserialize_hashmap_capacity"
         )
     )]
     reporting: HashMap<(u32, u32), bool>, // Workspace

src/geometry/collider.rs

@@ -1,9 +1,9 @@
-use crate::cdl::transformation::vhacd::VHACDParameters;
 use crate::dynamics::{CoefficientCombineRule, MassProperties, RigidBodyHandle};
 use crate::geometry::{InteractionGroups, SharedShape};
 use crate::math::{AngVector, Isometry, Point, Real, Rotation, Vector, DIM};
-use cdl::bounding_volume::AABB;
-use cdl::shape::Shape;
+use crate::parry::transformation::vhacd::VHACDParameters;
+use parry::bounding_volume::AABB;
+use parry::shape::Shape;
 
 bitflags::bitflags! {
     #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]

src/geometry/collider_set.rs

@@ -2,7 +2,7 @@ use crate::data::arena::Arena;
 use crate::data::pubsub::PubSub;
 use crate::dynamics::{RigidBodyHandle, RigidBodySet};
 use crate::geometry::Collider;
-use cdl::partitioning::IndexedData;
+use parry::partitioning::IndexedData;
 use std::ops::{Index, IndexMut};
 
 /// The unique identifier of a collider added to a collider set.

src/geometry/contact_pair.rs

@@ -1,7 +1,7 @@
 use crate::dynamics::{BodyPair, RigidBodyHandle};
 use crate::geometry::{ColliderPair, ContactManifold};
 use crate::math::{Point, Real, Vector};
-use cdl::query::ContactManifoldsWorkspace;
+use parry::query::ContactManifoldsWorkspace;
 
 bitflags::bitflags! {
     #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]

src/geometry/mod.rs

@@ -10,39 +10,39 @@ pub use self::interaction_graph::{
 };
 pub use self::interaction_groups::InteractionGroups;
 pub use self::narrow_phase::NarrowPhase;
-pub use self::pair_filter::{ContactPairFilter, PairFilterContext, ProximityPairFilter};
+pub use self::pair_filter::{ContactPairFilter, IntersectionPairFilter, PairFilterContext};
 
-pub use cdl::query::TrackedContact;
+pub use parry::query::TrackedContact;
 
-pub type Contact = cdl::query::TrackedContact<ContactData>;
-pub type ContactManifold = cdl::query::ContactManifold<ContactManifoldData, ContactData>;
+pub type Contact = parry::query::TrackedContact<ContactData>;
+pub type ContactManifold = parry::query::ContactManifold<ContactManifoldData, ContactData>;
 /// A segment shape.
-pub type Segment = cdl::shape::Segment;
+pub type Segment = parry::shape::Segment;
 /// A cuboid shape.
-pub type Cuboid = cdl::shape::Cuboid;
+pub type Cuboid = parry::shape::Cuboid;
 /// A triangle shape.
-pub type Triangle = cdl::shape::Triangle;
+pub type Triangle = parry::shape::Triangle;
 /// A ball shape.
-pub type Ball = cdl::shape::Ball;
+pub type Ball = parry::shape::Ball;
 /// A capsule shape.
-pub type Capsule = cdl::shape::Capsule;
+pub type Capsule = parry::shape::Capsule;
 /// A heightfield shape.
-pub type HeightField = cdl::shape::HeightField;
+pub type HeightField = parry::shape::HeightField;
 /// A cylindrical shape.
 #[cfg(feature = "dim3")]
-pub type Cylinder = cdl::shape::Cylinder;
+pub type Cylinder = parry::shape::Cylinder;
 /// A cone shape.
 #[cfg(feature = "dim3")]
-pub type Cone = cdl::shape::Cone;
+pub type Cone = parry::shape::Cone;
 /// An axis-aligned bounding box.
-pub type AABB = cdl::bounding_volume::AABB;
+pub type AABB = parry::bounding_volume::AABB;
 /// A ray that can be cast against colliders.
-pub type Ray = cdl::query::Ray;
+pub type Ray = parry::query::Ray;
 /// The intersection between a ray and a  collider.
-pub type RayIntersection = cdl::query::RayIntersection;
+pub type RayIntersection = parry::query::RayIntersection;
 /// The the projection of a point on a collider.
-pub type PointProjection = cdl::query::PointProjection;
-pub use cdl::shape::SharedShape;
+pub type PointProjection = parry::query::PointProjection;
+pub use parry::shape::SharedShape;
 
 #[derive(Copy, Clone, Hash, Debug)]
 /// Events occurring when two collision objects start or stop being in contact (or penetration).
@@ -84,18 +84,18 @@ impl IntersectionEvent {
 pub(crate) use self::broad_phase_multi_sap::{BroadPhasePairEvent, ColliderPair};
 pub(crate) use self::collider_set::RemovedCollider;
 pub(crate) use self::narrow_phase::ContactManifoldIndex;
-pub(crate) use cdl::partitioning::SimdQuadTree;
-pub use cdl::shape::*;
+pub(crate) use parry::partitioning::SimdQuadTree;
+pub use parry::shape::*;
 
 #[cfg(feature = "serde-serialize")]
 pub(crate) fn default_persistent_query_dispatcher(
-) -> std::sync::Arc<dyn cdl::query::PersistentQueryDispatcher<ContactManifoldData, ContactData>> {
-    std::sync::Arc::new(cdl::query::DefaultQueryDispatcher)
+) -> std::sync::Arc<dyn parry::query::PersistentQueryDispatcher<ContactManifoldData, ContactData>> {
+    std::sync::Arc::new(parry::query::DefaultQueryDispatcher)
 }
 
 #[cfg(feature = "serde-serialize")]
-pub(crate) fn default_query_dispatcher() -> std::sync::Arc<dyn cdl::query::QueryDispatcher> {
-    std::sync::Arc::new(cdl::query::DefaultQueryDispatcher)
+pub(crate) fn default_query_dispatcher() -> std::sync::Arc<dyn parry::query::QueryDispatcher> {
+    std::sync::Arc::new(parry::query::DefaultQueryDispatcher)
 }
 
 mod broad_phase_multi_sap;

src/geometry/narrow_phase.rs

@@ -6,14 +6,14 @@ use crate::data::Coarena;
 use crate::dynamics::{BodyPair, CoefficientCombineRule, RigidBodySet};
 use crate::geometry::{
     BroadPhasePairEvent, ColliderGraphIndex, ColliderHandle, ContactData, ContactEvent,
-    ContactManifoldData, ContactPairFilter, IntersectionEvent, PairFilterContext,
-    ProximityPairFilter, RemovedCollider, SolverContact, SolverFlags,
+    ContactManifoldData, ContactPairFilter, IntersectionEvent, IntersectionPairFilter,
+    PairFilterContext, RemovedCollider, SolverContact, SolverFlags,
 };
 use crate::geometry::{ColliderSet, ContactManifold, ContactPair, InteractionGraph};
 use crate::math::{Real, Vector};
 use crate::pipeline::EventHandler;
-use cdl::query::{DefaultQueryDispatcher, PersistentQueryDispatcher};
-use cdl::utils::IsometryOpt;
+use parry::query::{DefaultQueryDispatcher, PersistentQueryDispatcher};
+use parry::utils::IsometryOpt;
 use std::collections::HashMap;
 use std::sync::Arc;
 
@@ -387,7 +387,7 @@ impl NarrowPhase {
         &mut self,
         bodies: &RigidBodySet,
         colliders: &ColliderSet,
-        pair_filter: Option<&dyn ProximityPairFilter>,
+        pair_filter: Option<&dyn IntersectionPairFilter>,
         events: &dyn EventHandler,
     ) {
         let nodes = &self.intersection_graph.graph.nodes;

src/geometry/pair_filter.rs

@@ -41,7 +41,7 @@ pub trait ContactPairFilter: Send + Sync {
 ///
 /// This can be used to apply custom logic in order to decide whether two colliders
 /// should have their intersection computed by the narrow-phase.
-pub trait ProximityPairFilter: Send + Sync {
+pub trait IntersectionPairFilter: Send + Sync {
     /// Applies the intersection pair filter.
     ///
     /// Note that using an intersection pair filter will replace the default intersection filtering