SliderPrecision

crates/bevy_core_widgets/src/core_slider.rs

@@ -19,6 +19,7 @@ use bevy_input::keyboard::{KeyCode, KeyboardInput};
 use bevy_input::ButtonState;
 use bevy_input_focus::FocusedInput;
 use bevy_log::warn_once;
+use bevy_math::ops;
 use bevy_picking::events::{Drag, DragEnd, DragStart, Pointer, Press};
 use bevy_ui::{ComputedNode, ComputedNodeTarget, InteractionDisabled, UiGlobalTransform, UiScale};
 
@@ -187,6 +188,24 @@ impl Default for SliderStep {
     }
 }
 
+/// A component which controls the rounding of the slider value during dragging. Stepping is not
+/// affected, although presumably the step size will be an integer multiple of the rounding factor.
+/// This also doesn't prevent the slider value from being set to non-rounded values by other means,
+/// such as manually entering digits via a numberic input field.
+///
+/// The value in this component represents the number of decimal places of desired precision,
+/// so a value of 2 would round to the nearest 1/100th. A value of -3 would round to the nearest
+/// thousand.
+#[derive(Component, Debug, Default, Clone, Copy)]
+pub struct SliderPrecision(pub i32);
+
+impl SliderPrecision {
+    fn round(&self, value: f32) -> f32 {
+        let factor = ops::powf(10.0_f32, self.0 as f32);
+        (value * factor).round() / factor
+    }
+}
+
 /// Component used to manage the state of a slider during dragging.
 #[derive(Component, Default)]
 pub struct CoreSliderDragState {
@@ -204,6 +223,7 @@ pub(crate) fn slider_on_pointer_down(
         &SliderValue,
         &SliderRange,
         &SliderStep,
+        Option<&SliderPrecision>,
         &ComputedNode,
         &ComputedNodeTarget,
         &UiGlobalTransform,
@@ -217,8 +237,17 @@ pub(crate) fn slider_on_pointer_down(
     if q_thumb.contains(trigger.target()) {
         // Thumb click, stop propagation to prevent track click.
         trigger.propagate(false);
-    } else if let Ok((slider, value, range, step, node, node_target, transform, disabled)) =
+    } else if let Ok((
-        q_slider.get(trigger.target())
+        slider,
+        value,
+        range,
+        step,
+        precision,
+        node,
+        node_target,
+        transform,
+        disabled,
+    )) = q_slider.get(trigger.target())
     {
         // Track click
         trigger.propagate(false);
@@ -257,7 +286,9 @@ pub(crate) fn slider_on_pointer_down(
                     value.0 + step.0
                 }
             }
-            TrackClick::Snap => click_val,
+            TrackClick::Snap => precision
+                .map(|prec| prec.round(click_val))
+                .unwrap_or(click_val),
         });
 
         if matches!(slider.on_change, Callback::Ignore) {
@@ -296,6 +327,7 @@ pub(crate) fn slider_on_drag(
         &ComputedNode,
         &CoreSlider,
         &SliderRange,
+        Option<&SliderPrecision>,
         &UiGlobalTransform,
         &mut CoreSliderDragState,
         Has<InteractionDisabled>,
@@ -305,7 +337,8 @@ pub(crate) fn slider_on_drag(
     mut commands: Commands,
     ui_scale: Res<UiScale>,
 ) {
-    if let Ok((node, slider, range, transform, drag, disabled)) = q_slider.get_mut(trigger.target())
+    if let Ok((node, slider, range, precision, transform, drag, disabled)) =
+        q_slider.get_mut(trigger.target())
     {
         trigger.propagate(false);
         if drag.dragging && !disabled {
@@ -324,13 +357,16 @@ pub(crate) fn slider_on_drag(
             } else {
                 range.start() + span * 0.5
             };
+            let rounded_value = precision
+                .map(|prec| prec.round(new_value))
+                .unwrap_or(new_value);
 
             if matches!(slider.on_change, Callback::Ignore) {
                 commands
                     .entity(trigger.target())
-                    .insert(SliderValue(new_value));
+                    .insert(SliderValue(rounded_value));
             } else {
-                commands.notify_with(&slider.on_change, new_value);
+                commands.notify_with(&slider.on_change, rounded_value);
             }
         }
     }
@@ -491,3 +527,24 @@ impl Plugin for CoreSliderPlugin {
             .add_observer(slider_on_set_value);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_slider_precision_rounding() {
+        // Test positive precision values (decimal places)
+        let precision_2dp = SliderPrecision(2);
+        assert_eq!(precision_2dp.round(1.234567), 1.23);
+        assert_eq!(precision_2dp.round(1.235), 1.24);
+
+        // Test zero precision (rounds to integers)
+        let precision_0dp = SliderPrecision(0);
+        assert_eq!(precision_0dp.round(1.4), 1.0);
+
+        // Test negative precision (rounds to tens, hundreds, etc.)
+        let precision_neg1 = SliderPrecision(-1);
+        assert_eq!(precision_neg1.round(14.0), 10.0);
+    }
+}

crates/bevy_core_widgets/src/lib.rs

@@ -33,7 +33,7 @@ pub use core_scrollbar::{
 };
 pub use core_slider::{
     CoreSlider, CoreSliderDragState, CoreSliderPlugin, CoreSliderThumb, SetSliderValue,
-    SliderRange, SliderStep, SliderValue, TrackClick,
+    SliderPrecision, SliderRange, SliderStep, SliderValue, TrackClick,
 };
 
 /// A plugin group that registers the observers for all of the core widgets. If you don't want to

examples/ui/feathers.rs

@@ -1,7 +1,9 @@
 //! This example shows off the various Bevy Feathers widgets.
 
 use bevy::{
-    core_widgets::{Callback, CoreRadio, CoreRadioGroup, CoreWidgetsPlugins, SliderStep},
+    core_widgets::{
+        Callback, CoreRadio, CoreRadioGroup, CoreWidgetsPlugins, SliderPrecision, SliderStep,
+    },
     feathers::{
         controls::{
             button, checkbox, radio, slider, toggle_switch, ButtonProps, ButtonVariant,
@@ -259,7 +261,7 @@ fn demo_root(commands: &mut Commands) -> impl Bundle {
                         value: 20.0,
                         ..default()
                     },
-                    SliderStep(10.)
+                    (SliderStep(10.), SliderPrecision(2)),
                 ),
             ]
         ),],