Add example for bounding volumes and intersection tests (#11666)

# Objective

- Create an example for bounding volumes and intersection tests

## Solution

- Add an example with a few bounding volumes, created from primitives
- Allow the user to cycle trough the different intersection tests

Cargo.toml

@@ -528,6 +528,17 @@ description = "Shows how to create graphics that snap to the pixel grid by rende
 category = "2D Rendering"
 wasm = true
 
+[[example]]
+name = "bounding_2d"
+path = "examples/2d/bounding_2d.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.bounding_2d]
+name = "2D Bounding Volume Intersections"
+description = "Showcases bounding volumes and intersection tests"
+category = "2D Rendering"
+wasm = true
+
 # 3D Rendering
 [[example]]
 name = "3d_scene"

examples/2d/bounding_2d.rs

@@ -0,0 +1,444 @@
+//! This example demonstrates bounding volume intersections.
+
+use bevy::{math::bounding::*, prelude::*};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .init_state::<Test>()
+        .add_systems(Startup, setup)
+        .add_systems(
+            Update,
+            (update_text, spin, update_volumes, update_test_state),
+        )
+        .add_systems(
+            PostUpdate,
+            (
+                render_shapes,
+                (
+                    aabb_intersection_system.run_if(in_state(Test::AabbSweep)),
+                    circle_intersection_system.run_if(in_state(Test::CircleSweep)),
+                    ray_cast_system.run_if(in_state(Test::RayCast)),
+                    aabb_cast_system.run_if(in_state(Test::AabbCast)),
+                    bounding_circle_cast_system.run_if(in_state(Test::CircleCast)),
+                ),
+                render_volumes,
+            )
+                .chain(),
+        )
+        .run();
+}
+
+#[derive(Component)]
+struct Spin;
+
+fn spin(time: Res<Time>, mut query: Query<&mut Transform, With<Spin>>) {
+    for mut transform in query.iter_mut() {
+        transform.rotation *= Quat::from_rotation_z(time.delta_seconds() / 5.);
+    }
+}
+
+#[derive(States, Default, Debug, Hash, PartialEq, Eq, Clone, Copy)]
+enum Test {
+    AabbSweep,
+    CircleSweep,
+    #[default]
+    RayCast,
+    AabbCast,
+    CircleCast,
+}
+
+fn update_test_state(
+    keycode: Res<ButtonInput<KeyCode>>,
+    cur_state: Res<State<Test>>,
+    mut state: ResMut<NextState<Test>>,
+) {
+    if !keycode.just_pressed(KeyCode::Space) {
+        return;
+    }
+
+    use Test::*;
+    let next = match **cur_state {
+        AabbSweep => CircleSweep,
+        CircleSweep => RayCast,
+        RayCast => AabbCast,
+        AabbCast => CircleCast,
+        CircleCast => AabbSweep,
+    };
+    state.set(next);
+}
+
+fn update_text(mut text: Query<&mut Text>, cur_state: Res<State<Test>>) {
+    if !cur_state.is_changed() {
+        return;
+    }
+
+    let mut text = text.single_mut();
+    let text = &mut text.sections[0].value;
+    text.clear();
+
+    text.push_str("Intersection test:\n");
+    use Test::*;
+    for &test in &[AabbSweep, CircleSweep, RayCast, AabbCast, CircleCast] {
+        let s = if **cur_state == test { "*" } else { " " };
+        text.push_str(&format!(" {s} {test:?} {s}\n"));
+    }
+    text.push_str("\npress Space to cycle");
+}
+
+#[derive(Component)]
+enum Shape {
+    Rectangle(Rectangle),
+    Circle(Circle),
+    Triangle(Triangle2d),
+    Line(Segment2d),
+    Capsule(Capsule2d),
+    Polygon(RegularPolygon),
+}
+
+fn render_shapes(mut gizmos: Gizmos, query: Query<(&Shape, &Transform)>) {
+    let color = Color::GRAY;
+    for (shape, transform) in query.iter() {
+        let translation = transform.translation.xy();
+        let rotation = transform.rotation.to_euler(EulerRot::YXZ).2;
+        match shape {
+            Shape::Rectangle(r) => {
+                gizmos.primitive_2d(*r, translation, rotation, color);
+            }
+            Shape::Circle(c) => {
+                gizmos.primitive_2d(*c, translation, rotation, color);
+            }
+            Shape::Triangle(t) => {
+                gizmos.primitive_2d(*t, translation, rotation, color);
+            }
+            Shape::Line(l) => {
+                gizmos.primitive_2d(*l, translation, rotation, color);
+            }
+            Shape::Capsule(c) => {
+                gizmos.primitive_2d(*c, translation, rotation, color);
+            }
+            Shape::Polygon(p) => {
+                gizmos.primitive_2d(*p, translation, rotation, color);
+            }
+        }
+    }
+}
+
+#[derive(Component)]
+enum DesiredVolume {
+    Aabb,
+    Circle,
+}
+
+#[derive(Component, Debug)]
+enum CurrentVolume {
+    Aabb(Aabb2d),
+    Circle(BoundingCircle),
+}
+
+fn update_volumes(
+    mut commands: Commands,
+    query: Query<
+        (Entity, &DesiredVolume, &Shape, &Transform),
+        Or<(Changed<DesiredVolume>, Changed<Shape>, Changed<Transform>)>,
+    >,
+) {
+    for (entity, desired_volume, shape, transform) in query.iter() {
+        let translation = transform.translation.xy();
+        let rotation = transform.rotation.to_euler(EulerRot::YXZ).2;
+        match desired_volume {
+            DesiredVolume::Aabb => {
+                let aabb = match shape {
+                    Shape::Rectangle(r) => r.aabb_2d(translation, rotation),
+                    Shape::Circle(c) => c.aabb_2d(translation, rotation),
+                    Shape::Triangle(t) => t.aabb_2d(translation, rotation),
+                    Shape::Line(l) => l.aabb_2d(translation, rotation),
+                    Shape::Capsule(c) => c.aabb_2d(translation, rotation),
+                    Shape::Polygon(p) => p.aabb_2d(translation, rotation),
+                };
+                commands.entity(entity).insert(CurrentVolume::Aabb(aabb));
+            }
+            DesiredVolume::Circle => {
+                let circle = match shape {
+                    Shape::Rectangle(r) => r.bounding_circle(translation, rotation),
+                    Shape::Circle(c) => c.bounding_circle(translation, rotation),
+                    Shape::Triangle(t) => t.bounding_circle(translation, rotation),
+                    Shape::Line(l) => l.bounding_circle(translation, rotation),
+                    Shape::Capsule(c) => c.bounding_circle(translation, rotation),
+                    Shape::Polygon(p) => p.bounding_circle(translation, rotation),
+                };
+                commands
+                    .entity(entity)
+                    .insert(CurrentVolume::Circle(circle));
+            }
+        }
+    }
+}
+
+fn render_volumes(mut gizmos: Gizmos, query: Query<(&CurrentVolume, &Intersects)>) {
+    for (volume, intersects) in query.iter() {
+        let color = if **intersects {
+            Color::CYAN
+        } else {
+            Color::ORANGE_RED
+        };
+        match volume {
+            CurrentVolume::Aabb(a) => {
+                gizmos.rect_2d(a.center(), 0., a.half_size() * 2., color);
+            }
+            CurrentVolume::Circle(c) => {
+                gizmos.circle_2d(c.center(), c.radius(), color);
+            }
+        }
+    }
+}
+
+#[derive(Component, Deref, DerefMut, Default)]
+struct Intersects(bool);
+
+const OFFSET_X: f32 = 125.;
+const OFFSET_Y: f32 = 75.;
+
+fn setup(mut commands: Commands, loader: Res<AssetServer>) {
+    commands.spawn(Camera2dBundle::default());
+    commands.spawn((
+        SpatialBundle {
+            transform: Transform::from_xyz(-OFFSET_X, OFFSET_Y, 0.),
+            ..default()
+        },
+        Shape::Circle(Circle::new(45.)),
+        DesiredVolume::Aabb,
+        Intersects::default(),
+    ));
+
+    commands.spawn((
+        SpatialBundle {
+            transform: Transform::from_xyz(0., OFFSET_Y, 0.),
+            ..default()
+        },
+        Shape::Rectangle(Rectangle::new(80., 80.)),
+        Spin,
+        DesiredVolume::Circle,
+        Intersects::default(),
+    ));
+
+    commands.spawn((
+        SpatialBundle {
+            transform: Transform::from_xyz(OFFSET_X, OFFSET_Y, 0.),
+            ..default()
+        },
+        Shape::Triangle(Triangle2d::new(
+            Vec2::new(-40., -40.),
+            Vec2::new(-20., 40.),
+            Vec2::new(40., 50.),
+        )),
+        Spin,
+        DesiredVolume::Aabb,
+        Intersects::default(),
+    ));
+
+    commands.spawn((
+        SpatialBundle {
+            transform: Transform::from_xyz(-OFFSET_X, -OFFSET_Y, 0.),
+            ..default()
+        },
+        Shape::Line(Segment2d::new(Direction2d::from_xy(1., 0.3).unwrap(), 90.)),
+        Spin,
+        DesiredVolume::Circle,
+        Intersects::default(),
+    ));
+
+    commands.spawn((
+        SpatialBundle {
+            transform: Transform::from_xyz(0., -OFFSET_Y, 0.),
+            ..default()
+        },
+        Shape::Capsule(Capsule2d::new(25., 50.)),
+        Spin,
+        DesiredVolume::Aabb,
+        Intersects::default(),
+    ));
+
+    commands.spawn((
+        SpatialBundle {
+            transform: Transform::from_xyz(OFFSET_X, -OFFSET_Y, 0.),
+            ..default()
+        },
+        Shape::Polygon(RegularPolygon::new(50., 6)),
+        Spin,
+        DesiredVolume::Circle,
+        Intersects::default(),
+    ));
+
+    commands.spawn(
+        TextBundle::from_section(
+            "",
+            TextStyle {
+                font: loader.load("fonts/FiraMono-Medium.ttf"),
+                font_size: 26.0,
+                ..default()
+            },
+        )
+        .with_style(Style {
+            position_type: PositionType::Absolute,
+            bottom: Val::Px(10.0),
+            left: Val::Px(10.0),
+            ..default()
+        }),
+    );
+}
+
+fn draw_ray(gizmos: &mut Gizmos, ray: &RayCast2d) {
+    gizmos.line_2d(
+        ray.ray.origin,
+        ray.ray.origin + *ray.ray.direction * ray.max,
+        Color::WHITE,
+    );
+    for r in [1., 2., 3.] {
+        gizmos.circle_2d(ray.ray.origin, r, Color::FUCHSIA);
+    }
+}
+
+fn get_and_draw_ray(gizmos: &mut Gizmos, time: &Time) -> RayCast2d {
+    let ray = Vec2::new(time.elapsed_seconds().cos(), time.elapsed_seconds().sin());
+    let dist = 150. + (0.5 * time.elapsed_seconds()).sin().abs() * 500.;
+
+    let aabb_ray = Ray2d {
+        origin: ray * 250.,
+        direction: Direction2d::new_unchecked(-ray),
+    };
+    let ray_cast = RayCast2d::from_ray(aabb_ray, dist - 20.);
+
+    draw_ray(gizmos, &ray_cast);
+    ray_cast
+}
+
+fn ray_cast_system(
+    mut gizmos: Gizmos,
+    time: Res<Time>,
+    mut volumes: Query<(&CurrentVolume, &mut Intersects)>,
+) {
+    let ray_cast = get_and_draw_ray(&mut gizmos, &time);
+
+    for (volume, mut intersects) in volumes.iter_mut() {
+        let toi = match volume {
+            CurrentVolume::Aabb(a) => ray_cast.aabb_intersection_at(a),
+            CurrentVolume::Circle(c) => ray_cast.circle_intersection_at(c),
+        };
+        **intersects = toi.is_some();
+        if let Some(toi) = toi {
+            for r in [1., 2., 3.] {
+                gizmos.circle_2d(
+                    ray_cast.ray.origin + *ray_cast.ray.direction * toi,
+                    r,
+                    Color::GREEN,
+                );
+            }
+        }
+    }
+}
+
+fn aabb_cast_system(
+    mut gizmos: Gizmos,
+    time: Res<Time>,
+    mut volumes: Query<(&CurrentVolume, &mut Intersects)>,
+) {
+    let ray_cast = get_and_draw_ray(&mut gizmos, &time);
+    let aabb_cast = AabbCast2d {
+        aabb: Aabb2d::new(Vec2::ZERO, Vec2::splat(15.)),
+        ray: ray_cast,
+    };
+
+    for (volume, mut intersects) in volumes.iter_mut() {
+        let toi = match *volume {
+            CurrentVolume::Aabb(a) => aabb_cast.aabb_collision_at(a),
+            CurrentVolume::Circle(_) => None,
+        };
+
+        **intersects = toi.is_some();
+        if let Some(toi) = toi {
+            gizmos.rect_2d(
+                aabb_cast.ray.ray.origin
+                    + *aabb_cast.ray.ray.direction * toi
+                    + aabb_cast.aabb.center(),
+                0.,
+                aabb_cast.aabb.half_size() * 2.,
+                Color::GREEN,
+            );
+        }
+    }
+}
+
+fn bounding_circle_cast_system(
+    mut gizmos: Gizmos,
+    time: Res<Time>,
+    mut volumes: Query<(&CurrentVolume, &mut Intersects)>,
+) {
+    let ray_cast = get_and_draw_ray(&mut gizmos, &time);
+    let circle_cast = BoundingCircleCast {
+        circle: BoundingCircle::new(Vec2::ZERO, 15.),
+        ray: ray_cast,
+    };
+
+    for (volume, mut intersects) in volumes.iter_mut() {
+        let toi = match *volume {
+            CurrentVolume::Aabb(_) => None,
+            CurrentVolume::Circle(c) => circle_cast.circle_collision_at(c),
+        };
+
+        **intersects = toi.is_some();
+        if let Some(toi) = toi {
+            gizmos.circle_2d(
+                circle_cast.ray.ray.origin
+                    + *circle_cast.ray.ray.direction * toi
+                    + circle_cast.circle.center(),
+                circle_cast.circle.radius(),
+                Color::GREEN,
+            );
+        }
+    }
+}
+
+fn get_intersection_position(time: &Time) -> Vec2 {
+    let x = (0.8 * time.elapsed_seconds()).cos() * 250.;
+    let y = (0.4 * time.elapsed_seconds()).sin() * 100.;
+    Vec2::new(x, y)
+}
+
+fn aabb_intersection_system(
+    mut gizmos: Gizmos,
+    time: Res<Time>,
+    mut volumes: Query<(&CurrentVolume, &mut Intersects)>,
+) {
+    let center = get_intersection_position(&time);
+    let aabb = Aabb2d::new(center, Vec2::splat(50.));
+    gizmos.rect_2d(center, 0., aabb.half_size() * 2., Color::YELLOW);
+
+    for (volume, mut intersects) in volumes.iter_mut() {
+        let hit = match volume {
+            CurrentVolume::Aabb(a) => aabb.intersects(a),
+            CurrentVolume::Circle(c) => aabb.intersects(c),
+        };
+
+        **intersects = hit;
+    }
+}
+
+fn circle_intersection_system(
+    mut gizmos: Gizmos,
+    time: Res<Time>,
+    mut volumes: Query<(&CurrentVolume, &mut Intersects)>,
+) {
+    let center = get_intersection_position(&time);
+    let circle = BoundingCircle::new(center, 50.);
+    gizmos.circle_2d(center, circle.radius(), Color::YELLOW);
+
+    for (volume, mut intersects) in volumes.iter_mut() {
+        let hit = match volume {
+            CurrentVolume::Aabb(a) => circle.intersects(a),
+            CurrentVolume::Circle(c) => circle.intersects(c),
+        };
+
+        **intersects = hit;
+    }
+}

examples/README.md

@@ -93,6 +93,7 @@ Example | Description
 Example | Description
 --- | ---
 [2D Bloom](../examples/2d/bloom_2d.rs) | Illustrates bloom post-processing in 2d
+[2D Bounding Volume Intersections](../examples/2d/bounding_2d.rs) | Showcases bounding volumes and intersection tests
 [2D Gizmos](../examples/2d/2d_gizmos.rs) | A scene showcasing 2D gizmos
 [2D Rotation](../examples/2d/rotation.rs) | Demonstrates rotating entities in 2D with quaternions
 [2D Shapes](../examples/2d/2d_shapes.rs) | Renders simple 2D primitive shapes like circles and polygons