Move all the contact manifold computations out of Rapier.

src/data/arena.rs

@@ -3,7 +3,7 @@
 //! See  https://github.com/fitzgen/generational-arena/blob/master/src/lib.rs.
 //! This has been modified to have a fully deterministic deserialization (including for the order of
 //! Index attribution after a deserialization of the arena.
-use buckler::partitioning::IndexedData;
+use eagl::partitioning::IndexedData;
 use std::cmp;
 use std::iter::{self, Extend, FromIterator, FusedIterator};
 use std::mem;

src/data/hashmap.rs

@@ -1,137 +0,0 @@
-//! A hash-map that behaves deterministically when the
-//! `enhanced-determinism` feature is enabled.
-
-#[cfg(all(feature = "enhanced-determinism", feature = "serde-serialize"))]
-use indexmap::IndexMap as StdHashMap;
-#[cfg(all(not(feature = "enhanced-determinism"), feature = "serde-serialize"))]
-use std::collections::HashMap as StdHashMap;
-
-/// Serializes only the capacity of a hash-map instead of its actual content.
-#[cfg(feature = "serde-serialize")]
-pub fn serialize_hashmap_capacity<S: serde::Serializer, K, V, H: std::hash::BuildHasher>(
-    map: &StdHashMap<K, V, H>,
-    s: S,
-) -> Result<S::Ok, S::Error> {
-    s.serialize_u64(map.capacity() as u64)
-}
-
-/// Creates a new hash-map with its capacity deserialized from `d`.
-#[cfg(feature = "serde-serialize")]
-pub fn deserialize_hashmap_capacity<
-    'de,
-    D: serde::Deserializer<'de>,
-    K,
-    V,
-    H: std::hash::BuildHasher + Default,
->(
-    d: D,
-) -> Result<StdHashMap<K, V, H>, D::Error> {
-    struct CapacityVisitor;
-    impl<'de> serde::de::Visitor<'de> for CapacityVisitor {
-        type Value = u64;
-
-        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-            write!(formatter, "an integer between 0 and 2^64")
-        }
-
-        fn visit_u64<E: serde::de::Error>(self, val: u64) -> Result<Self::Value, E> {
-            Ok(val)
-        }
-    }
-
-    let capacity = d.deserialize_u64(CapacityVisitor)? as usize;
-    Ok(StdHashMap::with_capacity_and_hasher(
-        capacity,
-        Default::default(),
-    ))
-}
-
-/*
- * FxHasher taken from rustc_hash, except that it does not depend on the pointer size.
- */
-#[cfg(feature = "enhanced-determinism")]
-pub type FxHashMap32<K, V> = indexmap::IndexMap<K, V, std::hash::BuildHasherDefault<FxHasher32>>;
-#[cfg(feature = "enhanced-determinism")]
-pub use {self::FxHashMap32 as HashMap, indexmap::map::Entry};
-#[cfg(not(feature = "enhanced-determinism"))]
-pub use {rustc_hash::FxHashMap as HashMap, std::collections::hash_map::Entry};
-
-const K: u32 = 0x9e3779b9;
-
-// Same as FxHasher, but with the guarantee that the internal hash is
-// an u32 instead of something that depends on the platform.
-pub struct FxHasher32 {
-    hash: u32,
-}
-
-impl Default for FxHasher32 {
-    #[inline]
-    fn default() -> FxHasher32 {
-        FxHasher32 { hash: 0 }
-    }
-}
-
-impl FxHasher32 {
-    #[inline]
-    fn add_to_hash(&mut self, i: u32) {
-        use std::ops::BitXor;
-        self.hash = self.hash.rotate_left(5).bitxor(i).wrapping_mul(K);
-    }
-}
-
-impl std::hash::Hasher for FxHasher32 {
-    #[inline]
-    fn write(&mut self, mut bytes: &[u8]) {
-        use std::convert::TryInto;
-        let read_u32 = |bytes: &[u8]| u32::from_ne_bytes(bytes[..4].try_into().unwrap());
-        let mut hash = FxHasher32 { hash: self.hash };
-        assert!(std::mem::size_of::<u32>() <= 8);
-        while bytes.len() >= std::mem::size_of::<u32>() {
-            hash.add_to_hash(read_u32(bytes) as u32);
-            bytes = &bytes[std::mem::size_of::<u32>()..];
-        }
-        if (std::mem::size_of::<u32>() > 4) && (bytes.len() >= 4) {
-            hash.add_to_hash(u32::from_ne_bytes(bytes[..4].try_into().unwrap()) as u32);
-            bytes = &bytes[4..];
-        }
-        if (std::mem::size_of::<u32>() > 2) && bytes.len() >= 2 {
-            hash.add_to_hash(u16::from_ne_bytes(bytes[..2].try_into().unwrap()) as u32);
-            bytes = &bytes[2..];
-        }
-        if (std::mem::size_of::<u32>() > 1) && bytes.len() >= 1 {
-            hash.add_to_hash(bytes[0] as u32);
-        }
-        self.hash = hash.hash;
-    }
-
-    #[inline]
-    fn write_u8(&mut self, i: u8) {
-        self.add_to_hash(i as u32);
-    }
-
-    #[inline]
-    fn write_u16(&mut self, i: u16) {
-        self.add_to_hash(i as u32);
-    }
-
-    #[inline]
-    fn write_u32(&mut self, i: u32) {
-        self.add_to_hash(i as u32);
-    }
-
-    #[inline]
-    fn write_u64(&mut self, i: u64) {
-        self.add_to_hash(i as u32);
-        self.add_to_hash((i >> 32) as u32);
-    }
-
-    #[inline]
-    fn write_usize(&mut self, i: usize) {
-        self.add_to_hash(i as u32);
-    }
-
-    #[inline]
-    fn finish(&self) -> u64 {
-        self.hash as u64
-    }
-}

src/data/maybe_serializable_data.rs

@@ -1,17 +0,0 @@
-use downcast_rs::{impl_downcast, DowncastSync};
-#[cfg(feature = "serde-serialize")]
-use erased_serde::Serialize;
-
-/// Piece of data that may be serializable.
-pub trait MaybeSerializableData: DowncastSync {
-    /// Convert this shape as a serializable entity.
-    #[cfg(feature = "serde-serialize")]
-    fn as_serialize(&self) -> Option<(u32, &dyn Serialize)> {
-        None
-    }
-
-    /// Clones `self`.
-    fn clone_dyn(&self) -> Box<dyn MaybeSerializableData>;
-}
-
-impl_downcast!(sync MaybeSerializableData);

src/data/mod.rs

@@ -1,11 +1,9 @@
 //! Data structures modified with guaranteed deterministic behavior after deserialization.
 
 pub use self::coarena::Coarena;
-pub use self::maybe_serializable_data::MaybeSerializableData;
+pub use eagl::utils::MaybeSerializableData;
 
 pub mod arena;
 mod coarena;
 pub(crate) mod graph;
-pub(crate) mod hashmap;
-mod maybe_serializable_data;
 pub mod pubsub;