- fix doc mistakes

- fix bug about shapes `ID`

Author: kingwingfly

CHANGELOG.md

@@ -9,6 +9,11 @@ Note: In this file, do not use the hard wrap in the middle of a sentence for com
 -->
 
 ## [Unreleased]
+## [0.15.1-alpha9] - 2025-01-22
+
+- fix doc mistakes
+- fix bug about shapes `ID`
+
 ## [0.15.1-alpha8] - 2025-01-22
 
 - refator `QuadTree` (replace recursion with loop), a huge performance improvement in theory

bevy_quadtree/README.md

@@ -147,7 +147,7 @@ cmds.spawn((
 4. Query the quadtree like bevy's `Or, Not`:
 
 ```rust ignore
-type MyQuadTree = QuadTree<40, 100, 100, 20>;
+type MyQuadTree = QuadTree<8, 40, 100, 100, 20>;
 
 fn pick(
     mut gizmos: Gizmos,

bevy_quadtree/src/collision.rs

@@ -44,6 +44,33 @@ impl<T> DynCollision for T where
 {
 }
 
+/// Erase the `ID` of the shape and store it as a trait object in the `QuadTree`.
+#[allow(missing_docs)]
+pub trait AsDynCollision {
+    fn as_dyn_collision(&self) -> Box<dyn DynCollision>;
+}
+
+impl<const D: usize> AsDynCollision for CollisionRect<D> {
+    fn as_dyn_collision(&self) -> Box<dyn DynCollision> {
+        let this = CollisionRect::from(self);
+        Box::new(this)
+    }
+}
+
+impl<const D: usize> AsDynCollision for CollisionRotatedRect<D> {
+    fn as_dyn_collision(&self) -> Box<dyn DynCollision> {
+        let this = CollisionRotatedRect::from(self);
+        Box::new(this)
+    }
+}
+
+impl<const D: usize> AsDynCollision for CollisionCircle<D> {
+    fn as_dyn_collision(&self) -> Box<dyn DynCollision> {
+        let this = CollisionCircle::from(self);
+        Box::new(this)
+    }
+}
+
 /// Update the attributes of the shape during PreUpdate stage and before Collision Detection.
 pub trait UpdateCollision<C>
 where

bevy_quadtree/src/plugin.rs

@@ -1,6 +1,6 @@
 //! QuadTree Plugin
 
-use crate::collision::DynCollision;
+use crate::collision::AsDynCollision;
 use crate::system::{update_collision, update_quadtree};
 use crate::tree::QuadTree;
 use crate::UpdateCollision;
@@ -15,14 +15,15 @@ use bevy_transform::components::GlobalTransform;
 /// # Type Parameters
 /// `P`: `(S, C)` pair (or tuple of `(S, C)`s) where `S` (collision shape) can updated by `C` (component).
 ///
-/// `S: Component + DynCollision + UpdateCollision<C> + Clone`,
+/// `S: Component + AsDynCollision + UpdateCollision<C> + Clone`,
 /// such as [`CollisionCircle, CollisionRect, CollisionRotatedRect`](crate::shape).
 /// Being used to perform Collision Detection,
 /// storing the shape and position info, also serving as a marker component in ECS queries.
 /// (Do not need to include those only used in the [`QuadTree::query`](crate::QuadTree::query),
-/// only those need to be updated.)
+/// please include those need to be updated.)
 ///
-/// `C: Component`, only `GlobalTransform`, `Sprite`(need feature `sprite`) or tuples of them for now.
+/// `C: Component`, the components the shapes will be updated according to.
+/// Only `GlobalTransform`, `Sprite`(need feature `sprite`) or tuples of them for now.
 ///
 /// `N`: The max number of objects each node.
 /// `D`: The max depth of the tree.
@@ -43,7 +44,7 @@ use bevy_transform::components::GlobalTransform;
 ///
 /// 2. invalid const parameters.
 ///
-/// N, W, H should > 0. K should >= 10.
+/// N, D, W, H should > 0. K should >= 10.
 ///
 /// # Example
 /// ```no_run
@@ -118,9 +119,7 @@ where
             .add_systems(PreUpdate, P::update_collision())
             .add_systems(Update, P::update_quadtree::<N, D, W, H, K, ID>());
         #[cfg(feature = "gizmos")]
-        {
-            app.add_systems(PostUpdate, P::show_boundary::<N, D, W, H, K, ID>());
-        }
+        app.add_systems(PostUpdate, P::show_boundary::<N, D, W, H, K, ID>());
     }
 }
 
