Add all the missing docs.

src/geometry/collider.rs

@@ -191,6 +191,7 @@ impl ColliderBuilder {
         self.density.unwrap_or(default_density)
     }
 
+    /// Initialize a new collider builder with a compound shape.
     pub fn compound(shapes: Vec<(Isometry<Real>, SharedShape)>) -> Self {
         Self::new(SharedShape::compound(shapes))
     }
@@ -357,29 +358,46 @@ impl ColliderBuilder {
         ))
     }
 
+    /// Initializes a new collider builder with a 2D convex polygon or 3D convex polyhedron
+    /// obtained after computing the convex-hull of the given points.
     pub fn convex_hull(points: &[Point<Real>]) -> Option<Self> {
         SharedShape::convex_hull(points).map(|cp| Self::new(cp))
     }
 
+    /// Initializes a new collider builder with a round 2D convex polygon or 3D convex polyhedron
+    /// obtained after computing the convex-hull of the given points. The shape is dilated
+    /// by a sphere of radius `border_radius`.
     pub fn round_convex_hull(points: &[Point<Real>], border_radius: Real) -> Option<Self> {
         SharedShape::round_convex_hull(points, border_radius).map(|cp| Self::new(cp))
     }
 
+    /// Creates a new collider builder that is a convex polygon formed by the
+    /// given polyline assumed to be convex (no convex-hull will be automatically
+    /// computed).
     #[cfg(feature = "dim2")]
     pub fn convex_polyline(points: Vec<Point<Real>>) -> Option<Self> {
         SharedShape::convex_polyline(points).map(|cp| Self::new(cp))
     }
 
+    /// Creates a new collider builder that is a round convex polygon formed by the
+    /// given polyline assumed to be convex (no convex-hull will be automatically
+    /// computed). The polygon shape is dilated by a sphere of radius `border_radius`.
     #[cfg(feature = "dim2")]
     pub fn round_convex_polyline(points: Vec<Point<Real>>, border_radius: Real) -> Option<Self> {
         SharedShape::round_convex_polyline(points, border_radius).map(|cp| Self::new(cp))
     }
 
+    /// Creates a new collider builder that is a convex polyhedron formed by the
+    /// given triangle-mesh assumed to be convex (no convex-hull will be automatically
+    /// computed).
     #[cfg(feature = "dim3")]
     pub fn convex_mesh(points: Vec<Point<Real>>, indices: &[[u32; 3]]) -> Option<Self> {
         SharedShape::convex_mesh(points, indices).map(|cp| Self::new(cp))
     }
 
+    /// Creates a new collider builder that is a round convex polyhedron formed by the
+    /// given triangle-mesh assumed to be convex (no convex-hull will be automatically
+    /// computed). The triangle mesh shape is dilated by a sphere of radius `border_radius`.
     #[cfg(feature = "dim3")]
     pub fn round_convex_mesh(
         points: Vec<Point<Real>>,

src/geometry/collider_set.rs

@@ -12,10 +12,12 @@ use std::ops::{Index, IndexMut};
 pub struct ColliderHandle(pub(crate) crate::data::arena::Index);
 
 impl ColliderHandle {
+    /// Converts this handle into its (index, generation) components.
     pub fn into_raw_parts(self) -> (usize, u64) {
         self.0.into_raw_parts()
     }
 
+    /// Reconstructs an handle from its (index, generation) components.
     pub fn from_raw_parts(id: usize, generation: u64) -> Self {
         Self(crate::data::arena::Index::from_raw_parts(id, generation))
     }

src/geometry/contact_pair.rs

@@ -62,6 +62,7 @@ pub struct ContactPair {
     ///
     /// All contact manifold contain themselves contact points between the colliders.
     pub manifolds: Vec<ContactManifold>,
+    /// Is there any active contact in this contact pair?
     pub has_any_active_contact: bool,
     pub(crate) workspace: Option<ContactManifoldsWorkspace>,
 }
@@ -95,18 +96,31 @@ pub struct ContactManifoldData {
     // contact preparation method.
     /// Flags used to control some aspects of the constraints solver for this contact manifold.
     pub solver_flags: SolverFlags,
+    /// The world-space contact normal shared by all the contact in this contact manifold.
     pub normal: Vector<Real>,
+    /// The contacts that will be seen by the constraints solver for computing forces.
     pub solver_contacts: Vec<SolverContact>,
 }
 
+/// A contact seen by the constraints solver for computing forces.
 #[derive(Copy, Clone, Debug)]
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 pub struct SolverContact {
+    /// The world-space contact point.
     pub point: Point<Real>,
+    /// The distance between the two original contacts points along the contact normal.
+    /// If negative, this is measures the penetration depth.
     pub dist: Real,
+    /// The effective friction coefficient at this contact point.
     pub friction: Real,
+    /// The effective restitution coefficient at this contact point.
     pub restitution: Real,
+    /// The artificially add relative velocity at the contact point.
+    /// This is set to zero by default. Set to a non-zero value to
+    /// simulate, e.g., conveyor belts.
     pub surface_velocity: Vector<Real>,
+    /// Associated contact data used to warm-start the constraints
+    /// solver.
     pub data: ContactData,
 }
 
@@ -132,6 +146,8 @@ impl ContactManifoldData {
         }
     }
 
+    /// Number of actives contacts, i.e., contacts that will be seen by
+    /// the constraints solver.
     #[inline]
     pub fn num_active_contacts(&self) -> usize {
         self.solver_contacts.len()

src/geometry/mod.rs

@@ -14,7 +14,9 @@ pub use self::pair_filter::{ContactPairFilter, IntersectionPairFilter, PairFilte
 
 pub use parry::query::TrackedContact;
 
+/// A contact between two colliders.
 pub type Contact = parry::query::TrackedContact<ContactData>;
+/// A contact manifold between two colliders.
 pub type ContactManifold = parry::query::ContactManifold<ContactManifoldData, ContactData>;
 /// A segment shape.
 pub type Segment = parry::shape::Segment;