aeeb20ec4c
# Objective **This implementation is based on https://github.com/bevyengine/rfcs/pull/59.** --- Resolves #4597 Full details and motivation can be found in the RFC, but here's a brief summary. `FromReflect` is a very powerful and important trait within the reflection API. It allows Dynamic types (e.g., `DynamicList`, etc.) to be formed into Real ones (e.g., `Vec<i32>`, etc.). This mainly comes into play concerning deserialization, where the reflection deserializers both return a `Box<dyn Reflect>` that almost always contain one of these Dynamic representations of a Real type. To convert this to our Real type, we need to use `FromReflect`. It also sneaks up in other ways. For example, it's a required bound for `T` in `Vec<T>` so that `Vec<T>` as a whole can be made `FromReflect`. It's also required by all fields of an enum as it's used as part of the `Reflect::apply` implementation. So in other words, much like `GetTypeRegistration` and `Typed`, it is very much a core reflection trait. The problem is that it is not currently treated like a core trait and is not automatically derived alongside `Reflect`. This makes using it a bit cumbersome and easy to forget. ## Solution Automatically derive `FromReflect` when deriving `Reflect`. Users can then choose to opt-out if needed using the `#[reflect(from_reflect = false)]` attribute. ```rust #[derive(Reflect)] struct Foo; #[derive(Reflect)] #[reflect(from_reflect = false)] struct Bar; fn test<T: FromReflect>(value: T) {} test(Foo); // <-- OK test(Bar); // <-- Panic! Bar does not implement trait `FromReflect` ``` #### `ReflectFromReflect` This PR also automatically adds the `ReflectFromReflect` (introduced in #6245) registration to the derived `GetTypeRegistration` impl— if the type hasn't opted out of `FromReflect` of course. <details> <summary><h4>Improved Deserialization</h4></summary> > **Warning** > This section includes changes that have since been descoped from this PR. They will likely be implemented again in a followup PR. I am mainly leaving these details in for archival purposes, as well as for reference when implementing this logic again. And since we can do all the above, we might as well improve deserialization. We can now choose to deserialize into a Dynamic type or automatically convert it using `FromReflect` under the hood. `[Un]TypedReflectDeserializer::new` will now perform the conversion and return the `Box`'d Real type. `[Un]TypedReflectDeserializer::new_dynamic` will work like what we have now and simply return the `Box`'d Dynamic type. ```rust // Returns the Real type let reflect_deserializer = UntypedReflectDeserializer::new(®istry); let mut deserializer = ron:🇩🇪:Deserializer::from_str(input)?; let output: SomeStruct = reflect_deserializer.deserialize(&mut deserializer)?.take()?; // Returns the Dynamic type let reflect_deserializer = UntypedReflectDeserializer::new_dynamic(®istry); let mut deserializer = ron:🇩🇪:Deserializer::from_str(input)?; let output: DynamicStruct = reflect_deserializer.deserialize(&mut deserializer)?.take()?; ``` </details> --- ## Changelog * `FromReflect` is now automatically derived within the `Reflect` derive macro * This includes auto-registering `ReflectFromReflect` in the derived `GetTypeRegistration` impl * ~~Renamed `TypedReflectDeserializer::new` and `UntypedReflectDeserializer::new` to `TypedReflectDeserializer::new_dynamic` and `UntypedReflectDeserializer::new_dynamic`, respectively~~ **Descoped** * ~~Changed `TypedReflectDeserializer::new` and `UntypedReflectDeserializer::new` to automatically convert the deserialized output using `FromReflect`~~ **Descoped** ## Migration Guide * `FromReflect` is now automatically derived within the `Reflect` derive macro. Items with both derives will need to remove the `FromReflect` one. ```rust // OLD #[derive(Reflect, FromReflect)] struct Foo; // NEW #[derive(Reflect)] struct Foo; ``` If using a manual implementation of `FromReflect` and the `Reflect` derive, users will need to opt-out of the automatic implementation. ```rust // OLD #[derive(Reflect)] struct Foo; impl FromReflect for Foo {/* ... */} // NEW #[derive(Reflect)] #[reflect(from_reflect = false)] struct Foo; impl FromReflect for Foo {/* ... */} ``` <details> <summary><h4>Removed Migrations</h4></summary> > **Warning** > This section includes changes that have since been descoped from this PR. They will likely be implemented again in a followup PR. I am mainly leaving these details in for archival purposes, as well as for reference when implementing this logic again. * The reflect deserializers now perform a `FromReflect` conversion internally. The expected output of `TypedReflectDeserializer::new` and `UntypedReflectDeserializer::new` is no longer a Dynamic (e.g., `DynamicList`), but its Real counterpart (e.g., `Vec<i32>`). ```rust let reflect_deserializer = UntypedReflectDeserializer::new_dynamic(®istry); let mut deserializer = ron:🇩🇪:Deserializer::from_str(input)?; // OLD let output: DynamicStruct = reflect_deserializer.deserialize(&mut deserializer)?.take()?; // NEW let output: SomeStruct = reflect_deserializer.deserialize(&mut deserializer)?.take()?; ``` Alternatively, if this behavior isn't desired, use the `TypedReflectDeserializer::new_dynamic` and `UntypedReflectDeserializer::new_dynamic` methods instead: ```rust // OLD let reflect_deserializer = UntypedReflectDeserializer::new(®istry); // NEW let reflect_deserializer = UntypedReflectDeserializer::new_dynamic(®istry); ``` </details> --------- Co-authored-by: Carter Anderson <mcanders1@gmail.com>
382 lines
10 KiB
Rust
382 lines
10 KiB
Rust
use crate::Val;
|
|
use bevy_reflect::Reflect;
|
|
|
|
/// A type which is commonly used to define margins, paddings and borders.
|
|
///
|
|
/// # Examples
|
|
|
|
///
|
|
/// ## Margin
|
|
///
|
|
/// A margin is used to create space around UI elements, outside of any defined borders.
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let margin = UiRect::all(Val::Auto); // Centers the UI element
|
|
/// ```
|
|
///
|
|
/// ## Padding
|
|
///
|
|
/// A padding is used to create space around UI elements, inside of any defined borders.
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let padding = UiRect {
|
|
/// left: Val::Px(10.0),
|
|
/// right: Val::Px(20.0),
|
|
/// top: Val::Px(30.0),
|
|
/// bottom: Val::Px(40.0),
|
|
/// };
|
|
/// ```
|
|
///
|
|
/// ## Borders
|
|
///
|
|
/// A border is used to define the width of the border of a UI element.
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let border = UiRect {
|
|
/// left: Val::Px(10.0),
|
|
/// right: Val::Px(20.0),
|
|
/// top: Val::Px(30.0),
|
|
/// bottom: Val::Px(40.0),
|
|
/// };
|
|
/// ```
|
|
#[derive(Copy, Clone, PartialEq, Debug, Reflect)]
|
|
#[reflect(PartialEq)]
|
|
pub struct UiRect {
|
|
/// The value corresponding to the left side of the UI rect.
|
|
pub left: Val,
|
|
/// The value corresponding to the right side of the UI rect.
|
|
pub right: Val,
|
|
/// The value corresponding to the top side of the UI rect.
|
|
pub top: Val,
|
|
/// The value corresponding to the bottom side of the UI rect.
|
|
pub bottom: Val,
|
|
}
|
|
|
|
impl UiRect {
|
|
pub const DEFAULT: Self = Self {
|
|
left: Val::Px(0.),
|
|
right: Val::Px(0.),
|
|
top: Val::Px(0.),
|
|
bottom: Val::Px(0.),
|
|
};
|
|
|
|
/// Creates a new [`UiRect`] from the values specified.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::new(
|
|
/// Val::Px(10.0),
|
|
/// Val::Px(20.0),
|
|
/// Val::Px(30.0),
|
|
/// Val::Px(40.0),
|
|
/// );
|
|
///
|
|
/// assert_eq!(ui_rect.left, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.right, Val::Px(20.0));
|
|
/// assert_eq!(ui_rect.top, Val::Px(30.0));
|
|
/// assert_eq!(ui_rect.bottom, Val::Px(40.0));
|
|
/// ```
|
|
pub const fn new(left: Val, right: Val, top: Val, bottom: Val) -> Self {
|
|
UiRect {
|
|
left,
|
|
right,
|
|
top,
|
|
bottom,
|
|
}
|
|
}
|
|
|
|
/// Creates a new [`UiRect`] where all sides have the same value.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::all(Val::Px(10.0));
|
|
///
|
|
/// assert_eq!(ui_rect.left, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.right, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.top, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.bottom, Val::Px(10.0));
|
|
/// ```
|
|
pub const fn all(value: Val) -> Self {
|
|
UiRect {
|
|
left: value,
|
|
right: value,
|
|
top: value,
|
|
bottom: value,
|
|
}
|
|
}
|
|
|
|
/// Creates a new [`UiRect`] from the values specified in logical pixels.
|
|
///
|
|
/// This is a shortcut for [`UiRect::new()`], applying [`Val::Px`] to all arguments.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::px(10., 20., 30., 40.);
|
|
/// assert_eq!(ui_rect.left, Val::Px(10.));
|
|
/// assert_eq!(ui_rect.right, Val::Px(20.));
|
|
/// assert_eq!(ui_rect.top, Val::Px(30.));
|
|
/// assert_eq!(ui_rect.bottom, Val::Px(40.));
|
|
/// ```
|
|
pub const fn px(left: f32, right: f32, top: f32, bottom: f32) -> Self {
|
|
UiRect {
|
|
left: Val::Px(left),
|
|
right: Val::Px(right),
|
|
top: Val::Px(top),
|
|
bottom: Val::Px(bottom),
|
|
}
|
|
}
|
|
|
|
/// Creates a new [`UiRect`] from the values specified in percentages.
|
|
///
|
|
/// This is a shortcut for [`UiRect::new()`], applying [`Val::Percent`] to all arguments.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::percent(5., 10., 2., 1.);
|
|
/// assert_eq!(ui_rect.left, Val::Percent(5.));
|
|
/// assert_eq!(ui_rect.right, Val::Percent(10.));
|
|
/// assert_eq!(ui_rect.top, Val::Percent(2.));
|
|
/// assert_eq!(ui_rect.bottom, Val::Percent(1.));
|
|
/// ```
|
|
pub const fn percent(left: f32, right: f32, top: f32, bottom: f32) -> Self {
|
|
UiRect {
|
|
left: Val::Percent(left),
|
|
right: Val::Percent(right),
|
|
top: Val::Percent(top),
|
|
bottom: Val::Percent(bottom),
|
|
}
|
|
}
|
|
|
|
/// Creates a new [`UiRect`] where `left` and `right` take the given value,
|
|
/// and `top` and `bottom` set to zero `Val::Px(0.)`.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::horizontal(Val::Px(10.0));
|
|
///
|
|
/// assert_eq!(ui_rect.left, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.right, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.top, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.bottom, Val::Px(0.));
|
|
/// ```
|
|
pub fn horizontal(value: Val) -> Self {
|
|
UiRect {
|
|
left: value,
|
|
right: value,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
/// Creates a new [`UiRect`] where `top` and `bottom` take the given value,
|
|
/// and `left` and `right` are set to `Val::Px(0.)`.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::vertical(Val::Px(10.0));
|
|
///
|
|
/// assert_eq!(ui_rect.left, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.right, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.top, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.bottom, Val::Px(10.0));
|
|
/// ```
|
|
pub fn vertical(value: Val) -> Self {
|
|
UiRect {
|
|
top: value,
|
|
bottom: value,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
/// Creates a new [`UiRect`] where both `left` and `right` take the value of `horizontal`, and both `top` and `bottom` take the value of `vertical`.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::axes(Val::Px(10.0), Val::Percent(15.0));
|
|
///
|
|
/// assert_eq!(ui_rect.left, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.right, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.top, Val::Percent(15.0));
|
|
/// assert_eq!(ui_rect.bottom, Val::Percent(15.0));
|
|
/// ```
|
|
pub fn axes(horizontal: Val, vertical: Val) -> Self {
|
|
UiRect {
|
|
left: horizontal,
|
|
right: horizontal,
|
|
top: vertical,
|
|
bottom: vertical,
|
|
}
|
|
}
|
|
|
|
/// Creates a new [`UiRect`] where `left` takes the given value, and
|
|
/// the other fields are set to `Val::Px(0.)`.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::left(Val::Px(10.0));
|
|
///
|
|
/// assert_eq!(ui_rect.left, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.right, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.top, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.bottom, Val::Px(0.));
|
|
/// ```
|
|
pub fn left(value: Val) -> Self {
|
|
UiRect {
|
|
left: value,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
/// Creates a new [`UiRect`] where `right` takes the given value,
|
|
/// and the other fields are set to `Val::Px(0.)`.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::right(Val::Px(10.0));
|
|
///
|
|
/// assert_eq!(ui_rect.left, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.right, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.top, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.bottom, Val::Px(0.));
|
|
/// ```
|
|
pub fn right(value: Val) -> Self {
|
|
UiRect {
|
|
right: value,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
/// Creates a new [`UiRect`] where `top` takes the given value,
|
|
/// and the other fields are set to `Val::Px(0.)`.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::top(Val::Px(10.0));
|
|
///
|
|
/// assert_eq!(ui_rect.left, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.right, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.top, Val::Px(10.0));
|
|
/// assert_eq!(ui_rect.bottom, Val::Px(0.));
|
|
/// ```
|
|
pub fn top(value: Val) -> Self {
|
|
UiRect {
|
|
top: value,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
/// Creates a new [`UiRect`] where `bottom` takes the given value,
|
|
/// and the other fields are set to `Val::Px(0.)`.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```
|
|
/// # use bevy_ui::{UiRect, Val};
|
|
/// #
|
|
/// let ui_rect = UiRect::bottom(Val::Px(10.0));
|
|
///
|
|
/// assert_eq!(ui_rect.left, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.right, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.top, Val::Px(0.));
|
|
/// assert_eq!(ui_rect.bottom, Val::Px(10.0));
|
|
/// ```
|
|
pub fn bottom(value: Val) -> Self {
|
|
UiRect {
|
|
bottom: value,
|
|
..Default::default()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for UiRect {
|
|
fn default() -> Self {
|
|
Self::DEFAULT
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn uirect_default_equals_const_default() {
|
|
assert_eq!(
|
|
UiRect::default(),
|
|
UiRect {
|
|
left: Val::Px(0.),
|
|
right: Val::Px(0.),
|
|
top: Val::Px(0.),
|
|
bottom: Val::Px(0.)
|
|
}
|
|
);
|
|
assert_eq!(UiRect::default(), UiRect::DEFAULT);
|
|
}
|
|
|
|
#[test]
|
|
fn test_uirect_axes() {
|
|
let x = Val::Px(1.);
|
|
let y = Val::Vw(4.);
|
|
let r = UiRect::axes(x, y);
|
|
let h = UiRect::horizontal(x);
|
|
let v = UiRect::vertical(y);
|
|
|
|
assert_eq!(r.top, v.top);
|
|
assert_eq!(r.bottom, v.bottom);
|
|
assert_eq!(r.left, h.left);
|
|
assert_eq!(r.right, h.right);
|
|
}
|
|
|
|
#[test]
|
|
fn uirect_px() {
|
|
let r = UiRect::px(3., 5., 20., 999.);
|
|
assert_eq!(r.left, Val::Px(3.));
|
|
assert_eq!(r.right, Val::Px(5.));
|
|
assert_eq!(r.top, Val::Px(20.));
|
|
assert_eq!(r.bottom, Val::Px(999.));
|
|
}
|
|
|
|
#[test]
|
|
fn uirect_percent() {
|
|
let r = UiRect::percent(3., 5., 20., 99.);
|
|
assert_eq!(r.left, Val::Percent(3.));
|
|
assert_eq!(r.right, Val::Percent(5.));
|
|
assert_eq!(r.top, Val::Percent(20.));
|
|
assert_eq!(r.bottom, Val::Percent(99.));
|
|
}
|
|
}
|