First round deleting the component sets.

5 files changed, 168 insertions, 419 deletions

diff --git a/src/pipeline/collision_pipeline.rs b/src/pipeline/collision_pipeline.rs
index 009dfa9..48a11e7 100644
--- a/src/pipeline/collision_pipeline.rs
+++ b/src/pipeline/collision_pipeline.rs
@@ -1,14 +1,8 @@
 //! Physics pipeline structures.
 
-use crate::data::{ComponentSet, ComponentSetMut, ComponentSetOption};
-use crate::dynamics::{
-    RigidBodyActivation, RigidBodyChanges, RigidBodyColliders, RigidBodyDominance, RigidBodyHandle,
-    RigidBodyIds, RigidBodyMassProps, RigidBodyPosition, RigidBodyType, RigidBodyVelocity,
-};
+use crate::dynamics::RigidBodyHandle;
 use crate::geometry::{
-    BroadPhase, BroadPhasePairEvent, ColliderBroadPhaseData, ColliderChanges, ColliderFlags,
-    ColliderHandle, ColliderMassProps, ColliderMaterial, ColliderPair, ColliderParent,
-    ColliderPosition, ColliderShape, ColliderType, NarrowPhase,
+    BroadPhase, BroadPhasePairEvent, ColliderChanges, ColliderHandle, ColliderPair, NarrowPhase,
 };
 use crate::math::Real;
 use crate::pipeline::{EventHandler, PhysicsHooks};
@@ -48,32 +42,19 @@ impl CollisionPipeline {
         }
     }
 
