Move Val into geometry

crates/bevy_ui/src/geometry.rs

@@ -1,5 +1,184 @@
-use crate::Val;
+use bevy_math::Vec2;
 use bevy_reflect::Reflect;
+use bevy_reflect::ReflectDeserialize;
+use bevy_reflect::ReflectSerialize;
+use serde::Deserialize;
+use serde::Serialize;
+use std::ops::{Div, DivAssign, Mul, MulAssign};
+use thiserror::Error;
+
+/// Represents the possible value types for layout properties.
+///
+/// This enum allows specifying values for various [`Style`](crate::Style) properties in different units,
+/// such as logical pixels, percentages, or automatically determined values.
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Reflect)]
+#[reflect(PartialEq, Serialize, Deserialize)]
+pub enum Val {
+    /// Automatically determine the value based on the context and other [`Style`](crate::Style) properties.
+    Auto,
+    /// Set this value in logical pixels.
+    Px(f32),
+    /// Set the value as a percentage of its parent node's length along a specific axis.
+    ///
+    /// If the UI node has no parent, the percentage is calculated based on the window's length
+    /// along the corresponding axis.
+    ///
+    /// The chosen axis depends on the [`Style`](crate::Style) field set:
+    /// * For `flex_basis`, the percentage is relative to the main-axis length determined by the `flex_direction`.
+    /// * For `gap`, `min_size`, `size`, and `max_size`:
+    ///   - `width` is relative to the parent's width.
+    ///   - `height` is relative to the parent's height.
+    /// * For `margin`, `padding`, and `border` values: the percentage is relative to the parent node's width.
+    /// * For positions, `left` and `right` are relative to the parent's width, while `bottom` and `top` are relative to the parent's height.
+    Percent(f32),
+    /// Set this value in percent of the viewport width
+    Vw(f32),
+    /// Set this value in percent of the viewport height
+    Vh(f32),
+    /// Set this value in percent of the viewport's smaller dimension.
+    VMin(f32),
+    /// Set this value in percent of the viewport's larger dimension.
+    VMax(f32),
+}
+
+impl PartialEq for Val {
+    fn eq(&self, other: &Self) -> bool {
+        let same_unit = matches!(
+            (self, other),
+            (Self::Auto, Self::Auto)
+                | (Self::Px(_), Self::Px(_))
+                | (Self::Percent(_), Self::Percent(_))
+                | (Self::Vw(_), Self::Vw(_))
+                | (Self::Vh(_), Self::Vh(_))
+                | (Self::VMin(_), Self::VMin(_))
+                | (Self::VMax(_), Self::VMax(_))
+        );
+
+        let left = match self {
+            Self::Auto => None,
+            Self::Px(v)
+            | Self::Percent(v)
+            | Self::Vw(v)
+            | Self::Vh(v)
+            | Self::VMin(v)
+            | Self::VMax(v) => Some(v),
+        };
+
+        let right = match other {
+            Self::Auto => None,
+            Self::Px(v)
+            | Self::Percent(v)
+            | Self::Vw(v)
+            | Self::Vh(v)
+            | Self::VMin(v)
+            | Self::VMax(v) => Some(v),
+        };
+
+        match (same_unit, left, right) {
+            (true, a, b) => a == b,
+            // All zero-value variants are considered equal.
+            (false, Some(&a), Some(&b)) => a == 0. && b == 0.,
+            _ => false,
+        }
+    }
+}
+
+impl Val {
+    pub const DEFAULT: Self = Self::Auto;
+    pub const ZERO: Self = Self::Px(0.0);
+}
+
+impl Default for Val {
+    fn default() -> Self {
+        Self::DEFAULT
+    }
+}
+
+impl Mul<f32> for Val {
+    type Output = Val;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        match self {
+            Val::Auto => Val::Auto,
+            Val::Px(value) => Val::Px(value * rhs),
+            Val::Percent(value) => Val::Percent(value * rhs),
+            Val::Vw(value) => Val::Vw(value * rhs),
+            Val::Vh(value) => Val::Vh(value * rhs),
+            Val::VMin(value) => Val::VMin(value * rhs),
+            Val::VMax(value) => Val::VMax(value * rhs),
+        }
+    }
+}
+
+impl MulAssign<f32> for Val {
+    fn mul_assign(&mut self, rhs: f32) {
+        match self {
+            Val::Auto => {}
+            Val::Px(value)
+            | Val::Percent(value)
+            | Val::Vw(value)
+            | Val::Vh(value)
+            | Val::VMin(value)
+            | Val::VMax(value) => *value *= rhs,
+        }
+    }
+}
+
+impl Div<f32> for Val {
+    type Output = Val;
+
+    fn div(self, rhs: f32) -> Self::Output {
+        match self {
+            Val::Auto => Val::Auto,
+            Val::Px(value) => Val::Px(value / rhs),
+            Val::Percent(value) => Val::Percent(value / rhs),
+            Val::Vw(value) => Val::Vw(value / rhs),
+            Val::Vh(value) => Val::Vh(value / rhs),
+            Val::VMin(value) => Val::VMin(value / rhs),
+            Val::VMax(value) => Val::VMax(value / rhs),
+        }
+    }
+}
+
+impl DivAssign<f32> for Val {
+    fn div_assign(&mut self, rhs: f32) {
+        match self {
+            Val::Auto => {}
+            Val::Px(value)
+            | Val::Percent(value)
+            | Val::Vw(value)
+            | Val::Vh(value)
+            | Val::VMin(value)
+            | Val::VMax(value) => *value /= rhs,
+        }
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Copy, Error)]
+pub enum ValArithmeticError {
+    #[error("the variants of the Vals don't match")]
+    NonIdenticalVariants,
+    #[error("the given variant of Val is not evaluateable (non-numeric)")]
+    NonEvaluateable,
+}
+
+impl Val {
+    /// Resolves a [`Val`] to its value in logical pixels and returns this as an [`f32`].
+    /// Returns a [`ValArithmeticError::NonEvaluateable`] if the [`Val`] is impossible to resolve into a concrete value.
+    ///
+    /// **Note:** If a [`Val::Px`] is resolved, it's inner value is returned unchanged.
+    pub fn resolve(self, parent_size: f32, viewport_size: Vec2) -> Result<f32, ValArithmeticError> {
+        match self {
+            Val::Percent(value) => Ok(parent_size * value / 100.0),
+            Val::Px(value) => Ok(value),
+            Val::Vw(value) => Ok(viewport_size.x * value / 100.0),
+            Val::Vh(value) => Ok(viewport_size.y * value / 100.0),
+            Val::VMin(value) => Ok(viewport_size.min_element() * value / 100.0),
+            Val::VMax(value) => Ok(viewport_size.max_element() * value / 100.0),
+            Val::Auto => Err(ValArithmeticError::NonEvaluateable),
+        }
+    }
+}
 
 /// A type which is commonly used to define margins, paddings and borders.
 ///
