mirror of
https://github.com/bevyengine/bevy
synced 2025-01-12 05:09:00 +00:00
21b78b5990
# Objective
Several of our APIs (namely gizmos and bounding) use isometries on
current Bevy main. This is nicer than separate properties in a lot of
cases, but users have still expressed usability concerns.
One problem is that in a lot of cases, you only care about e.g.
translation, so you end up with this:
```rust
gizmos.cross_2d(
Isometry2d::from_translation(Vec2::new(-160.0, 120.0)),
12.0,
FUCHSIA,
);
```
The isometry adds quite a lot of length and verbosity, and isn't really
that relevant since only the translation is important here.
It would be nice if you could use the translation directly, and only
supply an isometry if both translation and rotation are needed. This
would make the following possible:
```rust
gizmos.cross_2d(Vec2::new(-160.0, 120.0), 12.0, FUCHSIA);
```
removing a lot of verbosity.
## Solution
Implement `From<Vec2>` and `From<Rot2>` for `Isometry2d`, and
`From<Vec3>`, `From<Vec3A>`, and `From<Quat>` for `Isometry3d`. These
are lossless conversions that fit the semantics of `From`.
This makes the proposed API possible! The methods must now simply take
an `impl Into<IsometryNd>`, and this works:
```rust
gizmos.cross_2d(Vec2::new(-160.0, 120.0), 12.0, FUCHSIA);
```
374 lines
13 KiB
Rust
374 lines
13 KiB
Rust
//! Additional [`Gizmos`] Functions -- Rounded cuboids and rectangles
|
|
//!
|
|
//! Includes the implementation of [`Gizmos::rounded_rect`], [`Gizmos::rounded_rect_2d`] and [`Gizmos::rounded_cuboid`].
|
|
//! and assorted support items.
|
|
|
|
use core::f32::consts::FRAC_PI_2;
|
|
|
|
use crate::prelude::{GizmoConfigGroup, Gizmos};
|
|
use bevy_color::Color;
|
|
use bevy_math::{Isometry2d, Isometry3d, Quat, Vec2, Vec3};
|
|
use bevy_transform::components::Transform;
|
|
|
|
/// A builder returned by [`Gizmos::rounded_rect`] and [`Gizmos::rounded_rect_2d`]
|
|
pub struct RoundedRectBuilder<'a, 'w, 's, T: GizmoConfigGroup> {
|
|
size: Vec2,
|
|
gizmos: &'a mut Gizmos<'w, 's, T>,
|
|
config: RoundedBoxConfig,
|
|
}
|
|
/// A builder returned by [`Gizmos::rounded_cuboid`]
|
|
pub struct RoundedCuboidBuilder<'a, 'w, 's, T: GizmoConfigGroup> {
|
|
size: Vec3,
|
|
gizmos: &'a mut Gizmos<'w, 's, T>,
|
|
config: RoundedBoxConfig,
|
|
}
|
|
struct RoundedBoxConfig {
|
|
isometry: Isometry3d,
|
|
color: Color,
|
|
corner_radius: f32,
|
|
arc_resolution: u32,
|
|
}
|
|
|
|
impl<T: GizmoConfigGroup> RoundedRectBuilder<'_, '_, '_, T> {
|
|
/// Change the radius of the corners to be `corner_radius`.
|
|
/// The default corner radius is [min axis of size] / 10.0
|
|
pub fn corner_radius(mut self, corner_radius: f32) -> Self {
|
|
self.config.corner_radius = corner_radius;
|
|
self
|
|
}
|
|
|
|
/// Change the resolution of the arcs at the corners of the rectangle.
|
|
/// The default value is 8
|
|
pub fn arc_resolution(mut self, arc_resolution: u32) -> Self {
|
|
self.config.arc_resolution = arc_resolution;
|
|
self
|
|
}
|
|
}
|
|
impl<T: GizmoConfigGroup> RoundedCuboidBuilder<'_, '_, '_, T> {
|
|
/// Change the radius of the edges to be `edge_radius`.
|
|
/// The default edge radius is [min axis of size] / 10.0
|
|
pub fn edge_radius(mut self, edge_radius: f32) -> Self {
|
|
self.config.corner_radius = edge_radius;
|
|
self
|
|
}
|
|
|
|
/// Change the resolution of the arcs at the edges of the cuboid.
|
|
/// The default value is 8
|
|
pub fn arc_resolution(mut self, arc_resolution: u32) -> Self {
|
|
self.config.arc_resolution = arc_resolution;
|
|
self
|
|
}
|
|
}
|
|
|
|
impl<T: GizmoConfigGroup> Drop for RoundedRectBuilder<'_, '_, '_, T> {
|
|
fn drop(&mut self) {
|
|
if !self.gizmos.enabled {
|
|
return;
|
|
}
|
|
let config = &self.config;
|
|
|
|
// Calculate inner and outer half size and ensure that the edge_radius is <= any half_length
|
|
let mut outer_half_size = self.size.abs() / 2.0;
|
|
let inner_half_size =
|
|
(outer_half_size - Vec2::splat(config.corner_radius.abs())).max(Vec2::ZERO);
|
|
let corner_radius = (outer_half_size - inner_half_size).min_element();
|
|
let mut inner_half_size = outer_half_size - Vec2::splat(corner_radius);
|
|
|
|
if config.corner_radius < 0. {
|
|
core::mem::swap(&mut outer_half_size, &mut inner_half_size);
|
|
}
|
|
|
|
// Handle cases where the rectangle collapses into simpler shapes
|
|
if outer_half_size.x * outer_half_size.y == 0. {
|
|
self.gizmos.line(
|
|
config.isometry * -outer_half_size.extend(0.),
|
|
config.isometry * outer_half_size.extend(0.),
|
|
config.color,
|
|
);
|
|
return;
|
|
}
|
|
if corner_radius == 0. {
|
|
self.gizmos.rect(config.isometry, self.size, config.color);
|
|
return;
|
|
}
|
|
|
|
let vertices = [
|
|
// top right
|
|
Vec3::new(inner_half_size.x, outer_half_size.y, 0.),
|
|
Vec3::new(inner_half_size.x, inner_half_size.y, 0.),
|
|
Vec3::new(outer_half_size.x, inner_half_size.y, 0.),
|
|
// bottom right
|
|
Vec3::new(outer_half_size.x, -inner_half_size.y, 0.),
|
|
Vec3::new(inner_half_size.x, -inner_half_size.y, 0.),
|
|
Vec3::new(inner_half_size.x, -outer_half_size.y, 0.),
|
|
// bottom left
|
|
Vec3::new(-inner_half_size.x, -outer_half_size.y, 0.),
|
|
Vec3::new(-inner_half_size.x, -inner_half_size.y, 0.),
|
|
Vec3::new(-outer_half_size.x, -inner_half_size.y, 0.),
|
|
// top left
|
|
Vec3::new(-outer_half_size.x, inner_half_size.y, 0.),
|
|
Vec3::new(-inner_half_size.x, inner_half_size.y, 0.),
|
|
Vec3::new(-inner_half_size.x, outer_half_size.y, 0.),
|
|
]
|
|
.map(|vec3| config.isometry * vec3);
|
|
|
|
for chunk in vertices.chunks_exact(3) {
|
|
self.gizmos
|
|
.short_arc_3d_between(chunk[1], chunk[0], chunk[2], config.color)
|
|
.resolution(config.arc_resolution);
|
|
}
|
|
|
|
let edges = if config.corner_radius > 0. {
|
|
[
|
|
(vertices[2], vertices[3]),
|
|
(vertices[5], vertices[6]),
|
|
(vertices[8], vertices[9]),
|
|
(vertices[11], vertices[0]),
|
|
]
|
|
} else {
|
|
[
|
|
(vertices[0], vertices[5]),
|
|
(vertices[3], vertices[8]),
|
|
(vertices[6], vertices[11]),
|
|
(vertices[9], vertices[2]),
|
|
]
|
|
};
|
|
|
|
for (start, end) in edges {
|
|
self.gizmos.line(start, end, config.color);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: GizmoConfigGroup> Drop for RoundedCuboidBuilder<'_, '_, '_, T> {
|
|
fn drop(&mut self) {
|
|
if !self.gizmos.enabled {
|
|
return;
|
|
}
|
|
let config = &self.config;
|
|
|
|
// Calculate inner and outer half size and ensure that the edge_radius is <= any half_length
|
|
let outer_half_size = self.size.abs() / 2.0;
|
|
let inner_half_size =
|
|
(outer_half_size - Vec3::splat(config.corner_radius.abs())).max(Vec3::ZERO);
|
|
let mut edge_radius = (outer_half_size - inner_half_size).min_element();
|
|
let inner_half_size = outer_half_size - Vec3::splat(edge_radius);
|
|
edge_radius *= config.corner_radius.signum();
|
|
|
|
// Handle cases where the rounded cuboid collapses into simpler shapes
|
|
if edge_radius == 0.0 {
|
|
let transform = Transform::from_translation(config.isometry.translation.into())
|
|
.with_rotation(config.isometry.rotation)
|
|
.with_scale(self.size);
|
|
self.gizmos.cuboid(transform, config.color);
|
|
return;
|
|
}
|
|
|
|
let rects = [
|
|
(
|
|
Vec3::X,
|
|
Vec2::new(self.size.z, self.size.y),
|
|
Quat::from_rotation_y(FRAC_PI_2),
|
|
),
|
|
(
|
|
Vec3::Y,
|
|
Vec2::new(self.size.x, self.size.z),
|
|
Quat::from_rotation_x(FRAC_PI_2),
|
|
),
|
|
(Vec3::Z, Vec2::new(self.size.x, self.size.y), Quat::IDENTITY),
|
|
];
|
|
|
|
for (position, size, rotation) in rects {
|
|
let local_position = position * inner_half_size;
|
|
self.gizmos
|
|
.rounded_rect(
|
|
config.isometry * Isometry3d::new(local_position, rotation),
|
|
size,
|
|
config.color,
|
|
)
|
|
.arc_resolution(config.arc_resolution)
|
|
.corner_radius(edge_radius);
|
|
|
|
self.gizmos
|
|
.rounded_rect(
|
|
config.isometry * Isometry3d::new(-local_position, rotation),
|
|
size,
|
|
config.color,
|
|
)
|
|
.arc_resolution(config.arc_resolution)
|
|
.corner_radius(edge_radius);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'w, 's, T: GizmoConfigGroup> Gizmos<'w, 's, T> {
|
|
/// Draw a wireframe rectangle with rounded corners in 3D.
|
|
///
|
|
/// This should be called for each frame the rectangle needs to be rendered.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// - `isometry` defines the translation and rotation of the rectangle.
|
|
/// - the translation specifies the center of the rectangle
|
|
/// - defines orientation of the rectangle, by default we
|
|
/// assume the rectangle is contained in a plane parallel
|
|
/// to the XY plane.
|
|
/// - `size`: defines the size of the rectangle. This refers to the 'outer size', similar to a bounding box.
|
|
/// - `color`: color of the rectangle
|
|
///
|
|
/// # Builder methods
|
|
///
|
|
/// - The corner radius can be adjusted with the `.corner_radius(...)` method.
|
|
/// - The resolution of the arcs at each corner (i.e. the level of detail) can be adjusted with the
|
|
/// `.arc_resolution(...)` method.
|
|
///
|
|
/// # Example
|
|
/// ```
|
|
/// # use bevy_gizmos::prelude::*;
|
|
/// # use bevy_math::prelude::*;
|
|
/// # use bevy_color::palettes::css::GREEN;
|
|
/// fn system(mut gizmos: Gizmos) {
|
|
/// gizmos.rounded_rect(
|
|
/// Isometry3d::IDENTITY,
|
|
/// Vec2::ONE,
|
|
/// GREEN
|
|
/// )
|
|
/// .corner_radius(0.25)
|
|
/// .arc_resolution(10);
|
|
/// }
|
|
/// # bevy_ecs::system::assert_is_system(system);
|
|
/// ```
|
|
pub fn rounded_rect(
|
|
&mut self,
|
|
isometry: impl Into<Isometry3d>,
|
|
size: Vec2,
|
|
color: impl Into<Color>,
|
|
) -> RoundedRectBuilder<'_, 'w, 's, T> {
|
|
let corner_radius = size.min_element() * DEFAULT_CORNER_RADIUS;
|
|
RoundedRectBuilder {
|
|
gizmos: self,
|
|
config: RoundedBoxConfig {
|
|
isometry: isometry.into(),
|
|
color: color.into(),
|
|
corner_radius,
|
|
arc_resolution: DEFAULT_ARC_RESOLUTION,
|
|
},
|
|
size,
|
|
}
|
|
}
|
|
|
|
/// Draw a wireframe rectangle with rounded corners in 2D.
|
|
///
|
|
/// This should be called for each frame the rectangle needs to be rendered.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// - `isometry` defines the translation and rotation of the rectangle.
|
|
/// - the translation specifies the center of the rectangle
|
|
/// - defines orientation of the rectangle, by default we
|
|
/// assume the rectangle aligned with all axes.
|
|
/// - `size`: defines the size of the rectangle. This refers to the 'outer size', similar to a bounding box.
|
|
/// - `color`: color of the rectangle
|
|
///
|
|
/// # Builder methods
|
|
///
|
|
/// - The corner radius can be adjusted with the `.corner_radius(...)` method.
|
|
/// - The resolution of the arcs at each corner (i.e. the level of detail) can be adjusted with the
|
|
/// `.arc_resolution(...)` method.
|
|
///
|
|
/// # Example
|
|
/// ```
|
|
/// # use bevy_gizmos::prelude::*;
|
|
/// # use bevy_math::prelude::*;
|
|
/// # use bevy_color::palettes::css::GREEN;
|
|
/// fn system(mut gizmos: Gizmos) {
|
|
/// gizmos.rounded_rect_2d(
|
|
/// Isometry2d::IDENTITY,
|
|
/// Vec2::ONE,
|
|
/// GREEN
|
|
/// )
|
|
/// .corner_radius(0.25)
|
|
/// .arc_resolution(10);
|
|
/// }
|
|
/// # bevy_ecs::system::assert_is_system(system);
|
|
/// ```
|
|
pub fn rounded_rect_2d(
|
|
&mut self,
|
|
isometry: impl Into<Isometry2d>,
|
|
size: Vec2,
|
|
color: impl Into<Color>,
|
|
) -> RoundedRectBuilder<'_, 'w, 's, T> {
|
|
let isometry = isometry.into();
|
|
let corner_radius = size.min_element() * DEFAULT_CORNER_RADIUS;
|
|
RoundedRectBuilder {
|
|
gizmos: self,
|
|
config: RoundedBoxConfig {
|
|
isometry: Isometry3d::new(
|
|
isometry.translation.extend(0.0),
|
|
Quat::from_rotation_z(isometry.rotation.as_radians()),
|
|
),
|
|
color: color.into(),
|
|
corner_radius,
|
|
arc_resolution: DEFAULT_ARC_RESOLUTION,
|
|
},
|
|
size,
|
|
}
|
|
}
|
|
|
|
/// Draw a wireframe cuboid with rounded corners in 3D.
|
|
///
|
|
/// This should be called for each frame the cuboid needs to be rendered.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// - `isometry` defines the translation and rotation of the cuboid.
|
|
/// - the translation specifies the center of the cuboid
|
|
/// - defines orientation of the cuboid, by default we
|
|
/// assume the cuboid aligned with all axes.
|
|
/// - `size`: defines the size of the cuboid. This refers to the 'outer size', similar to a bounding box.
|
|
/// - `color`: color of the cuboid
|
|
///
|
|
/// # Builder methods
|
|
///
|
|
/// - The edge radius can be adjusted with the `.edge_radius(...)` method.
|
|
/// - The resolution of the arcs at each edge (i.e. the level of detail) can be adjusted with the
|
|
/// `.arc_resolution(...)` method.
|
|
///
|
|
/// # Example
|
|
/// ```
|
|
/// # use bevy_gizmos::prelude::*;
|
|
/// # use bevy_math::prelude::*;
|
|
/// # use bevy_color::palettes::css::GREEN;
|
|
/// fn system(mut gizmos: Gizmos) {
|
|
/// gizmos.rounded_cuboid(
|
|
/// Isometry3d::IDENTITY,
|
|
/// Vec3::ONE,
|
|
/// GREEN
|
|
/// )
|
|
/// .edge_radius(0.25)
|
|
/// .arc_resolution(10);
|
|
/// }
|
|
/// # bevy_ecs::system::assert_is_system(system);
|
|
/// ```
|
|
pub fn rounded_cuboid(
|
|
&mut self,
|
|
isometry: impl Into<Isometry3d>,
|
|
size: Vec3,
|
|
color: impl Into<Color>,
|
|
) -> RoundedCuboidBuilder<'_, 'w, 's, T> {
|
|
let corner_radius = size.min_element() * DEFAULT_CORNER_RADIUS;
|
|
RoundedCuboidBuilder {
|
|
gizmos: self,
|
|
config: RoundedBoxConfig {
|
|
isometry: isometry.into(),
|
|
color: color.into(),
|
|
corner_radius,
|
|
arc_resolution: DEFAULT_ARC_RESOLUTION,
|
|
},
|
|
size,
|
|
}
|
|
}
|
|
}
|
|
|
|
const DEFAULT_ARC_RESOLUTION: u32 = 8;
|
|
const DEFAULT_CORNER_RADIUS: f32 = 0.1;
|