55c9958dd0
# Objective - Refactor collide code and add tests. ## Solution - Rebase the changes made in #4485. Co-authored-by: Eduardo Canellas de Oliveira <eduardo.canellas@bemobi.com>
298 lines
8.3 KiB
Rust
298 lines
8.3 KiB
Rust
//! Utilities for detecting if and on which side two axis-aligned bounding boxes (AABB) collide.
|
|
|
|
use bevy_math::{Vec2, Vec3};
|
|
|
|
/// The side where a collision occurred, as returned by [`collide`].
|
|
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
|
pub enum Collision {
|
|
Left,
|
|
Right,
|
|
Top,
|
|
Bottom,
|
|
Inside,
|
|
}
|
|
|
|
struct CollisionBox {
|
|
pub top: f32,
|
|
pub bottom: f32,
|
|
pub left: f32,
|
|
pub right: f32,
|
|
}
|
|
|
|
impl CollisionBox {
|
|
pub fn new(pos: Vec3, size: Vec2) -> Self {
|
|
Self {
|
|
top: pos.y + size.y / 2.,
|
|
bottom: pos.y - size.y / 2.,
|
|
left: pos.x - size.x / 2.,
|
|
right: pos.x + size.x / 2.,
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: ideally we can remove this once bevy gets a physics system
|
|
/// Axis-aligned bounding box collision with "side" detection.
|
|
///
|
|
/// The [Collision], in case it occurred, is the side of `b` where `a` hit.
|
|
///
|
|
/// * `a_pos` and `b_pos` are the center positions of the rectangles, typically obtained by
|
|
/// extracting the `translation` field from a [`Transform`](bevy_transform::components::Transform) component
|
|
/// * `a_size` and `b_size` are the dimensions (width and height) of the rectangles.
|
|
///
|
|
/// The return value is the side of `B` that `A` has collided with. [`Collision::Left`] means that
|
|
/// `A` collided with `B`'s left side. [`Collision::Top`] means that `A` collided with `B`'s top side.
|
|
/// If the collision occurs on multiple sides, the side with the shallowest penetration is returned.
|
|
/// If all sides are involved, [`Collision::Inside`] is returned.
|
|
pub fn collide(a_pos: Vec3, a_size: Vec2, b_pos: Vec3, b_size: Vec2) -> Option<Collision> {
|
|
let a = CollisionBox::new(a_pos, a_size);
|
|
let b = CollisionBox::new(b_pos, b_size);
|
|
|
|
// check to see if the two rectangles are intersecting
|
|
if a.left < b.right && a.right > b.left && a.bottom < b.top && a.top > b.bottom {
|
|
// check to see if we hit on the left or right side
|
|
let (x_collision, x_depth) = if a.left < b.left && a.right > b.left && a.right < b.right {
|
|
(Collision::Left, b.left - a.right)
|
|
} else if a.left > b.left && a.left < b.right && a.right > b.right {
|
|
(Collision::Right, a.left - b.right)
|
|
} else {
|
|
(Collision::Inside, -f32::INFINITY)
|
|
};
|
|
|
|
// check to see if we hit on the top or bottom side
|
|
let (y_collision, y_depth) = if a.bottom < b.bottom && a.top > b.bottom && a.top < b.top {
|
|
(Collision::Bottom, b.bottom - a.top)
|
|
} else if a.bottom > b.bottom && a.bottom < b.top && a.top > b.top {
|
|
(Collision::Top, a.bottom - b.top)
|
|
} else {
|
|
(Collision::Inside, -f32::INFINITY)
|
|
};
|
|
|
|
// if we had an "x" and a "y" collision, pick the "primary" side using penetration depth
|
|
if y_depth.abs() < x_depth.abs() {
|
|
Some(y_collision)
|
|
} else {
|
|
Some(x_collision)
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
///
|
|
///
|
|
/// ______
|
|
/// | |
|
|
/// | A |
|
|
/// ----|----|----
|
|
/// | |____| |
|
|
/// | B |
|
|
/// |____________|
|
|
///
|
|
#[test]
|
|
fn top_collision() {
|
|
let a = Vec3::new(0., 30., 0.);
|
|
let b = Vec3::new(0., 0., 0.);
|
|
|
|
check(a, b, Some(Collision::Top));
|
|
}
|
|
|
|
///
|
|
///
|
|
/// --------------
|
|
/// | B |
|
|
/// | _____ |
|
|
/// |___|____|___|
|
|
/// | |
|
|
/// | A |
|
|
/// | |
|
|
/// -----
|
|
#[test]
|
|
fn bottom_collision() {
|
|
let a = Vec3::new(0., -30., 0.);
|
|
let b = Vec3::new(0., 0., 0.);
|
|
|
|
check(a, b, Some(Collision::Bottom));
|
|
}
|
|
|
|
///
|
|
/// ______
|
|
/// | --|-----------
|
|
/// | | | |
|
|
/// | A | | B |
|
|
/// | |_|__________|
|
|
/// |_____|
|
|
///
|
|
#[test]
|
|
fn left_collision() {
|
|
let a = Vec3::new(0., 0., 0.);
|
|
let b = Vec3::new(30., 0., 0.);
|
|
|
|
check(a, b, Some(Collision::Left));
|
|
}
|
|
|
|
///
|
|
/// ______
|
|
/// -----------|-- |
|
|
/// | B | | |
|
|
/// | | | A |
|
|
/// |__________|_| |
|
|
/// |_____|
|
|
#[test]
|
|
fn right_collision() {
|
|
let a = Vec3::new(0., 0., 0.);
|
|
let b = Vec3::new(-30., 0., 0.);
|
|
|
|
check(a, b, Some(Collision::Right));
|
|
}
|
|
|
|
///
|
|
/// ______
|
|
/// ----|----|----
|
|
/// | | | |
|
|
/// | | | B |
|
|
/// |___|____|___|
|
|
/// | A |
|
|
/// |____|
|
|
#[test]
|
|
fn without_corners_on_intersection_area() {
|
|
let a = Vec3::new(0., 0., 0.);
|
|
let b = Vec3::new(0., 0., 0.);
|
|
|
|
check(a, b, Some(Collision::Inside));
|
|
}
|
|
|
|
fn check(a: Vec3, b: Vec3, expected: Option<Collision>) {
|
|
let a_size = Vec2::new(30., 50.);
|
|
let b_size = Vec2::new(50., 30.);
|
|
assert_eq!(collide(a, a_size, b, b_size), expected);
|
|
}
|
|
|
|
fn collide_two_rectangles(
|
|
// (x, y, size x, size y)
|
|
a: (f32, f32, f32, f32),
|
|
b: (f32, f32, f32, f32),
|
|
) -> Option<Collision> {
|
|
collide(
|
|
Vec3::new(a.0, a.1, 0.),
|
|
Vec2::new(a.2, a.3),
|
|
Vec3::new(b.0, b.1, 0.),
|
|
Vec2::new(b.2, b.3),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn inside_collision() {
|
|
// Identical
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(1., 1., 1., 1.),
|
|
(1., 1., 1., 1.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Inside));
|
|
// B inside A
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(2., 2., 2., 2.),
|
|
(2., 2., 1., 1.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Inside));
|
|
// A inside B
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(2., 2., 1., 1.),
|
|
(2., 2., 2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Inside));
|
|
}
|
|
|
|
#[test]
|
|
fn collision_based_on_b() {
|
|
// Right of B
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(3., 2., 2., 2.),
|
|
(2., 2., 2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Right));
|
|
// Left of B
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(1., 2., 2., 2.),
|
|
(2., 2., 2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Left));
|
|
// Top of B
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(2., 3., 2., 2.),
|
|
(2., 2., 2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Top));
|
|
// Bottom of B
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(2., 1., 2., 2.),
|
|
(2., 2., 2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Bottom));
|
|
}
|
|
|
|
// In case the X-collision depth is equal to the Y-collision depth, always
|
|
// prefer X-collision, meaning, `Left` or `Right` over `Top` and `Bottom`.
|
|
#[test]
|
|
fn prefer_x_collision() {
|
|
// Bottom-left collision
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(1., 1., 2., 2.),
|
|
(2., 2., 2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Left));
|
|
// Top-left collision
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(1., 3., 2., 2.),
|
|
(2., 2., 2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Left));
|
|
// Bottom-right collision
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(3., 1., 2., 2.),
|
|
(2., 2., 2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Right));
|
|
// Top-right collision
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(3., 3., 2., 2.),
|
|
(2., 2., 2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Right));
|
|
}
|
|
|
|
// If the collision intersection area stretches more along the Y-axis then
|
|
// return `Top` or `Bottom`. Otherwise, `Left` or `Right`.
|
|
#[test]
|
|
fn collision_depth_wins() {
|
|
// Top-right collision
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(3., 3., 2., 2.),
|
|
(2.5, 2.,2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Top));
|
|
// Top-right collision
|
|
#[rustfmt::skip]
|
|
let res = collide_two_rectangles(
|
|
(3., 3., 2., 2.),
|
|
(2., 2.5, 2., 2.),
|
|
);
|
|
assert_eq!(res, Some(Collision::Right));
|
|
}
|
|
}
|