Merge pull request #9 from bratorange/logarithmic. Fixes #8

Logarithmic Knobs

README.md

@@ -18,6 +18,7 @@ A simple, customizable knob widget for egui.
 - Configurable sweep range
 - Background arc with filled segments
 - Adjustable drag sensitivity
+- Logarithmic scaling
 
 ## Installation
 
@@ -104,6 +105,13 @@ Knob::new(&mut value, 0.0, 1.0, KnobStyle::Wiper)
     .with_label_format(|v| format!("{:.0}%", v * 100.0));
 ```
 
+#### Logarithmic Knobs
+```rust
+// Enable logarithmic scaling
+Knob::new(&mut value, 0.0, 1.0, KnobStyle::Wiper)
+    .with_logarithmic_scaling();
+```
+
 ## Running demo app
 
 ```bash

examples/example_knob.rs

@@ -21,6 +21,7 @@ struct KnobDemo {
     show_bg_arc: bool,
     show_filled: bool,
     use_step: bool,
+    logarithmic_scaling: bool,
     knob_color: egui::Color32,
     line_color: egui::Color32,
     text_color: egui::Color32,
@@ -33,6 +34,7 @@ impl Default for KnobDemo {
             show_bg_arc: true,
             show_filled: true,
             use_step: false,
+            logarithmic_scaling: false,
             knob_color: egui::Color32::DARK_GRAY,
             line_color: egui::Color32::LIGHT_BLUE,
             text_color: egui::Color32::WHITE,
@@ -51,6 +53,8 @@ impl eframe::App for KnobDemo {
                 ui.checkbox(&mut self.show_bg_arc, "Background arc");
                 ui.checkbox(&mut self.show_filled, "Filled segment");
                 ui.checkbox(&mut self.use_step, "Step (0.02)");
+                ui.checkbox(&mut self.logarithmic_scaling, "Logarithmic");
+
             });
 
             ui.horizontal(|ui| {
@@ -82,7 +86,7 @@ impl eframe::App for KnobDemo {
                     .enumerate()
                     {
                         ui.vertical(|ui| {
-                            let mut knob = Knob::new(&mut self.values[i], 0.0, 1.0, *config)
+                            let mut knob = Knob::new(&mut self.values[i], 0., 1., *config)
                                 .with_label(*label, LabelPosition::Bottom)
                                 .with_background_arc(self.show_bg_arc)
                                 .with_show_filled_segments(self.show_filled)
@@ -91,6 +95,10 @@ impl eframe::App for KnobDemo {
                                 .with_double_click_reset(0.5)
                                 .with_middle_scroll();
 
+                            if self.logarithmic_scaling {
+                                knob = knob.with_logarithmic_scaling();
+                            }
+
                             if *label == "Wiper, Sweep" {
                                 knob = knob.with_sweep_range(0.25, 0.75).with_size(50.0);
                             }

src/config.rs

@@ -18,6 +18,7 @@ pub struct KnobConfig {
     pub(crate) max_angle: f32,
     pub(crate) reset_value: Option<f32>,
     pub(crate) allow_scroll: bool,
+    pub(crate) logarithmic_scaling: bool,
 }
 
 impl KnobConfig {
@@ -39,7 +40,8 @@ impl KnobConfig {
             show_background_arc: true,
             show_filled_segments: true,
             reset_value: None,
-            allow_scroll:false
+            allow_scroll:false,
+            logarithmic_scaling: false,
         }
     }
 }

src/render.rs

@@ -6,27 +6,28 @@ use crate::style::{KnobStyle, LabelPosition};
 pub(crate) struct KnobRenderer<'a> {
     config: &'a KnobConfig,
     value: f32,
+    raw: f32,
     min: f32,
     max: f32,
 }
 
 impl<'a> KnobRenderer<'a> {
-    pub fn new(config: &'a KnobConfig, value: f32, min: f32, max: f32) -> Self {
+    pub fn new(config: &'a KnobConfig, value: f32, raw: f32, min: f32, max: f32) -> Self {
         Self {
             config,
             value,
+            raw,
             min,
             max,
         }
     }
 
     pub fn compute_angle(&self) -> f32 {
-        if self.min == self.max || self.value.is_nan() {
+        if self.min == self.max || self.raw.is_nan() {
             self.config.min_angle
         } else {
             self.config.min_angle
-                + (self.value - self.min) / (self.max - self.min)
+                + self.raw * (self.config.max_angle - self.config.min_angle)
-                    * (self.config.max_angle - self.config.min_angle)
         }
     }
 
@@ -99,7 +100,7 @@ impl<'a> KnobRenderer<'a> {
 
         if self.config.show_filled_segments {
             let filled_segments = (segments as f32
-                * ((self.value - self.min) / (self.max - self.min)).clamp(0.0, 1.0))
+                * self.raw.clamp(0.0, 1.0))
                 as usize;
 
             if filled_segments > 0 {

src/widget.rs

@@ -1,4 +1,4 @@
-use egui::{Color32, Response, Sense, Ui, Widget};
+use egui::{remap, Color32, Response, Sense, Ui, Widget};
 
 use crate::config::KnobConfig;
 use crate::render::KnobRenderer;
@@ -168,6 +168,10 @@ impl<'a> Knob<'a> {
         self.config.allow_scroll = true;
         self
     }
+    pub fn with_logarithmic_scaling(mut self) -> Self {
+        self.config.logarithmic_scaling = true;
+        self
+    }
 }
 
 impl Widget for Knob<'_> {
@@ -176,8 +180,13 @@ impl Widget for Knob<'_> {
             *self.value = self.min;
         }
 
-        let current_value = *self.value;
+        let mut raw = if self.config.logarithmic_scaling {
-        let renderer = KnobRenderer::new(&self.config, current_value, self.min, self.max);
+            remap(*self.value, self.min..=self.max, 1.0..=10.0).log(10.0)
+        } else {
+            remap(*self.value, self.min..=self.max, 0.0..=1.0)
+        };
+
+        let renderer = KnobRenderer::new(&self.config, *self.value, raw, self.min, self.max);
         let adjusted_size = renderer.calculate_size(ui);
 
         let (rect, response) = ui.allocate_exact_size(adjusted_size, Sense::click_and_drag());
@@ -185,36 +194,43 @@ impl Widget for Knob<'_> {
         let mut response = response;
         if response.dragged() {
             let delta = response.drag_delta().y;
-            let range = self.max - self.min;
+            let step = self.config.step.unwrap_or(self.config.drag_sensitivity);
-            let step = self.config.step.unwrap_or(range * self.config.drag_sensitivity);
+            raw = (raw - delta * step).clamp(0.0,1.0);
-            let new_value = (*self.value - delta * step).clamp(self.min, self.max);
 
-            *self.value = if let Some(step) = self.config.step {
+            raw = if let Some(step) = self.config.step {
-                let steps = ((new_value - self.min) / step).round();
+                let steps = (raw / step).round();
-                (self.min + steps * step).clamp(self.min, self.max)
+                (steps * step).clamp(0.0, 1.0)
             } else {
-                new_value
+                raw
             };
 
             if self.value.is_nan() {
-                *self.value = self.min;
+                *self.value = 0.0;
             }
 
             response.mark_changed();
-        } else if response.double_clicked() {
+        }  else if response.hovered() & self.config.allow_scroll {
-            if let Some(reset_value) = self.config.reset_value {
-                *self.value = reset_value
-            }
-        } else if response.hovered() & self.config.allow_scroll {
             if let Some(scoll) = ui.input(|input| {
                 input.events.iter().find_map(|e| match e {
                     egui::Event::MouseWheel { delta, .. } => Some(*delta),
                     _ => None,
                 })
             }) {
-                *self.value = (*self.value
+                raw = (raw
                     + scoll.y * self.config.step.unwrap_or(self.config.drag_sensitivity))
-                .clamp(self.min, self.max);
+                .clamp(0.0, 1.0);
+            }
+        }
+
+        *self.value = if self.config.logarithmic_scaling {
+            remap(10f32.powf(raw), 1.0..=10.0, self.min..=self.max)
+        }else {
+            remap(raw, 0.0..=1.0, self.min..=self.max)
+        };
+
+        if response.double_clicked() {
+            if let Some(reset_value) = self.config.reset_value {
+                *self.value = reset_value
             }
         }
 
@@ -222,8 +238,7 @@ impl Widget for Knob<'_> {
         let center = knob_rect.center();
         let radius = self.config.size / 2.0;
 
-        let updated_value = *self.value;
+        let updated_renderer = KnobRenderer::new(&self.config, *self.value, raw, self.min, self.max);
-        let updated_renderer = KnobRenderer::new(&self.config, updated_value, self.min, self.max);
         updated_renderer.render_knob(ui.painter(), center, radius, response.hovered());
         updated_renderer.render_label(ui, rect);