Remove Val::Undefined

crates/bevy_ui/src/flex/convert.rs

@@ -42,7 +42,10 @@ pub fn from_style(scale_factor: f64, value: &Style) -> taffy::style::Style {
         align_self: value.align_self.into(),
         align_content: value.align_content.into(),
         justify_content: value.justify_content.into(),
-        position: from_rect(scale_factor, value.position),
+        position: from_rect(
+            scale_factor,
+            UiRect::new(value.left, value.right, value.top, value.bottom),
+        ),
         margin: from_rect(scale_factor, value.margin),
         padding: from_rect(scale_factor, value.padding),
         border: from_rect(scale_factor, value.border),
@@ -60,7 +63,7 @@ pub fn from_style(scale_factor: f64, value: &Style) -> taffy::style::Style {
 /// Converts a [`Val`] to a [`f32`] while respecting the scale factor.
 pub fn val_to_f32(scale_factor: f64, val: Val) -> f32 {
     match val {
-        Val::Undefined | Val::Auto => 0.0,
+        Val::Auto => 0.0,
         Val::Px(value) => (scale_factor * value as f64) as f32,
         Val::Percent(value) => value / 100.0,
     }
@@ -71,7 +74,6 @@ pub fn from_val(scale_factor: f64, val: Val) -> taffy::style::Dimension {
         Val::Auto => taffy::style::Dimension::Auto,
         Val::Percent(value) => taffy::style::Dimension::Percent(value / 100.0),
         Val::Px(value) => taffy::style::Dimension::Points((scale_factor * value as f64) as f32),
-        Val::Undefined => taffy::style::Dimension::Undefined,
     }
 }
 

crates/bevy_ui/src/geometry.rs

@@ -22,7 +22,7 @@ use std::ops::{Div, DivAssign, Mul, MulAssign};
 /// ```
 ///
 /// If you define opposite sides of the position, the size of the UI element will automatically be calculated
-/// if not explicitly specified. This means that if you have a [`Size`] that uses [`Val::Undefined`](crate::Val::Undefined)
+/// if not explicitly specified. This means that if you have a [`Size`] that uses [`Val::Auto`](crate::Val::Auto)
 /// as a width and height, the size would be determined by the window size and the values specified in the position.
 ///
 /// ```
@@ -65,16 +65,14 @@ use std::ops::{Div, DivAssign, Mul, MulAssign};
 /// right values of the position because the size of the UI element is already explicitly specified.
 ///
 /// ```
-/// # use bevy_ui::{UiRect, Size, Val, Style};
+/// # use bevy_ui::{Size, Val, Style};
 /// # use bevy_utils::default;
 /// #
 /// let style = Style {
-///     position: UiRect { // Defining all four sides
-///         left: Val::Px(100.0),
-///         right: Val::Px(200.0),
-///         top: Val::Px(300.0),
-///         bottom: Val::Px(400.0),
-///     },
+///     left: Val::Px(100.0),
+///     right: Val::Px(200.0),
+///     top: Val::Px(300.0),
+///     bottom: Val::Px(400.0),
 ///     size: Size::new(Val::Percent(100.0), Val::Percent(50.0)), // but also explicitly specifying a size
 ///     ..default()
 /// };
@@ -134,10 +132,10 @@ pub struct UiRect {
 
 impl UiRect {
     pub const DEFAULT: Self = Self {
-        left: Val::DEFAULT,
-        right: Val::DEFAULT,
-        top: Val::DEFAULT,
-        bottom: Val::DEFAULT,
+        left: Val::Px(0.),
+        right: Val::Px(0.),
+        top: Val::Px(0.),
+        bottom: Val::Px(0.),
     };
 
     /// Creates a new [`UiRect`] from the values specified.
@@ -202,8 +200,8 @@ impl UiRect {
     ///
     /// assert_eq!(ui_rect.left, Val::Px(10.0));
     /// assert_eq!(ui_rect.right, Val::Px(10.0));
-    /// assert_eq!(ui_rect.top, Val::Undefined);
-    /// assert_eq!(ui_rect.bottom, Val::Undefined);
+    /// assert_eq!(ui_rect.top, Val::Px(0.));
+    /// assert_eq!(ui_rect.bottom, Val::Px(0.));
     /// ```
     pub fn horizontal(value: Val) -> Self {
         UiRect {
@@ -222,8 +220,8 @@ impl UiRect {
     /// #
     /// let ui_rect = UiRect::vertical(Val::Px(10.0));
     ///
-    /// assert_eq!(ui_rect.left, Val::Undefined);
-    /// assert_eq!(ui_rect.right, Val::Undefined);
+    /// 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));
     /// ```
@@ -245,9 +243,9 @@ impl UiRect {
     /// let ui_rect = UiRect::left(Val::Px(10.0));
     ///
     /// assert_eq!(ui_rect.left, Val::Px(10.0));
-    /// assert_eq!(ui_rect.right, Val::Undefined);
-    /// assert_eq!(ui_rect.top, Val::Undefined);
-    /// assert_eq!(ui_rect.bottom, Val::Undefined);
+    /// 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 {
@@ -265,10 +263,10 @@ impl UiRect {
     /// #
     /// let ui_rect = UiRect::right(Val::Px(10.0));
     ///
-    /// assert_eq!(ui_rect.left, Val::Undefined);
+    /// assert_eq!(ui_rect.left, Val::Px(0.));
     /// assert_eq!(ui_rect.right, Val::Px(10.0));
-    /// assert_eq!(ui_rect.top, Val::Undefined);
-    /// assert_eq!(ui_rect.bottom, Val::Undefined);
+    /// assert_eq!(ui_rect.top, Val::Px(0.));
+    /// assert_eq!(ui_rect.bottom, Val::Px(0.));
     /// ```
     pub fn right(value: Val) -> Self {
         UiRect {
@@ -286,10 +284,10 @@ impl UiRect {
     /// #
     /// let ui_rect = UiRect::top(Val::Px(10.0));
     ///
-    /// assert_eq!(ui_rect.left, Val::Undefined);
-    /// assert_eq!(ui_rect.right, Val::Undefined);
+    /// 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::Undefined);
+    /// assert_eq!(ui_rect.bottom, Val::Px(0.));
     /// ```
     pub fn top(value: Val) -> Self {
         UiRect {
@@ -307,9 +305,9 @@ impl UiRect {
     /// #
     /// let ui_rect = UiRect::bottom(Val::Px(10.0));
     ///
-    /// assert_eq!(ui_rect.left, Val::Undefined);
-    /// assert_eq!(ui_rect.right, Val::Undefined);
-    /// assert_eq!(ui_rect.top, Val::Undefined);
+    /// 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 {
@@ -383,9 +381,6 @@ impl Size {
 
     /// Creates a Size where both values are [`Val::Auto`].
     pub const AUTO: Self = Self::all(Val::Auto);
-
-    /// Creates a Size where both values are [`Val::Undefined`].
-    pub const UNDEFINED: Self = Self::all(Val::Undefined);
 }
 
 impl Default for Size {
@@ -443,6 +438,11 @@ impl DivAssign<f32> for Size {
 mod tests {
     use super::*;
 
+    #[test]
+    fn uirect_default_equals_const_default() {
+        assert_eq!(UiRect::default(), UiRect::DEFAULT);
+    }
+
     #[test]
     fn test_size_from() {
         let size: Size = (Val::Px(20.), Val::Px(30.)).into();
@@ -476,4 +476,48 @@ mod tests {
         size /= 2.;
         assert_eq!(size, Size::new(Val::Px(10.), Val::Px(10.)));
     }
+
+    #[test]
+    fn test_size_all() {
+        let length = Val::Px(10.);
+
+        assert_eq!(
+            Size::all(length),
+            Size {
+                width: length,
+                height: length
+            }
+        );
+    }
+
+    #[test]
+    fn test_size_width() {
+        let width = Val::Px(10.);
+
+        assert_eq!(
+            Size::width(width),
+            Size {
+                width,
+                ..Default::default()
+            }
+        );
+    }
+
+    #[test]
+    fn test_size_height() {
+        let height = Val::Px(7.);
+
+        assert_eq!(
+            Size::height(height),
+            Size {
+                height,
+                ..Default::default()
+            }
+        );
+    }
+
+    #[test]
+    fn size_default_equals_const_default() {
+        assert_eq!(Size::default(), Size::DEFAULT);
+    }
 }