- simplify CollisionQuery trait

- improve documentation
- simplify dependencies

Author: kingwingfly

CHANGELOG.md

@@ -9,6 +9,12 @@ Note: In this file, do not use the hard wrap in the middle of a sentence for com
 -->
 
 ## [Unreleased]
+## [0.15.1-alpha6] - 2025-01-20
+
+- simplify `CollisionQuery` trait
+- improve documentation
+- simplify dependencies
+
 ## [0.15.1-alpha5] - 2025-01-20
 
 - decouple `Disassemble` from `CollisionQuery`

Cargo.toml

@@ -3,7 +3,7 @@ members = ["bevy_quadtree"]
 resolver = "2"
 
 [workspace.package]
-version = "0.15.1-alpha5"
+version = "0.15.1-alpha6"
 authors = ["Louis <[email protected]>"]
 description = "A quadtree plugin for bevy"
 license = "MIT"
@@ -13,7 +13,15 @@ documentation = "https://docs.rs/bevy_quadtree"
 
 [workspace.dependencies]
 bevy_quadtree = { path = "bevy_quadtree" }
-bevy = { version = "0.15.1", default-features = false }
+bevy_app = { version = "0.15.1", default-features = false }
+bevy_ecs = { version = "0.15.1", default-features = false }
+bevy_math = { version = "0.15.1", default-features = false }
+bevy_gizmos = { version = "0.15.1", default-features = false }
+bevy_sprite = { version = "0.15.1", default-features = false }
+bevy_transform = { version = "0.15.1", default-features = false }
+bevy_color = { version = "0.15.1", default-features = false }
+bevy_log = { version = "0.15.1", default-features = false }
+
 
 [profile.dev]
 opt-level = 3

bevy_quadtree/Cargo.toml

@@ -13,7 +13,14 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [dependencies]
-bevy = { workspace = true }
+bevy_app = { workspace = true }
+bevy_ecs = { workspace = true }
+bevy_math = { workspace = true }
+bevy_transform = { workspace = true, features = ["bevy-support"] }
+bevy_log = { workspace = true }
+bevy_gizmos = { workspace = true, optional = true }
+bevy_color = { workspace = true, optional = true }
+bevy_sprite = { workspace = true, optional = true }
 parking_lot = { version = "0.12.3", default-features = false }
 paste = { version = "1.0.15", default-features = false }
 
@@ -23,5 +30,5 @@ rand_chacha = { version = "0.3.1", default-features = false }
 
 [features]
 default = []
-sprite = ["bevy/bevy_sprite"]
-gizmos = ["bevy/bevy_gizmos"]
+sprite = ["dep:bevy_sprite"]
+gizmos = ["dep:bevy_gizmos", "dep:bevy_color"]

bevy_quadtree/README.md