@@ -157,7 +156,7 @@ macro_rules! impl_tracking_pair {
     ($c: ty) => {
         impl<S> TrackingPair for (S, $c)
         where
-            S: Component + DynCollision + UpdateCollision<$c> + Clone,
+            S: Component + AsDynCollision + UpdateCollision<$c> + Clone,
         {
             fn update_collision() -> SystemConfigs {
                 update_collision::<S, $c>.ambiguous_with_all()
@@ -200,7 +199,7 @@ macro_rules! impl_tracking_pair_tuple {
     ($($c: ty),+) => {
         impl<S> TrackingPair for (S, ($($c),+,))
         where
-            S: Component + DynCollision + $(UpdateCollision<$c>+)+ Clone,
+            S: Component + AsDynCollision + $(UpdateCollision<$c>+)+ Clone,
             $($c: Component),+,
             $((S, $c): TrackingPair),+,
         {
@@ -250,7 +249,7 @@ macro_rules! impl_tracking_pairs {
                         let mut set = std::collections::HashMap::new();
                         $(
                             if let Some(dup) = set.insert([<P $i>]::shape_id(), std::any::type_name::<[<P $i>]>()) {
-                                panic!("Duplicate quadtree updating system added:\n<{}>\n<{}>\nThey have the same collision shape, merge them into one or use `ID` type parameter of shape.", std::any::type_name::<[<P $i>]>(), dup);
+                                panic!("Duplicate quadtree updating system added:\n<{}>\n<{}>\nThey have the same collision shape, merge them into one or use `ID` type parameter of shape.", dup, std::any::type_name::<[<P $i>]>());
                             }
                         );+
                     }
@@ -264,7 +263,7 @@ macro_rules! impl_tracking_pairs {
                         let mut set = std::collections::HashMap::new();
                         $(
                             if let Some(dup) = set.insert([<P $i>]::shape_id(), std::any::type_name::<[<P $i>]>()) {
-                                panic!("Duplicate gizmos box updating system added:\n<{}>\n<{}>\nThey have the same collision shape, merge them into one or use `ID` type parameter of shape.", std::any::type_name::<[<P $i>]>(), dup);
+                                panic!("Duplicate gizmos box updating system added:\n<{}>\n<{}>\nThey have the same collision shape, merge them into one or use `ID` type parameter of shape.", dup, std::any::type_name::<[<P $i>]>());
                             }
                         );+
                     }
@@ -360,4 +359,19 @@ mod tests {
             20,
         >::default());
     }
+
+    #[test]
+    fn plugin_test_with_id() {
+        App::new().add_plugins(QuadTreePlugin::<
+            (
+                (CollisionCircle<0>, GlobalTransform),
+                (CollisionCircle<1>, GlobalTransform),
+            ),
+            40,
+            4,
+            100,
+            100,
+            20,
+        >::default());
+    }
 }

bevy_quadtree/src/shape/circle.rs

@@ -1,8 +1,8 @@
-use core::fmt;
-
 use bevy_ecs::prelude::*;
 use bevy_math::prelude::*;
 use bevy_transform::components::GlobalTransform;
+use core::fmt;
+use std::any::type_name;
 
 use crate::{
     collision::{DynCollision, Relation},
@@ -24,11 +24,12 @@ pub struct CollisionCircle<const ID: usize = 0> {
     init_radius: f32,
 }
 
-impl fmt::Debug for CollisionCircle {
+impl<const ID: usize> fmt::Debug for CollisionCircle<ID> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
-            "CollisionCircle: center = ({}, {}); r = {} x {} = {}",
+            "{}: center = ({}, {}); r = {} x {} = {}",
+            type_name::<Self>(),
             self.center.x,
             self.center.y,
             self.init_radius,
@@ -38,7 +39,21 @@ impl fmt::Debug for CollisionCircle {
     }
 }
 
+impl<const ID: usize> From<&CollisionCircle<ID>> for CollisionCircle<0> {
+    /// Convert the shape with `ID` to the shape with `ID = 0`.
+    /// Used to eliminate the `ID` in the collision detection.
+    fn from(value: &CollisionCircle<ID>) -> Self {
+        Self {
+            center: value.center,
+            scale: value.scale,
+            init_radius: value.init_radius,
+        }
+    }
+}
+
 impl CollisionCircle {
+    /// Create a new circle with `ID = 0`. See [`Self::new_id`] for the version with `ID`.
+    ///
     /// The initial radius is used to compute the size with the GlobalTransform's scale.
     ///
     /// The initial center is covered by the GlobalTransform's translation during the update.
@@ -49,6 +64,17 @@ impl CollisionCircle {
             init_radius: radius,
         }
     }
+}
+
+impl<const ID: usize> CollisionCircle<ID> {
+    /// Create a new circle with the given `ID`.
+    pub fn new_id(center: Vec2, radius: f32) -> Self {
+        Self {
+            center,
+            scale: 1.,
+            init_radius: radius,
+        }
+    }
 
     fn radius(&self) -> f32 {
         self.init_radius * self.scale
@@ -130,7 +156,7 @@ impl Collision<CollisionCircle> for CollisionCircle {
     }
 }
 
-impl UpdateCollision<GlobalTransform> for CollisionCircle {
+impl<const ID: usize> UpdateCollision<GlobalTransform> for CollisionCircle<ID> {
     fn update() -> impl FnOnce(Mut<Self>, &GlobalTransform) {
         |mut circle, global_transform| {
             circle.center = global_transform.translation().truncate();

bevy_quadtree/src/shape/mod.rs

@@ -1,4 +1,8 @@
-//! Shapes able to be used in Collision Detection
+//! Shapes able to be used in Collision Detection.
+//!
+//! The `ID` of shapes is used to distinguish the same shape following different transforms, having nothing to do with the `ID` of the [`QuadTree`](crate::QuadTree).
+//!
+//! The `ID` of the `QuadTree` is used to distinguish different `QuadTree`s in the `World`, which is determined by the `ID` of [`QuadTreePlugin`](crate::QuadTreePlugin).
 
 mod circle;
 mod rect;

bevy_quadtree/src/shape/rect.rs

@@ -1,12 +1,12 @@
-use core::fmt;
-
 use bevy_ecs::prelude::*;
 #[cfg(feature = "sprite")]
 use bevy_log::warn;
 use bevy_math::prelude::*;
 #[cfg(feature = "sprite")]
 use bevy_sprite::Sprite;
 use bevy_transform::components::GlobalTransform;
+use core::fmt;
+use std::any::type_name;
 
 use crate::{
     collision::{DynCollision, Relation},
@@ -27,11 +27,12 @@ pub struct CollisionRect<const ID: usize = 0> {
     init_size: Vec2,
 }
 
-impl fmt::Debug for CollisionRect {
+impl<const ID: usize> fmt::Debug for CollisionRect<ID> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "CollisionRect: center = ({}, {}); size = ({} x {}) x ({} x {}) = {} x {}",
+            "{}: center = ({}, {}); size = ({} x {}) x ({} x {}) = {} x {}",
+            type_name::<Self>(),
             self.center.x,
             self.center.y,
             self.init_size.x,
@@ -44,7 +45,22 @@ impl fmt::Debug for CollisionRect {
     }
 }
 
+impl<const ID: usize> From<&CollisionRect<ID>> for CollisionRect<0> {
+    /// Convert the shape with `ID` to the shape with `ID = 0`.
+    /// Used to eliminate the `ID` in the collision detection.
+    fn from(value: &CollisionRect<ID>) -> Self {
+        Self {
+            center: value.center,
+            scale: value.scale,
+            init_size: value.init_size,
+        }
+    }
+}
+
 impl From<Rect> for CollisionRect {
+    /// Create a new CollisionRect from a Rect with `ID = 0`.
+    ///
+    /// See [`Self::new`] for details.
     fn from(rect: Rect) -> Self {
         Self {
             center: rect.center(),
@@ -55,7 +71,8 @@ impl From<Rect> for CollisionRect {
 }
 
 impl CollisionRect {
-    /// Create a new CollisionRect from a Rect.
+    /// Create a new CollisionRect from a Rect with `ID = 0`.
+    ///
     /// The initial size is set to the size of the rect.
     /// It is used to compute the size with the GlobalTransform's scale.
     ///
@@ -64,6 +81,17 @@ impl CollisionRect {
     pub fn new(rect: Rect) -> Self {
         rect.into()
     }
+}
+
+impl<const ID: usize> CollisionRect<ID> {
+    /// Create a new CollisionRect from a Rect with given `ID`.
+    pub fn new_id(rect: Rect) -> Self {
+        Self {
+            center: rect.center(),
+            scale: Vec2::ONE,
+            init_size: rect.size(),
+        }
+    }
 
     pub(crate) fn size(&self) -> Vec2 {
         self.init_size * self.scale
@@ -193,7 +221,7 @@ impl Collision<CollisionCircle> for CollisionRect {
     }
 }
 
-impl UpdateCollision<GlobalTransform> for CollisionRect {
+impl<const ID: usize> UpdateCollision<GlobalTransform> for CollisionRect<ID> {
     fn update() -> impl FnOnce(Mut<Self>, &GlobalTransform) {
         |mut rect, global_transform| {
             debug_assert_eq!(
@@ -209,7 +237,7 @@ impl UpdateCollision<GlobalTransform> for CollisionRect {
 }
 
 #[cfg(feature = "sprite")]
-impl UpdateCollision<Sprite> for CollisionRect {
+impl<const ID: usize> UpdateCollision<Sprite> for CollisionRect<ID> {
     fn update() -> impl FnOnce(Mut<Self>, &Sprite) {
         |mut rect, sprite| {
             if let Some(size) = sprite.custom_size {