-    fn detect_collisions<Bodies, Colliders>(
+    fn detect_collisions(
         &mut self,
         prediction_distance: Real,
         broad_phase: &mut BroadPhase,
         narrow_phase: &mut NarrowPhase,
-        bodies: &mut Bodies,
-        colliders: &mut Colliders,
+        bodies: &mut RigidBodySet,
+        colliders: &mut ColliderSet,
         modified_colliders: &[ColliderHandle],
         removed_colliders: &[ColliderHandle],
-        hooks: &dyn PhysicsHooks<Bodies, Colliders>,
+        hooks: &dyn PhysicsHooks,
         events: &dyn EventHandler,
         handle_user_changes: bool,
-    ) where
-        Bodies: ComponentSetMut<RigidBodyActivation>
-            + ComponentSet<RigidBodyType>
-            + ComponentSetMut<RigidBodyIds>
-            + ComponentSet<RigidBodyDominance>,
-        Colliders: ComponentSetMut<ColliderBroadPhaseData>
-            + ComponentSet<ColliderChanges>
-            + ComponentSet<ColliderPosition>
-            + ComponentSet<ColliderShape>
-            + ComponentSetOption<ColliderParent>
-            + ComponentSet<ColliderType>
-            + ComponentSet<ColliderMaterial>
-            + ComponentSet<ColliderFlags>,
-    {
+    ) {
         // Update broad-phase.
         self.broad_phase_events.clear();
         self.broadphase_collider_pairs.clear();
@@ -112,7 +93,7 @@ impl CollisionPipeline {
 
     fn clear_modified_colliders(
         &mut self,
-        colliders: &mut impl ComponentSetMut<ColliderChanges>,
+        colliders: &mut ColliderSet,
         modified_colliders: &mut Vec<ColliderHandle>,
     ) {
         for handle in modified_colliders.drain(..) {
@@ -129,7 +110,7 @@ impl CollisionPipeline {
         narrow_phase: &mut NarrowPhase,
         bodies: &mut RigidBodySet,
         colliders: &mut ColliderSet,
-        hooks: &dyn PhysicsHooks<RigidBodySet, ColliderSet>,
+        hooks: &dyn PhysicsHooks,
         events: &dyn EventHandler,
     ) {
         let mut modified_bodies = bodies.take_modified();
@@ -151,38 +132,19 @@ impl CollisionPipeline {
     }
 
     /// Executes one step of the collision detection.
-    pub fn step_generic<Bodies, Colliders>(
+    pub fn step_generic(
         &mut self,
         prediction_distance: Real,
         broad_phase: &mut BroadPhase,
         narrow_phase: &mut NarrowPhase,
-        bodies: &mut Bodies,
-        colliders: &mut Colliders,
+        bodies: &mut RigidBodySet,
+        colliders: &mut ColliderSet,
         modified_bodies: &mut Vec<RigidBodyHandle>,
         modified_colliders: &mut Vec<ColliderHandle>,
         removed_colliders: &mut Vec<ColliderHandle>,
-        hooks: &dyn PhysicsHooks<Bodies, Colliders>,
+        hooks: &dyn PhysicsHooks,
         events: &dyn EventHandler,
-    ) where
-        Bodies: ComponentSetMut<RigidBodyPosition>
-            + ComponentSetMut<RigidBodyVelocity>
-            + ComponentSetMut<RigidBodyIds>
-            + ComponentSetMut<RigidBodyActivation>
-            + ComponentSetMut<RigidBodyChanges>
-            + ComponentSetMut<RigidBodyMassProps>
-            + ComponentSet<RigidBodyColliders>
-            + ComponentSet<RigidBodyDominance>
-            + ComponentSet<RigidBodyType>,
-        Colliders: ComponentSetMut<ColliderBroadPhaseData>
-            + ComponentSetMut<ColliderChanges>
-            + ComponentSetMut<ColliderPosition>
-            + ComponentSet<ColliderShape>
-            + ComponentSetOption<ColliderParent>
-            + ComponentSet<ColliderType>
-            + ComponentSet<ColliderMaterial>
-            + ComponentSet<ColliderFlags>
-            + ComponentSet<ColliderMassProps>,
-    {
+    ) {
         super::user_changes::handle_user_changes_to_colliders(
             bodies,
             colliders,
diff --git a/src/pipeline/physics_hooks.rs b/src/pipeline/physics_hooks.rs
index 68a05d1..4024237 100644
--- a/src/pipeline/physics_hooks.rs
+++ b/src/pipeline/physics_hooks.rs
@@ -1,14 +1,14 @@
-use crate::dynamics::RigidBodyHandle;
-use crate::geometry::{ColliderHandle, ContactManifold, SolverContact, SolverFlags};
+use crate::dynamics::{RigidBodyHandle, RigidBodySet};
+use crate::geometry::{ColliderHandle, ColliderSet, ContactManifold, SolverContact, SolverFlags};
 use crate::math::{Real, Vector};
 use na::ComplexField;
 
 /// Context given to custom collision filters to filter-out collisions.
-pub struct PairFilterContext<'a, Bodies, Colliders> {
+pub struct PairFilterContext<'a> {
     /// The set of rigid-bodies.
-    pub bodies: &'a Bodies,
+    pub bodies: &'a RigidBodySet,
     /// The set of colliders.
-    pub colliders: &'a Colliders,
+    pub colliders: &'a ColliderSet,
     /// The handle of the first collider involved in the potential collision.
     pub collider1: ColliderHandle,
     /// The handle of the first collider involved in the potential collision.
@@ -20,11 +20,11 @@ pub struct PairFilterContext<'a, Bodies, Colliders> {
 }
 
 /// Context given to custom contact modifiers to modify the contacts seen by the constraints solver.
-pub struct ContactModificationContext<'a, Bodies, Colliders> {
+pub struct ContactModificationContext<'a> {
     /// The set of rigid-bodies.
-    pub bodies: &'a Bodies,
+    pub bodies: &'a RigidBodySet,
     /// The set of colliders.
-    pub colliders: &'a Colliders,
+    pub colliders: &'a ColliderSet,
     /// The handle of the first collider involved in the potential collision.
     pub collider1: ColliderHandle,
     /// The handle of the first collider involved in the potential collision.
@@ -45,7 +45,7 @@ pub struct ContactModificationContext<'a, Bodies, Colliders> {
     pub user_data: &'a mut u32,
 }
 
-impl<'a, Bodies, Colliders> ContactModificationContext<'a, Bodies, Colliders> {
+impl<'a> ContactModificationContext<'a> {
     /// Helper function to update `self` to emulate a oneway-platform.
     ///
     /// The "oneway" behavior will only allow contacts between two colliders
@@ -139,28 +139,24 @@ impl Default for ActiveHooks {
 //       not having Send+Sync isn't a problem.
 /// User-defined functions called by the physics engines during one timestep in order to customize its behavior.
 #[cfg(target_arch = "wasm32")]
-pub trait PhysicsHooks<Bodies, Colliders> {
+pub trait PhysicsHooks {
     /// Applies the contact pair filter.
-    fn filter_contact_pair(
-        &self,
-        _context: &PairFilterContext<Bodies, Colliders>,
-    ) -> Option<SolverFlags> {
+    fn filter_contact_pair(&self, _context: &PairFilterContext) -> Option<SolverFlags> {
         None
     }
 
     /// Applies the intersection pair filter.
-    fn filter_intersection_pair(&self, _context: &PairFilterContext<Bodies, Colliders>) -> bool {
+    fn filter_intersection_pair(&self, _context: &PairFilterContext) -> bool {
         false
     }
 
     /// Modifies the set of contacts seen by the constraints solver.
-    fn modify_solver_contacts(&self, _context: &mut ContactModificationContext<Bodies, Colliders>) {
-    }
+    fn modify_solver_contacts(&self, _context: &mut ContactModificationContext) {}
 }
 
 /// User-defined functions called by the physics engines during one timestep in order to customize its behavior.
 #[cfg(not(target_arch = "wasm32"))]
-pub trait PhysicsHooks<Bodies, Colliders>: Send + Sync {
+pub trait PhysicsHooks: Send + Sync {
     /// Applies the contact pair filter.
     ///
     /// Note that this method will only be called if at least one of the colliders
@@ -185,10 +181,7 @@ pub trait PhysicsHooks<Bodies, Colliders>: Send + Sync {
     /// will be taken into account by the constraints solver. If this returns
     /// `Some(SolverFlags::empty())` then the constraints solver will ignore these
     /// contacts.
-    fn filter_contact_pair(
-        &self,
-        _context: &PairFilterContext<Bodies, Colliders>,
-    ) -> Option<SolverFlags> {
+    fn filter_contact_pair(&self, _context: &PairFilterContext) -> Option<SolverFlags> {
         Some(SolverFlags::COMPUTE_IMPULSES)
     }
 
@@ -212,7 +205,7 @@ pub trait PhysicsHooks<Bodies, Colliders>: Send + Sync {
     /// not compute any intersection information for it.
     /// If this return `true` then the narrow-phase will compute intersection
     /// information for this pair.
-    fn filter_intersection_pair(&self, _context: &PairFilterContext<Bodies, Colliders>) -> bool {
+    fn filter_intersection_pair(&self, _context: &PairFilterContext) -> bool {
         true
     }
 
@@ -241,21 +234,17 @@ pub trait PhysicsHooks<Bodies, Colliders>: Send + Sync {
     /// as 0 and can be modified in `context.user_data`.
     ///
     /// The world-space contact normal can be modified in `context.normal`.
-    fn modify_solver_contacts(&self, _context: &mut ContactModificationContext<Bodies, Colliders>) {
-    }
+    fn modify_solver_contacts(&self, _context: &mut ContactModificationContext) {}
 }
 
-impl<Bodies, Colliders> PhysicsHooks<Bodies, Colliders> for () {
-    fn filter_contact_pair(
-        &self,
-        _context: &PairFilterContext<Bodies, Colliders>,
-    ) -> Option<SolverFlags> {
+impl PhysicsHooks for () {
+    fn filter_contact_pair(&self, _context: &PairFilterContext) -> Option<SolverFlags> {
         Some(SolverFlags::default())
     }
 
-    fn filter_intersection_pair(&self, _: &PairFilterContext<Bodies, Colliders>) -> bool {
+    fn filter_intersection_pair(&self, _: &PairFilterContext) -> bool {
         true
     }
 
-    fn modify_solver_contacts(&self, _: &mut ContactModificationContext<Bodies, Colliders>) {}
+    fn modify_solver_contacts(&self, _: &mut ContactModificationContext) {}
 }
diff --git a/src/pipeline/physics_pipeline.rs b/src/pipeline/physics_pipeline.rs
index 2d90c4b..ffcb25f 100644
--- a/src/pipeline/physics_pipeline.rs
+++ b/src/pipeline/physics_pipeline.rs
@@ -1,21 +1,18 @@
 //! Physics pipeline structures.
 
 use crate::counters::Counters;
-use crate::data::{BundleSet, ComponentSet, ComponentSetMut, ComponentSetOption};
 #[cfg(not(feature = "parallel"))]
 use crate::dynamics::IslandSolver;
 use crate::dynamics::{
     CCDSolver, ImpulseJointSet, IntegrationParameters, IslandManager, MultibodyJointSet,
-    RigidBodyActivation, RigidBodyCcd, RigidBodyChanges, RigidBodyColliders, RigidBodyDamping,
-    RigidBodyDominance, RigidBodyForces, RigidBodyHandle, RigidBodyIds, RigidBodyMassProps,
-    RigidBodyPosition, RigidBodyType, RigidBodyVelocity,
+    RigidBodyColliders, RigidBodyForces, RigidBodyHandle, RigidBodyMassProps, RigidBodyPosition,
+    RigidBodyType, RigidBodyVelocity,
 };
 #[cfg(feature = "parallel")]
 use crate::dynamics::{JointGraphEdge, ParallelIslandSolver as IslandSolver};
 use crate::geometry::{
-    BroadPhase, BroadPhasePairEvent, ColliderBroadPhaseData, ColliderChanges, ColliderFlags,
-    ColliderHandle, ColliderMaterial, ColliderPair, ColliderParent, ColliderPosition,
-    ColliderShape, ColliderType, ContactManifoldIndex, NarrowPhase, ColliderMassProps
+    BroadPhase, BroadPhasePairEvent, ColliderChanges, ColliderHandle, ColliderPair,
+    ContactManifoldIndex, NarrowPhase,
 };
 use crate::math::{Real, Vector};
 use crate::pipeline::{EventHandler, PhysicsHooks};
@@ -71,7 +68,7 @@ impl PhysicsPipeline {
 
     fn clear_modified_colliders(
         &mut self,
-        colliders: &mut impl ComponentSetMut<ColliderChanges>,
+        colliders: &mut ColliderSet,
         modified_colliders: &mut Vec<ColliderHandle>,
     ) {
         for handle in modified_colliders.drain(..) {
@@ -79,33 +76,20 @@ impl PhysicsPipeline {
         }
     }
 
-    fn detect_collisions<Bodies, Colliders>(
+    fn detect_collisions(
         &mut self,
         integration_parameters: &IntegrationParameters,
         islands: &mut IslandManager,
         broad_phase: &mut BroadPhase,
         narrow_phase: &mut NarrowPhase,
-        bodies: &mut Bodies,
-        colliders: &mut Colliders,
+        bodies: &mut RigidBodySet,
+        colliders: &mut ColliderSet,
         modified_colliders: &[ColliderHandle],
         removed_colliders: &[ColliderHandle],
-        hooks: &dyn PhysicsHooks<Bodies, Colliders>,
+        hooks: &dyn PhysicsHooks,
         events: &dyn EventHandler,
         handle_user_changes: bool,
-    ) where
-        Bodies: ComponentSetMut<RigidBodyActivation>
-            + ComponentSet<RigidBodyType>
-            + ComponentSetMut<RigidBodyIds>
-            + ComponentSet<RigidBodyDominance>,
-        Colliders: ComponentSetMut<ColliderBroadPhaseData>
-            + ComponentSet<ColliderChanges>
-            + ComponentSet<ColliderPosition>
-            + ComponentSet<ColliderShape>
-            + ComponentSetOption<ColliderParent>
-            + ComponentSet<ColliderType>
-            + ComponentSet<ColliderMaterial>
-            + ComponentSet<ColliderFlags>,
-    {
+    ) {
         self.counters.stages.collision_detection_time.resume();
         self.counters.cd.broad_phase_time.resume();
 
@@ -155,28 +139,17 @@ impl PhysicsPipeline {
         self.counters.stages.collision_detection_time.pause();
     }
 
-    fn build_islands_and_solve_velocity_constraints<Bodies, Colliders>(
+    fn build_islands_and_solve_velocity_constraints(
         &mut self,
         gravity: &Vector<Real>,
         integration_parameters: &IntegrationParameters,
         islands: &mut IslandManager,
         narrow_phase: &mut NarrowPhase,
-        bodies: &mut Bodies,
-        colliders: &mut Colliders,
+        bodies: &mut RigidBodySet,
+        colliders: &mut ColliderSet,
         impulse_joints: &mut ImpulseJointSet,
         multibody_joints: &mut MultibodyJointSet,
-    ) where
-        Bodies: ComponentSetMut<RigidBodyPosition>
-            + ComponentSetMut<RigidBodyVelocity>
-            + ComponentSetMut<RigidBodyMassProps>
-            + ComponentSetMut<RigidBodyForces>
-            + ComponentSetMut<RigidBodyIds>
-            + ComponentSetMut<RigidBodyActivation>
-            + ComponentSet<RigidBodyDamping>
-            + ComponentSet<RigidBodyColliders>
-            + ComponentSet<RigidBodyType>,
-        Colliders: ComponentSetOption<ColliderParent>,
-    {
+    ) {
         self.counters.stages.island_construction_time.resume();
         islands.update_active_set_with_contacts(
             integration_parameters.dt,
@@ -285,7 +258,7 @@ impl PhysicsPipeline {
                     .par_iter_mut()
                     .enumerate()
                     .for_each(|(island_id, solver)| {
-                        let bodies: &mut Bodies =
+                        let bodies: &mut RigidBodySet =
                             unsafe { std::mem::transmute(bodies.load(Ordering::Relaxed)) };
                         let manifolds: &mut Vec<&mut ContactManifold> =
                             unsafe { std::mem::transmute(manifolds.load(Ordering::Relaxed)) };
@@ -313,28 +286,16 @@ impl PhysicsPipeline {
         self.counters.stages.solver_time.pause();
     }
 
-    fn run_ccd_motion_clamping<Bodies, Colliders>(
+    fn run_ccd_motion_clamping(
         &mut self,
         integration_parameters: &IntegrationParameters,
         islands: &IslandManager,
-        bodies: &mut Bodies,
-        colliders: &mut Colliders,
+        bodies: &mut RigidBodySet,
+        colliders: &mut ColliderSet,
         narrow_phase: &NarrowPhase,
         ccd_solver: &mut CCDSolver,
         events: &dyn EventHandler,
-    ) where
-        Bodies: ComponentSetMut<RigidBodyPosition>
-            + ComponentSet<RigidBodyVelocity>
-            + ComponentSet<RigidBodyCcd>
-            + ComponentSet<RigidBodyColliders>
-            + ComponentSet<RigidBodyForces>
-            + ComponentSet<RigidBodyMassProps>,
-        Colliders: ComponentSetOption<ColliderParent>
-            + ComponentSet<ColliderPosition>
-            + ComponentSet<ColliderShape>
-            + ComponentSet<ColliderType>
-            + ComponentSet<ColliderFlags>,
-    {
+    ) {
         self.counters.ccd.toi_computation_time.start();
         // Handle CCD
         let impacts = ccd_solver.predict_impacts_at_next_positions(
@@ -349,22 +310,13 @@ impl PhysicsPipeline {
         self.counters.ccd.toi_computation_time.pause();
     }
 
-    fn advance_to_final_positions<Bodies, Colliders>(
+    fn advance_to_final_positions(
         &mut self,
         islands: &IslandManager,
-        bodies: &mut Bodies,
-        colliders: &mut Colliders,
+        bodies: &mut RigidBodySet,
+        colliders: &mut ColliderSet,
         modified_colliders: &mut Vec<ColliderHandle>,
-    ) where
-        Bodies: ComponentSetMut<RigidBodyVelocity>
-            + ComponentSetMut<RigidBodyForces>
-            + ComponentSetMut<RigidBodyPosition>
-            + ComponentSet<RigidBodyType>
-            + ComponentSet<RigidBodyColliders>,
-        Colliders: ComponentSetMut<ColliderPosition>
-            + ComponentSetMut<ColliderChanges>
-            + ComponentSetOption<ColliderParent>,
-    {
+    ) {
         // Set the rigid-bodies and kinematic bodies to their final position.
         for handle in islands.iter_active_bodies() {
             bodies.map_mut_internal(handle.0, |poss: &mut RigidBodyPosition| {
@@ -377,17 +329,12 @@ impl PhysicsPipeline {
         }
     }
 
-    fn interpolate_kinematic_velocities<Bodies>(
+    fn interpolate_kinematic_velocities(
         &mut self,
         integration_parameters: &IntegrationParameters,
         islands: &IslandManager,
-        bodies: &mut Bodies,
-    ) where
-        Bodies: ComponentSetMut<RigidBodyVelocity>
-            + ComponentSetMut<RigidBodyPosition>
-            + ComponentSet<RigidBodyType>
-            + ComponentSet<RigidBodyMassProps>,
-    {
+        bodies: &mut RigidBodySet,
+    ) {
         // Update kinematic bodies velocities.
         // TODO: what is the best place for this? It should at least be
         // located before the island computation because we test the velocity
@@ -440,7 +387,7 @@ impl PhysicsPipeline {
         impulse_joints: &mut ImpulseJointSet,
         multibody_joints: &mut MultibodyJointSet,
         ccd_solver: &mut CCDSolver,
-        hooks: &dyn PhysicsHooks<RigidBodySet, ColliderSet>,
+        hooks: &dyn PhysicsHooks,
         events: &dyn EventHandler,
     ) {
         let mut modified_bodies = bodies.take_modified();
@@ -467,46 +414,24 @@ impl PhysicsPipeline {
     }
 
     /// Executes one timestep of the physics simulation.
-    pub fn step_generic<Bodies, Colliders>(
+    pub fn step_generic(
         &mut self,
         gravity: &Vector<Real>,
         integration_parameters: &IntegrationParameters,
         islands: &mut IslandManager,
         broad_phase: &mut BroadPhase,
         narrow_phase: &mut NarrowPhase,
-        bodies: &mut Bodies,
-        colliders: &mut Colliders,
+        bodies: &mut RigidBodySet,
+        colliders: &mut ColliderSet,
         modified_bodies: &mut Vec<RigidBodyHandle>,
         modified_colliders: &mut Vec<ColliderHandle>,
         removed_colliders: &mut Vec<ColliderHandle>,
         impulse_joints: &mut ImpulseJointSet,
         multibody_joints: &mut MultibodyJointSet,
         ccd_solver: &mut CCDSolver,
-        hooks: &dyn PhysicsHooks<Bodies, Colliders>,
+        hooks: &dyn PhysicsHooks,
         events: &dyn EventHandler,
-    ) where
-        Bodies: ComponentSetMut<RigidBodyPosition>
-            + ComponentSetMut<RigidBodyVelocity>
-            + ComponentSetMut<RigidBodyMassProps>
-            + ComponentSetMut<RigidBodyIds>
-            + ComponentSetMut<RigidBodyForces>
-            + ComponentSetMut<RigidBodyActivation>
-            + ComponentSetMut<RigidBodyChanges>
-            + ComponentSetMut<RigidBodyCcd>
-            + ComponentSet<RigidBodyColliders>
-            + ComponentSet<RigidBodyDamping>
-            + ComponentSet<RigidBodyDominance>
-            + ComponentSet<RigidBodyType>,
-        Colliders: ComponentSetMut<ColliderBroadPhaseData>
-            + ComponentSetMut<ColliderChanges>
-            + ComponentSetMut<ColliderPosition>
-            + ComponentSet<ColliderShape>
-            + ComponentSetOption<ColliderParent>
-            + ComponentSet<ColliderType>
-            + ComponentSet<ColliderMaterial>
-            + ComponentSet<ColliderFlags>
-            + ComponentSet<ColliderMassProps>,
-    {
+    ) {
         self.counters.reset();
         self.counters.step_started();
 
diff --git a/src/pipeline/query_pipeline.rs b/src/pipeline/query_pipeline.rs
index a5565cd..584989e 100644
--- a/src/pipeline/query_pipeline.rs
+++ b/src/pipeline/query_pipeline.rs
@@ -1,4 +1,3 @@
-use crate::data::{BundleSet, ComponentSet, ComponentSetOption};
 use crate::dynamics::{
     IslandManager, RigidBodyColliders, RigidBodyForces, RigidBodyMassProps, RigidBodyPosition,
     RigidBodyVelocity,
@@ -40,9 +39,9 @@ pub struct QueryPipeline {
     dilation_factor: Real,
 }
 
-struct QueryPipelineAsCompositeShape<'a, Colliders> {
+struct QueryPipelineAsCompositeShape<'a> {
     query_pipeline: &'a QueryPipeline,
-    colliders: &'a Colliders,
+    colliders: &'a ColliderSet,
     query_groups: InteractionGroups,
     filter: Option<&'a dyn Fn(ColliderHandle) -> bool>,
 }
@@ -63,12 +62,7 @@ pub enum QueryPipelineMode {
     },
 }
 
-impl<'a, Colliders> TypedSimdCompositeShape for QueryPipelineAsCompositeShape<'a, Colliders>
-where
-    // TODO ECS: make everything optional but the shape?
-    Colliders:
-        ComponentSet<ColliderFlags> + ComponentSet<ColliderPosition> + ComponentSet<ColliderShape>,
-{
+impl<'a> TypedSimdCompositeShape for QueryPipelineAsCompositeShape<'a> {
     type PartShape = dyn Shape;
     type PartId = ColliderHandle;
 
@@ -77,15 +71,11 @@ where
         shape_id: Self::PartId,
         mut f: impl FnMut(Option<&Isometry<Real>>, &Self::PartShape),
     ) {
-        let co_flags: Option<&ColliderFlags> = self.colliders.get(shape_id.0);
-
-        if let Some(co_flags) = co_flags {
-            if co_flags.collision_groups.test(self.query_groups)
+        if let Some(co) = self.colliders.get(shape_id) {
+            if co.flags.collision_groups.test(self.query_groups)
                 && self.filter.map(|f| f(shape_id)).unwrap_or(true)
             {
-                let (co_pos, co_shape): (&ColliderPosition, &ColliderShape) =
-                    self.colliders.index_bundle(shape_id.0);
-                f(Some(co_pos), &**co_shape)
+                f(Some(co.pos), &**co.shape)
             }
         }
     }
@@ -115,12 +105,12 @@ impl QueryPipeline {
         Self::with_query_dispatcher(DefaultQueryDispatcher)
     }
 
-    fn as_composite_shape<'a, Colliders>(
+    fn as_composite_shape<'a>(
         &'a self,
-        colliders: &'a Colliders,
+        colliders: &'a ColliderSet,
         query_groups: InteractionGroups,
         filter: Option<&'a dyn Fn(ColliderHandle) -> bool>,
-    ) -> QueryPipelineAsCompositeShape<'a, Colliders> {
+    ) -> QueryPipelineAsCompositeShape<'a> {
         QueryPipelineAsCompositeShape {
             query_pipeline: self,
             colliders,
@@ -162,21 +152,12 @@ impl QueryPipeline {
     }
 
     /// Update the acceleration structure on the query pipeline.
-    pub fn update_generic<Bodies, Colliders>(
+    pub fn update_generic(
         &mut self,
         islands: &IslandManager,
-        bodies: &Bodies,
-        colliders: &Colliders,
-    ) where
-        Bodies: ComponentSet<RigidBodyPosition>
-            + ComponentSet<RigidBodyColliders>
-            + ComponentSet<RigidBodyVelocity>
-            + ComponentSet<RigidBodyMassProps>
-            + ComponentSet<RigidBodyForces>,
-        Colliders: ComponentSet<ColliderShape>
-            + ComponentSet<ColliderPosition>
-            + ComponentSetOption<ColliderParent>,
-    {
+        bodies: &RigidBodySet,
+        colliders: &ColliderSet,
+    ) {
         self.update_with_mode(
             islands,
             bodies,
@@ -186,40 +167,22 @@ impl QueryPipeline {
     }
 
     /// Update the acceleration structure on the query pipeline.
-    pub fn update_with_mode<Bodies, Colliders>(
+    pub fn update_with_mode(
         &mut self,
         islands: &IslandManager,
-        bodies: &Bodies,
-        colliders: &Colliders,
+        bodies: &RigidBodySet,
+        colliders: &ColliderSet,
         mode: QueryPipelineMode,
-    ) where
-        Bodies: ComponentSet<RigidBodyPosition>
-            + ComponentSet<RigidBodyColliders>
-            + ComponentSet<RigidBodyVelocity>
-            + ComponentSet<RigidBodyMassProps>
-            + ComponentSet<RigidBodyForces>,
-        Colliders: ComponentSet<ColliderShape>
-            + ComponentSet<ColliderPosition>
-            + ComponentSetOption<ColliderParent>,
-    {
-        struct DataGenerator<'a, Bs, Cs> {
-            bodies: &'a Bs,
-            colliders: &'a Cs,
+    ) {
+        struct DataGenerator<'a> {
+            bodies: &'a RigidBodySet,
+            colliders: &'a ColliderSet,
             mode: QueryPipelineMode,
         }
 
-        impl<'a, Bs, Cs> QBVHDataGenerator<ColliderHandle> for DataGenerator<'a, Bs, Cs>
-        where
-            Bs: ComponentSet<RigidBodyPosition>
-                + ComponentSet<RigidBodyMassProps>
-                + ComponentSet<RigidBodyVelocity>
-                + ComponentSet<RigidBodyForces>,
-            Cs: ComponentSet<ColliderShape>
-                + ComponentSet<ColliderPosition>
-                + ComponentSetOption<ColliderParent>,
-        {
+        impl<'a> QBVHDataGenerator<ColliderHandle> for DataGenerator<'a> {
             fn size_hint(&self) -> usize {
-                ComponentSet::<ColliderShape>::size_hint(self.colliders)
+                self.colliders.len()
             }
 
             #[inline(always)]
@@ -313,16 +276,13 @@ impl QueryPipeline {
             QueryPipelineMode::SweepTestWithNextPosition => {
                 self.qbvh.update(
                     |handle| {
-                        let co_parent: Option<&ColliderParent> = colliders.get(handle.0);
-                        let (co_pos, co_shape): (&ColliderPosition, &ColliderShape) =
-                            colliders.index_bundle(handle.0);
-
-                        if let Some(co_parent) = co_parent {
-                            let rb_pos: &RigidBodyPosition = bodies.index(co_parent.handle.0);
-                            let next_position = rb_pos.next_position * co_parent.pos_wrt_parent;
-                            co_shape.compute_swept_aabb(&co_pos, &next_position)
+                        let co = &colliders[handle];
+                        if let Some(parent) = co.parent {
+                            let rb_pos: &RigidBodyPosition = bodies.index(co.parent.handle.0);
+                            let next_position = rb_pos.next_position * co.parent.pos_wrt_parent;
+                            co.shape.compute_swept_aabb(&co.pos, &next_position)
                         } else {
-                            co_shape.compute_aabb(&co_pos)
+                            co.shape.compute_aabb(&co.pos)
                         }
                     },
                     self.dilation_factor,
@@ -331,25 +291,17 @@ impl QueryPipeline {
             QueryPipelineMode::SweepTestWithPredictedPosition { dt } => {
                 self.qbvh.update(
                     |handle| {
-                        let co_parent: Option<&ColliderParent> = colliders.get(handle.0);
-                        let (co_pos, co_shape): (&ColliderPosition, &ColliderShape) =
-                            colliders.index_bundle(handle.0);
-
-                        if let Some(co_parent) = co_parent {
-                            let (rb_pos, vels, forces, mprops): (
-                                &RigidBodyPosition,
-                                &RigidBodyVelocity,
-                                &RigidBodyForces,
-                                &RigidBodyMassProps,
-                            ) = bodies.index_bundle(co_parent.handle.0);
-
-                            let predicted_pos =
-                                rb_pos.integrate_forces_and_velocities(dt, forces, vels, mprops);
-
-                            let next_position = predicted_pos * co_parent.pos_wrt_parent;
-                            co_shape.compute_swept_aabb(&co_pos, &next_position)
+                        let co = &colliders[handle];
+                        if let Some(parent) = co.parent {
+                            let rb = &bodies[parent.handle];
+                            let predicted_pos = rb
+                                .pos
+                                .integrate_forces_and_velocities(dt, rb.forces, rb.vels, rb.mprops);
+
+                            let next_position = predicted_pos * parent.pos_wrt_parent;
+                            co.shape.compute_swept_aabb(&co.pos, &next_position)
                         } else {
-                            co_shape.compute_aabb(&co_pos)
+                            co.shape.compute_aabb(&co.pos)
                         }
                     },
                     self.dilation_factor,
@@ -373,20 +325,15 @@ impl QueryPipeline {
     /// * `filter`: a more fine-grained filter. A collider is taken into account by this query if
     ///             its `contact_group` is compatible with the `query_groups`, and if this `filter`
     ///             is either `None` or returns `true`.
-    pub fn cast_ray<Colliders>(
+    pub fn cast_ray(
         &self,
-        colliders: &Colliders,
+        colliders: &ColliderSet,
         ray: &Ray,
         max_toi: Real,
         solid: bool,
         query_groups: InteractionGroups,
         filter: Option<&dyn Fn(ColliderHandle) -> bool>,
-    ) -> Option<(ColliderHandle, Real)>
-    where
-        Colliders: ComponentSet<ColliderFlags>
-            + ComponentSet<ColliderPosition>
-            + ComponentSet<ColliderShape>,
-    {
+    ) -> Option<(ColliderHandle, Real)> {
         let pipeline_shape = self.as_composite_shape(colliders, query_groups, filter);
         let mut visitor =
             RayCompositeShapeToiBestFirstVisitor::new(&pipeline_shape, ray, max_toi, solid);
@@ -409,20 +356,15 @@ impl QueryPipeline {
     /// * `filter`: a more fine-grained filter. A collider is taken into account by this query if
     ///             its `contact_group` is compatible with the `query_groups`, and if this `filter`
     ///             is either `None` or returns `true`.
-    pub fn cast_ray_and_get_normal<Colliders>(
+    pub fn cast_ray_and_get_normal(
         &self,
-        colliders: &Colliders,
+        colliders: &ColliderSet,
         ray: &Ray,
         max_toi: Real,
         solid: bool,
         query_groups: InteractionGroups,
         filter: Option<&dyn Fn(ColliderHandle) -> bool>,
-    ) -> Option<(ColliderHandle, RayIntersection)>
-    where
-        Colliders: ComponentSet<ColliderFlags>
-            + ComponentSet<ColliderPosition>
-            + ComponentSet<ColliderShape>,
-    {
+    ) -> Option<(ColliderHandle, RayIntersection)> {
         let pipeline_shape = self.as_composite_shape(colliders, query_groups, filter);
         let mut visitor = RayCompositeShapeToiAndNormalBestFirstVisitor::new(
             &pipeline_shape,
@@ -452,20 +394,16 @@ impl QueryPipeline {
     /// * `callback`: function executed on each collider for which a ray intersection has been found.
     ///               There is no guarantees on the order the results will be yielded. If this callback returns `false`,
     ///               this method will exit early, ignore any further raycast.
-    pub fn intersections_with_ray<'a, Colliders>(
+    pub fn intersections_with_ray<'a, ColliderSet>(
         &self,
-        colliders: &'a Colliders,
+        colliders: &'a ColliderSet,
         ray: &Ray,
         max_toi: Real,
         solid: bool,
         query_groups: InteractionGroups,
         filter: Option<&dyn Fn(ColliderHandle) -> bool>,
         mut callback: impl FnMut(ColliderHandle, RayIntersection) -> bool,
-    ) where
-        Colliders: ComponentSet<ColliderFlags>
-            + ComponentSet<ColliderPosition>
-            + ComponentSet<ColliderShape>,
-    {
+    ) {
         let mut leaf_callback = &mut |handle: &ColliderHandle| {
             let co_shape: Option<&ColliderShape> = colliders.get(handle.0);
             if let Some(co_shape) = co_shape {
@@ -499,19 +437,14 @@ impl QueryPipeline {
     /// * `filter` - a more fine-grained filter. A collider is taken into account by this query if
     ///             its `contact_group` is compatible with the `query_groups`, and if this `filter`
     ///             is either `None` or returns `true`.
-    pub fn intersection_with_shape<Colliders>(
+    pub fn intersection_with_shape(
         &self,
-        colliders: &Colliders,
+        colliders: &ColliderSet,
         shape_pos: &Isometry<Real>,
         shape: &dyn Shape,
         query_groups: InteractionGroups,
         filter: Option<&dyn Fn(ColliderHandle) -> bool>,
-    ) -> Option<ColliderHandle>
-    where
-        Colliders: ComponentSet<ColliderFlags>
-            + ComponentSet<ColliderPosition>
-            + ComponentSet<ColliderShape>,
-    {
+    ) -> Option<ColliderHandle> {
         let pipeline_shape = self.as_composite_shape(colliders, query_groups, filter);
         let mut visitor = IntersectionCompositeShapeShapeBestFirstVisitor::new(
             &*self.query_dispatcher,
@@ -540,19 +473,14 @@ impl QueryPipeline {
     /// * `filter` - a more fine-grained filter. A collider is taken into account by this query if
     ///             its `contact_group` is compatible with the `query_groups`, and if this `filter`