@@ -99,13 +99,15 @@ bevy_quadtree = { version = "0.15.1" }
 2. Add the plugin to your Bevy app:
 
 ```rust no_run
-use bevy::prelude::*;
+# use bevy_app::prelude::*;
+# use bevy_transform::prelude::*;
+# #[cfg(feature = "sprite")]
+# use bevy_sprite::Sprite;
 use bevy_quadtree::{QuadTreePlugin, CollisionCircle, CollisionRect};
 
 fn main() {
     #[cfg(feature = "sprite")]
     App::new()
-        .add_plugins(DefaultPlugins)
         .add_plugins(QuadTreePlugin::<(
                 (CollisionCircle, GlobalTransform), (CollisionRect, (GlobalTransform, Sprite)),
             ),

bevy_quadtree/src/collision.rs

@@ -1,9 +1,7 @@
 //! Collision Detection
 
-use bevy::prelude::{Component, Mut};
-use paste::paste;
-
 use crate::{shape::CollisionRotatedRect, CollisionCircle, CollisionRect};
+use bevy_ecs::prelude::*;
 
 /// The result of a bound check.
 /// # Example
@@ -58,6 +56,15 @@ where
 
 /// Disassemble the boundary as [`CollisionRect`]s, [`CollisionRotatedRect`]s and [`CollisionCircle`]s as query boundary.
 /// All `S: Disassemble` also impl `CollisionQuery`, which can be used as a boundary in [`QuadTree::query`](crate::QuadTree::query).
+///
+/// Relation::Contain if any of the sub-boundaries completely contains the object.
+///
+/// Relation::Contained if all of the sub-boundaries are completely contained by the object.
+///
+/// Relation::Overlap if any of the sub-boundaries overlaps the object
+/// or not all of the sub-boundaries are contained by the object.
+///
+/// Relation::Disjoint otherwise.
 pub trait Disassemble {
     /// Disassemble the shape as [`CollisionRect`], [`CollisionRotatedRect`] and [`CollisionCircle`] as query boundaries.
     fn disassemble(
@@ -71,18 +78,9 @@ pub trait Disassemble {
 
 /// Used for [`QuadTree::query`](crate::QuadTree::query) as a boundary to detect the relation between the boundary and objects from the tree.
 ///
-/// However, implementing [`Disassemble`] trait for user boundary used in [`QuadTree::query`](crate::QuadTree::query) is recommended, since it's easier.
+/// However, implementing user-defined query boundary with [`Disassemble`] trait is recommended, since it's easier.
 ///
-/// For `S: Disassemble`, the default `CollisionQuery` impletation:
-///
-/// Relation::Contain if any of the sub-boundaries completely contains the object.
-///
-/// Relation::Contained if all of the sub-boundaries are completely contained by the object.
-///
-/// Relation::Overlap if any of the sub-boundaries overlaps the object
-/// or not all of the sub-boundaries are contained by the object.
-///
-/// Relation::Disjoint otherwise.
+/// For `S: Disassemble`, the default `CollisionQuery` impletation see [`here`](crate::Disassemble).
 pub trait CollisionQuery {
     /// Detect the relation between the boundary and objects from the tree.
     fn query(&self, obj: &dyn DynCollision) -> Relation;
@@ -159,7 +157,7 @@ where
 
 macro_rules! impl_disassemable {
     ($($i: literal),+) => {
-        paste! {
+        paste::paste! {
             impl<$([<S $i>]),+> Disassemble for ($([<S $i>]),+,)
             where
                 $([<S $i>]: Disassemble,)+

bevy_quadtree/src/lib.rs

@@ -11,7 +11,7 @@ pub mod shape;
 mod system;
 pub mod tree;
 
-pub use collision::{Collision, CollisionQuery, UpdateCollision};
+pub use collision::{Collision, CollisionQuery, Disassemble, UpdateCollision};
 pub use plugin::{QuadTreePlugin, TrackingPair};
 pub use query::{All, Contain, Contained, Disjoint, Overlap, QNot, QOr, QRelation};
 pub use shape::{CollisionCircle, CollisionRect, CollisionRotatedRect};

bevy_quadtree/src/node.rs

@@ -4,12 +4,9 @@ use crate::{
     collision::{DynCollision, Relation},
     CollisionRect,
 };
-use bevy::{
-    ecs::entity::EntityHashMap,
-    log::warn,
-    math::{Rect, Vec2},
-    prelude::Entity,
-};
+use bevy_ecs::entity::{Entity, EntityHashMap};
+use bevy_log::warn;
+use bevy_math::prelude::*;
 use core::fmt;
 use parking_lot::RwLock;
 use std::sync::Arc;

bevy_quadtree/src/plugin.rs

@@ -4,8 +4,12 @@ use crate::collision::DynCollision;
 use crate::system::{update_collision, update_quadtree};
 use crate::tree::QuadTree;
 use crate::UpdateCollision;
-use bevy::ecs::schedule::SystemConfigs;
-use bevy::prelude::*;
+use bevy_app::prelude::*;
+use bevy_ecs::prelude::*;
+use bevy_ecs::schedule::{IntoSystemConfigs, SystemConfigs};
+#[cfg(feature = "sprite")]
+use bevy_sprite::Sprite;
+use bevy_transform::components::GlobalTransform;
 
 /// A Bevy plugin for quadtree.
 /// # Type Parameters
@@ -32,7 +36,10 @@ use bevy::prelude::*;
 /// `ID`: If you want different quadtree for different use cases with the same other parameters, set ID to different values.
 /// # Example
 /// ```no_run