@@ -338,7 +517,82 @@ impl Default for UiRect {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use crate::geometry::*;
+    use bevy_math::vec2;
+
+    #[test]
+    fn val_evaluate() {
+        let size = 250.;
+        let viewport_size = vec2(1000., 500.);
+        let result = Val::Percent(80.).resolve(size, viewport_size).unwrap();
+
+        assert_eq!(result, size * 0.8);
+    }
+
+    #[test]
+    fn val_resolve_px() {
+        let size = 250.;
+        let viewport_size = vec2(1000., 500.);
+        let result = Val::Px(10.).resolve(size, viewport_size).unwrap();
+
+        assert_eq!(result, 10.);
+    }
+
+    #[test]
+    fn val_resolve_viewport_coords() {
+        let size = 250.;
+        let viewport_size = vec2(500., 500.);
+
+        for value in (-10..10).map(|value| value as f32) {
+            // for a square viewport there should be no difference between `Vw` and `Vh` and between `Vmin` and `Vmax`.
+            assert_eq!(
+                Val::Vw(value).resolve(size, viewport_size),
+                Val::Vh(value).resolve(size, viewport_size)
+            );
+            assert_eq!(
+                Val::VMin(value).resolve(size, viewport_size),
+                Val::VMax(value).resolve(size, viewport_size)
+            );
+            assert_eq!(
+                Val::VMin(value).resolve(size, viewport_size),
+                Val::Vw(value).resolve(size, viewport_size)
+            );
+        }
+
+        let viewport_size = vec2(1000., 500.);
+        assert_eq!(Val::Vw(100.).resolve(size, viewport_size).unwrap(), 1000.);
+        assert_eq!(Val::Vh(100.).resolve(size, viewport_size).unwrap(), 500.);
+        assert_eq!(Val::Vw(60.).resolve(size, viewport_size).unwrap(), 600.);
+        assert_eq!(Val::Vh(40.).resolve(size, viewport_size).unwrap(), 200.);
+        assert_eq!(Val::VMin(50.).resolve(size, viewport_size).unwrap(), 250.);
+        assert_eq!(Val::VMax(75.).resolve(size, viewport_size).unwrap(), 750.);
+    }
+
+    #[test]
+    fn val_auto_is_non_resolveable() {
+        let size = 250.;
+        let viewport_size = vec2(1000., 500.);
+        let resolve_auto = Val::Auto.resolve(size, viewport_size);
+
+        assert_eq!(resolve_auto, Err(ValArithmeticError::NonEvaluateable));
+    }
+
+    #[test]
+    fn val_arithmetic_error_messages() {
+        assert_eq!(
+            format!("{}", ValArithmeticError::NonIdenticalVariants),
+            "the variants of the Vals don't match"
+        );
+        assert_eq!(
+            format!("{}", ValArithmeticError::NonEvaluateable),
+            "the given variant of Val is not evaluateable (non-numeric)"
+        );
+    }
+
+    #[test]
+    fn default_val_equals_const_default_val() {
+        assert_eq!(Val::default(), Val::DEFAULT);
+    }
 
     #[test]
     fn uirect_default_equals_const_default() {