djkato/egui
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[slider] use f64 internally for increased precision

Browse source
This commit is contained in:
Emil Ernerfeldt 2020-10-06 21:03:47 +02:00
parent a49cba54ac
commit d5d8eeb172
3 changed files with 59 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
egui/src/math/mod.rs
View file

@ -120,14 +120,6 @@ pub fn ease_in_ease_out(t: f32) -> f32 {
/// See <https://tauday.com/> /// See <https://tauday.com/>
pub const TAU: f32 = 2.0 * std::f32::consts::PI; pub const TAU: f32 = 2.0 * std::f32::consts::PI;
/// Round a value to the given number of decimal places.
pub fn round_to_precision_f32(value: f32, decimal_places: usize) -> f32 {
// This is a stupid way of doing this, but stupid works.
format!("{:.*}", decimal_places, value)
.parse()
.unwrap_or_else(|_| value)
}
/// Round a value to the given number of decimal places. /// Round a value to the given number of decimal places.
pub fn round_to_precision(value: f64, decimal_places: usize) -> f64 { pub fn round_to_precision(value: f64, decimal_places: usize) -> f64 {
// This is a stupid way of doing this, but stupid works. // This is a stupid way of doing this, but stupid works.

4
egui/src/math/smart_aim.rs
View file

@ -2,10 +2,6 @@
const NUM_DECIMALS: usize = 15; const NUM_DECIMALS: usize = 15;
pub fn best_in_range_f32(min: f32, max: f32) -> f32 {
best_in_range_f64(min as f64, max as f64) as f32
}
/// Find the "simplest" number in a closed range [min, max], i.e. the one with the fewest decimal digits. /// Find the "simplest" number in a closed range [min, max], i.e. the one with the fewest decimal digits.
/// ///
/// So in the range `[0.83, 1.354]` you will get `1.0`, and for `[0.37, 0.48]` you will get `0.4`. /// So in the range `[0.83, 1.354]` you will get `1.0`, and for `[0.37, 0.48]` you will get `0.4`.

111
egui/src/widgets/slider.rs
View file

@ -2,15 +2,29 @@ use std::ops::RangeInclusive;
use crate::{paint::*, widgets::Label, *}; use crate::{paint::*, widgets::Label, *};
// TODO: switch to f64 internally so we can handle integers larger than 2^24.
/// Combined into one function (rather than two) to make it easier /// Combined into one function (rather than two) to make it easier
/// for the borrow checker. /// for the borrow checker.
type SliderGetSet<'a> = Box<dyn 'a + FnMut(Option<f32>) -> f32>; type GetSetValue<'a> = Box<dyn 'a + FnMut(Option<f64>) -> f64>;
fn get(value_function: &mut GetSetValue<'_>) -> f64 {
(value_function)(None)
}
fn set(value_function: &mut GetSetValue<'_>, value: f64) {
(value_function)(Some(value));
}
fn to_f64_range<T: Copy>(r: RangeInclusive<T>) -> RangeInclusive<f64>
where
f64: From<T>,
{
f64::from(*r.start())..=f64::from(*r.end())
}
/// Control a number by a horizontal slider. /// Control a number by a horizontal slider.
pub struct Slider<'a> { pub struct Slider<'a> {
get_set_value: SliderGetSet<'a>, get_set_value: GetSetValue<'a>,
range: RangeInclusive<f32>, range: RangeInclusive<f64>,
// TODO: label: Option<Label> // TODO: label: Option<Label>
text: Option<String>, text: Option<String>,
precision: Option<usize>, precision: Option<usize>,
@ -20,8 +34,8 @@ pub struct Slider<'a> {
impl<'a> Slider<'a> { impl<'a> Slider<'a> {
fn from_get_set( fn from_get_set(
range: RangeInclusive<f32>, range: RangeInclusive<f64>,
get_set_value: impl 'a + FnMut(Option<f32>) -> f32, get_set_value: impl 'a + FnMut(Option<f64>) -> f64,
) -> Self { ) -> Self {
Self { Self {
get_set_value: Box::new(get_set_value), get_set_value: Box::new(get_set_value),
@ -35,7 +49,18 @@ impl<'a> Slider<'a> {
pub fn f32(value: &'a mut f32, range: RangeInclusive<f32>) -> Self { pub fn f32(value: &'a mut f32, range: RangeInclusive<f32>) -> Self {
Self { Self {
..Self::from_get_set(range, move |v: Option<f32>| { ..Self::from_get_set(to_f64_range(range), move |v: Option<f64>| {
if let Some(v) = v {
*value = v as f32
}
*value as f64
})
}
}
pub fn f64(value: &'a mut f64, range: RangeInclusive<f64>) -> Self {
Self {
..Self::from_get_set(to_f64_range(range), move |v: Option<f64>| {
if let Some(v) = v { if let Some(v) = v {
*value = v *value = v
} }
@ -45,40 +70,38 @@ impl<'a> Slider<'a> {
} }
pub fn u8(value: &'a mut u8, range: RangeInclusive<u8>) -> Self { pub fn u8(value: &'a mut u8, range: RangeInclusive<u8>) -> Self {
let range = (*range.start() as f32)..=(*range.end() as f32);
Self { Self {
precision: Some(0), precision: Some(0),
..Self::from_get_set(range, move |v: Option<f32>| { ..Self::from_get_set(to_f64_range(range), move |v: Option<f64>| {
if let Some(v) = v { if let Some(v) = v {
*value = v.round() as u8 *value = v.round() as u8
} }
*value as f32 *value as f64
}) })
} }
} }
pub fn i32(value: &'a mut i32, range: RangeInclusive<i32>) -> Self { pub fn i32(value: &'a mut i32, range: RangeInclusive<i32>) -> Self {
let range = (*range.start() as f32)..=(*range.end() as f32);
Self { Self {
precision: Some(0), precision: Some(0),
..Self::from_get_set(range, move |v: Option<f32>| { ..Self::from_get_set(to_f64_range(range), move |v: Option<f64>| {
if let Some(v) = v { if let Some(v) = v {
*value = v.round() as i32 *value = v.round() as i32
} }
*value as f32 *value as f64
}) })
} }
} }
pub fn usize(value: &'a mut usize, range: RangeInclusive<usize>) -> Self { pub fn usize(value: &'a mut usize, range: RangeInclusive<usize>) -> Self {
let range = (*range.start() as f32)..=(*range.end() as f32); let range = (*range.start() as f64)..=(*range.end() as f64);
Self { Self {
precision: Some(0), precision: Some(0),
..Self::from_get_set(range, move |v: Option<f32>| { ..Self::from_get_set(range, move |v: Option<f64>| {
if let Some(v) = v { if let Some(v) = v {
*value = v.round() as usize *value = v.round() as usize
} }
*value as f32 *value as f64
}) })
} }
} }
@ -102,28 +125,28 @@ impl<'a> Slider<'a> {
self self
} }
fn get_value_f32(&mut self) -> f32 { fn get_value(&mut self) -> f64 {
(self.get_set_value)(None) get(&mut self.get_set_value)
} }
fn set_value_f32(&mut self, mut value: f32) { fn set_value(&mut self, mut value: f64) {
if let Some(precision) = self.precision { if let Some(precision) = self.precision {
value = round_to_precision_f32(value, precision); value = round_to_precision(value, precision);
} }
(self.get_set_value)(Some(value)); set(&mut self.get_set_value, value);
} }
/// For instance, `x` is the mouse position and `x_range` is the physical location of the slider on the screen. /// For instance, `x` is the mouse position and `x_range` is the physical location of the slider on the screen.
fn value_from_x_clamped(&self, x: f32, x_range: RangeInclusive<f32>) -> f32 { fn value_from_x_clamped(&self, x: f32, x_range: RangeInclusive<f32>) -> f64 {
remap_clamp(x, x_range, self.range.clone()) remap_clamp(x as f64, to_f64_range(x_range), self.range.clone())
} }
fn value_from_x(&self, x: f32, x_range: RangeInclusive<f32>) -> f32 { fn value_from_x(&self, x: f32, x_range: RangeInclusive<f32>) -> f64 {
remap(x, x_range, self.range.clone()) remap(x as f64, to_f64_range(x_range), self.range.clone())
} }
fn x_from_value(&self, value: f32, x_range: RangeInclusive<f32>) -> f32 { fn x_from_value(&self, value: f64, x_range: RangeInclusive<f32>) -> f32 {
remap(value, self.range.clone(), x_range) remap(value, self.range.clone(), to_f64_range(x_range)) as f32
} }
} }
@ -156,24 +179,24 @@ impl<'a> Slider<'a> {
if let Some(mouse_pos) = ui.input().mouse.pos { if let Some(mouse_pos) = ui.input().mouse.pos {
if response.active { if response.active {
let aim_radius = ui.input().aim_radius(); let aim_radius = ui.input().aim_radius();
let new_value = crate::math::smart_aim::best_in_range_f32( let new_value = crate::math::smart_aim::best_in_range_f64(
self.value_from_x_clamped(mouse_pos.x - aim_radius, x_range.clone()), self.value_from_x_clamped(mouse_pos.x - aim_radius, x_range.clone()),
self.value_from_x_clamped(mouse_pos.x + aim_radius, x_range.clone()), self.value_from_x_clamped(mouse_pos.x + aim_radius, x_range.clone()),
); );
self.set_value_f32(new_value); self.set_value(new_value);
} }
} }
// Paint it: // Paint it:
{ {
let value = self.get_value_f32(); let value = self.get_value();
let rail_radius = ui.painter().round_to_pixel((rect.height() / 8.0).max(2.0)); let rail_radius = ui.painter().round_to_pixel((rect.height() / 8.0).max(2.0));
let rail_rect = Rect::from_min_max( let rail_rect = Rect::from_min_max(
pos2(rect.left(), rect.center().y - rail_radius), pos2(rect.left(), rect.center().y - rail_radius),
pos2(rect.right(), rect.center().y + rail_radius), pos2(rect.right(), rect.center().y + rail_radius),
); );
let marker_center_x = remap_clamp(value, range, x_range); let marker_center_x = self.x_from_value(value, x_range);
ui.painter().add(PaintCmd::Rect { ui.painter().add(PaintCmd::Rect {
rect: rail_rect, rect: rail_rect,
@ -205,22 +228,6 @@ impl<'a> Slider<'a> {
} }
} }
// fn value_ui(&mut self, ui: &mut Ui, x_range: RangeInclusive<f32>) {
// TODO: make it a drag value somehow
// fn range_width(range: &RangeInclusive<f32>) -> f32 {
// range.end() - range.start()
// }
// let range = self.range.clone();
// let get_set_f64 = |value: Option<f64>| (self.get_set_value)(value.map(|x| x as f32)) as f64;
// let speed = range_width(&range) / range_width(&x_range);
// // TODO: precision
// ui.add(
// DragValue::from_get_set(get_set_f64)
// .range(range)
// .speed(speed),
// );
// }
fn value_ui(&mut self, ui: &mut Ui, x_range: RangeInclusive<f32>) { fn value_ui(&mut self, ui: &mut Ui, x_range: RangeInclusive<f32>) {
let kb_edit_id = self.id.expect("We should have an id by now").with("edit"); let kb_edit_id = self.id.expect("We should have an id by now").with("edit");
let is_kb_editing = ui.memory().has_kb_focus(kb_edit_id); let is_kb_editing = ui.memory().has_kb_focus(kb_edit_id);
@ -244,7 +251,7 @@ impl<'a> Slider<'a> {
.text_style(TextStyle::Monospace), .text_style(TextStyle::Monospace),
); );
if let Ok(value) = value_text.parse() { if let Ok(value) = value_text.parse() {
self.set_value_f32(value); self.set_value(value);
} }
if ui.input().key_pressed(Key::Enter) { if ui.input().key_pressed(Key::Enter) {
ui.memory().surrender_kb_focus(kb_edit_id); ui.memory().surrender_kb_focus(kb_edit_id);
@ -267,19 +274,19 @@ impl<'a> Slider<'a> {
} }
fn format_value(&mut self, aim_radius: f32, x_range: RangeInclusive<f32>) -> String { fn format_value(&mut self, aim_radius: f32, x_range: RangeInclusive<f32>) -> String {
let value = (self.get_set_value)(None); let value = self.get_value();
let precision = self.precision.unwrap_or_else(|| { let precision = self.precision.unwrap_or_else(|| {
// pick precision based upon how much moving the slider would change the value: // pick precision based upon how much moving the slider would change the value:
let value_from_x = |x| self.value_from_x(x, x_range.clone()); let value_from_x = |x: f32| self.value_from_x(x, x_range.clone());
let x_from_value = |value| self.x_from_value(value, x_range.clone()); let x_from_value = |value: f64| self.x_from_value(value, x_range.clone());
let left_value = value_from_x(x_from_value(value) - aim_radius); let left_value = value_from_x(x_from_value(value) - aim_radius);
let right_value = value_from_x(x_from_value(value) + aim_radius); let right_value = value_from_x(x_from_value(value) + aim_radius);
let range = (left_value - right_value).abs(); let range = (left_value - right_value).abs();
(-range.log10()).ceil().max(0.0) as usize (-range.log10()).ceil().max(0.0) as usize
}); });
format_with_minimum_precision(value, precision) format_with_minimum_precision(value as f32, precision)
} }
} }