-/// use bevy::prelude::*;
+/// # use bevy_app::prelude::*;
+/// # use bevy_transform::prelude::*;
+/// # #[cfg(feature = "sprite")]
+/// # use bevy_sprite::Sprite;
 /// use bevy_quadtree::{CollisionCircle, CollisionRect, CollisionRotatedRect, QuadTreePlugin};
 ///
 /// #[cfg(feature = "sprite")]
@@ -250,7 +257,8 @@ impl_tracking_pairs!(0, 1, 2, 3, 4, 5, 6, 7, 8);
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::CollisionCircle;
+    #[allow(unused_imports)]
+    use crate::{CollisionCircle, CollisionRect, CollisionRotatedRect};
 
     #[test]
     #[should_panic(expected = "Duplicate quadtree updating system added")]
@@ -271,9 +279,6 @@ mod tests {
     #[test]
     #[should_panic(expected = "Duplicate quadtree updating system added")]
     fn duplicate_shape2() {
-        use bevy::prelude::*;
-
-        use crate::CollisionRect;
         App::new().add_plugins(QuadTreePlugin::<
             ((CollisionRect, GlobalTransform), (CollisionRect, Sprite)),
             40,
@@ -287,9 +292,6 @@ mod tests {
     #[test]
     #[should_panic(expected = "Duplicate quadtree updating system added")]
     fn duplicate_shape3() {
-        use crate::{CollisionCircle, CollisionRect, CollisionRotatedRect};
-        use bevy::prelude::*;
-
         App::new().add_plugins(QuadTreePlugin::<
             (
                 (CollisionCircle, GlobalTransform),
@@ -307,9 +309,6 @@ mod tests {
     #[cfg(all(feature = "sprite", feature = "gizmos"))]
     #[test]
     fn plugin_test() {
-        use crate::{CollisionCircle, CollisionRect, CollisionRotatedRect};
-        use bevy::prelude::*;
-
         App::new().add_plugins(QuadTreePlugin::<
             (
                 (CollisionCircle, GlobalTransform),

bevy_quadtree/src/query.rs

@@ -1,7 +1,7 @@
 //! Query
 
 use crate::{collision::Relation, node::ArcNode, CollisionQuery};
-use bevy::ecs::entity::EntityHashSet;
+use bevy_ecs::entity::EntityHashSet;
 
 /// `Or` filter used in `QuadTree::query`
 pub struct QOr<T>(core::marker::PhantomData<T>);

bevy_quadtree/src/shape/circle.rs

@@ -1,8 +1,11 @@
+use bevy_ecs::prelude::*;
+use bevy_math::prelude::*;
+use bevy_transform::components::GlobalTransform;
+
 use crate::{
     collision::{DynCollision, Relation},
     Collision, CollisionQuery, CollisionRect, CollisionRotatedRect, UpdateCollision,
 };
-use bevy::prelude::*;
 
 /// Circle shape to be used in the QuadTreePlugin
 /// and as a Component in the ECS.
@@ -119,19 +122,18 @@ impl UpdateCollision<GlobalTransform> for CollisionCircle {
 
 impl CollisionQuery for CollisionCircle {
     fn query(&self, obj: &dyn DynCollision) -> Relation {
-        let mut relation = Relation::Contain;
         match obj.detect(self) {
-            Relation::Contain => return Relation::Contained,
-            Relation::Contained if relation == Relation::Contain => {}
-            Relation::Contained | Relation::Overlap => return Relation::Overlap,
-            Relation::Disjoint => relation = Relation::Disjoint,
+            Relation::Contain => Relation::Contained,
+            Relation::Contained => Relation::Contain,
+            r => r,
         }
-        relation
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use bevy_math::{Rect, Rot2};
+
     use super::*;
     use std::f32::consts::*;