simplify things

1 files changed, 116 insertions, 182 deletions

diff --git a/src/params.rs b/src/params.rs
index 605e305..4b57dd6 100644
--- a/src/params.rs
+++ b/src/params.rs
@@ -1,5 +1,3 @@
-//! Contains all types and implementations related to parameter management.
-
 use crate::{RetainPluginMainThread, window_size::WindowSize, window_type::WindowType};
 use clack_extensions::{
     params::{
@@ -21,18 +19,14 @@ use std::{
     sync::atomic::{AtomicBool, AtomicU8, AtomicUsize, Ordering},
 };
 
-/// The default value of the order parameter.
+/// The default values of the parameters.
 const DEFAULT_ORDER: usize = 1;
 pub const DEFAULT_WINDOW_SIZE: WindowSize = WindowSize::Size4096;
 pub const DEFAULT_WINDOW_TYPE: WindowType = WindowType::Hann;
 const DEFAULT_COMPLEMENT: bool = false;
 
-/// A struct that manages the parameters for our plugin.
-///
-/// This struct will be used both by the [`RetainPluginMainThread`] (which the host will use
-/// to query the value of our parameters), and by the [`RetainPluginAudioProcessor`], which will
-/// actually modulate the audio samples.
-pub struct RetainParamsShared {
+/// A struct that manages the parameters for the plugin.
+pub struct RetainParams {
     /// The current value of the order parameter.
     order: AtomicUsize,
     /// Window size of FFT
@@ -43,12 +37,12 @@ pub struct RetainParamsShared {
     complement: AtomicBool,
 }
 
-impl RetainParamsShared {
+impl RetainParams {
     /// The unique identifier for the order parameter.
     pub const PARAM_ORDER_ID: ClapId = ClapId::new(1);
     pub const PARAM_WINDOW_SIZE_ID: ClapId = ClapId::new(2);
     pub const PARAM_WINDOW_TYPE_ID: ClapId = ClapId::new(3);
-    pub const PARAM_COMPLEMENT_ID: ClapId = ClapId::new(3);
+    pub const PARAM_COMPLEMENT_ID: ClapId = ClapId::new(4);
 
     /// Initializes the shared parameter value.
     pub fn new() -> Self {
@@ -59,157 +53,85 @@ impl RetainParamsShared {
             complement: AtomicBool::new(DEFAULT_COMPLEMENT),
         }
     }
-}
-
-/// The local-side of parameter state.
-///
-/// This state is local to the current thread (whether it is the main-thread, the UI or the audio
-/// thread), it is not shared directly with the others.
-///
-/// This allows us to both check for differences, and to only update parameter state when we want
-/// to.
-pub struct RetainParamsLocal {
-    /// The local value of the order parameter.
-    order: usize,
-    /// The local value of the window size paramter.
-    window_size: usize,
-    /// The local value of the type of window function parameter.
-    window_type: WindowType,
-    /// The local value of the complement parameter.
-    complement: bool,
-}
-
-impl RetainParamsLocal {
-    /// Initializes a new local state from the current shared state.
-    pub fn new(shared: &RetainParamsShared) -> Self {
-        Self {
-            order: shared.order.load(Ordering::Relaxed),
-            window_size: shared.window_size.load(Ordering::Relaxed),
-            window_type: WindowType::from_byte(shared.window_type.load(Ordering::Relaxed)),
-            complement: shared.complement.load(Ordering::Relaxed),
-        }
-    }
 
-    /// Returns the current local order value.
+    /// Returns the current order value.
     #[inline]
     pub fn get_order(&self) -> usize {
-        self.order
+        self.order.load(Ordering::SeqCst)
     }
 
-    /// Sets the current local order to `value`.
+    /// Sets the current order to `value`.
     ///
-    /// It is clamped to the range `0..=100_000`.
+    /// It is clamped to the range `0..=32_768`.
     #[inline]
-    pub fn set_order(&mut self, value: usize) {
-        self.order = value;
+    pub fn set_order(&self, value: usize) {
+        self.order.store(value.clamp(0, 32768), Ordering::SeqCst);
     }
 
     /// Returns the current window size value.
     #[inline]
-    pub fn get_window_size(&self) -> usize {
-        self.window_size
+    pub fn get_window_size(&self) -> WindowSize {
+        self.window_size.load(Ordering::SeqCst).into()
     }
 
     /// Sets the current local window size to `value`.
     #[inline]
-    pub fn set_window_size(&mut self, value: usize) {
-        self.window_size = value;
+    pub fn set_window_size(&self, value: WindowSize) {
+        self.window_size.store(value.inner(), Ordering::SeqCst);
     }
 
     /// Returns the current local window type.
     #[inline]
-    pub fn get_window_type(&self) -> &WindowType {
-        &self.window_type
+    pub fn get_window_type(&self) -> WindowType {
+        self.window_type.load(Ordering::SeqCst).into()
     }
 
     /// Sets the current local window type from `bits`.
     #[inline]
-    pub fn set_window_type_from_byte(&mut self, bits: u8) {
-        self.window_type = WindowType::from_byte(bits);
+    pub fn set_window_type(&self, window_type: WindowType) {
+        self.window_type
+            .store(window_type.as_byte(), Ordering::SeqCst);
     }
 
     /// Returns the current local complement.
     #[inline]
     pub fn get_complement(&self) -> bool {
-        self.complement
+        self.complement.load(Ordering::SeqCst)
     }
 
     /// Sets the current local complement to `value`.
     #[inline]
-    pub fn set_complement(&mut self, value: bool) {
-        self.complement = value;
-    }
-
-    /// Fetch updates from the `shared` state.
-    ///
-    /// If any of the parameters have been updated, this returns `true`.
-    #[inline]
-    pub fn fetch_updates(&mut self, shared: &RetainParamsShared) -> bool {
-        let latest_order = shared.order.load(Ordering::Relaxed);
-        let latest_window_size = shared.window_size.load(Ordering::Relaxed);
-        let latest_window_type = WindowType::from_byte(shared.window_type.load(Ordering::Relaxed));
-        let latest_complement = shared.complement.load(Ordering::Relaxed);
-
-        if latest_order != self.order
-            || latest_window_size != self.order
-            || latest_window_type != self.window_type
-            || latest_complement != self.complement
-        {
-            self.order = latest_order;
-            self.window_size = latest_window_size;
-            self.window_type = latest_window_type;
-            self.complement = latest_complement;
-
-            true
-        } else {
-            false
-        }
-    }
-
-    /// Pushes the local parameter values to the `shared` state.
-    ///
-    /// If the values were different and an actual update occurred, this returns `true`.
-    #[inline]
-    pub fn push_updates(&self, shared: &RetainParamsShared) -> bool {
-        let previous_order = shared.order.swap(self.order, Ordering::Relaxed);
-        let previous_window_size = shared.window_size.swap(self.window_size, Ordering::Relaxed);
-        let previous_window_type = shared
-            .window_type
-            .swap(self.window_type.as_byte(), Ordering::Relaxed);
-        let previous_complement = shared.complement.swap(self.complement, Ordering::Relaxed);
-
-        previous_order != self.order
-            || previous_window_size != self.window_size
-            || previous_window_type != self.window_type.as_byte()
-            || previous_complement != self.complement
+    pub fn set_complement(&self, value: bool) {
+        self.complement.store(value, Ordering::SeqCst);
     }
 
     /// Handles incoming events.
     ///
     /// If the given event is a matching parameter change event, the order parameter will be
     /// updated accordingly.
-    pub fn handle_event(&mut self, event: &UnknownEvent) {
+    pub fn handle_event(&self, event: &UnknownEvent) {
         if let Some(CoreEventSpace::ParamValue(event)) = event.as_core_event() {
-            if event.param_id() == RetainParamsShared::PARAM_ORDER_ID {
+            if event.param_id() == RetainParams::PARAM_ORDER_ID {
                 self.set_order(event.value() as usize);
             }
 
-            if event.param_id() == RetainParamsShared::PARAM_WINDOW_SIZE_ID {
-                self.set_window_size(event.value() as usize);
+            if event.param_id() == RetainParams::PARAM_WINDOW_SIZE_ID {
+                self.set_window_size((event.value() as usize).into());
             }
 
-            if event.param_id() == RetainParamsShared::PARAM_WINDOW_TYPE_ID {
-                self.set_window_type_from_byte(event.value() as u8);
+            if event.param_id() == RetainParams::PARAM_WINDOW_TYPE_ID {
+                self.set_window_type((event.value() as u8).into());
             }
 
-            if event.param_id() == RetainParamsShared::PARAM_COMPLEMENT_ID {
+            if event.param_id() == RetainParams::PARAM_COMPLEMENT_ID {
                 self.set_complement(event.value() != 0.0);
             }
         }
     }
 }
 
-/// To save the plugin state (parameter values) using protocol buffers
+/// Wrapper that helps save plugin parameters using protocol buffers
+/// Updating this will change the schema and break old
 #[derive(Message)]
 struct PluginState {
     #[prost(uint64, tag = "1")]
@@ -223,10 +145,10 @@ struct PluginState {
 }
 
 impl PluginState {
-    fn copied(local_params: &RetainParamsLocal) -> Self {
+    fn copied(local_params: &RetainParams) -> Self {
         Self {
             order: local_params.get_order() as u64,
-            window_size: local_params.get_window_size() as u32,
+            window_size: local_params.get_window_size().inner() as u32,
             window_type: local_params.get_window_type().as_byte() as u32,
             complement: local_params.get_complement(),
         }
@@ -249,14 +171,12 @@ impl PluginState {
     }
 }
 
-/// Implementation of the State extension.
+/// To save and load the plugin parameters
 impl PluginStateImpl for RetainPluginMainThread<'_> {
     fn save(&mut self, output: &mut OutputStream) -> Result<(), PluginError> {
-        self.params.fetch_updates(&self.shared.params);
-
         let mut data = vec![];
 
-        let state = PluginState::copied(&self.params);
+        let state = PluginState::copied(&self.shared.params);
 
         state.encode(&mut data)?;
 
@@ -271,13 +191,14 @@ impl PluginStateImpl for RetainPluginMainThread<'_> {
 
         let data = PluginState::decode(&data[..])?;
 
-        self.params.set_order(data.get_order() as usize);
-        self.params.set_window_size(data.get_window_size() as usize);
-        self.params
-            .set_window_type_from_byte(data.get_window_type_bits());
-        self.params.set_complement(data.get_complement());
-
-        self.params.push_updates(&self.shared.params);
+        self.shared.params.set_order(data.get_order() as usize);
+        self.shared
+            .params
+            .set_window_size((data.get_window_size() as usize).into());
+        self.shared
+            .params
+            .set_window_type(data.get_window_type_bits().into());
+        self.shared.params.set_complement(data.get_complement());
 
         Ok(())
     }
@@ -288,92 +209,105 @@ impl PluginMainThreadParams for RetainPluginMainThread<'_> {
         4
     }
 
+    /// `param_index`: The index of the parameter to query.
+    /// Must be less than the value returned by `count()`.
     fn get_info(&mut self, param_index: u32, info: &mut ParamInfoWriter) {
-        if param_index != 0 {
+        if param_index >= 4 {
             return;
         }
 
-        info.set(&ParamInfo {
-            id: RetainParamsShared::PARAM_ORDER_ID,
-            flags: ParamInfoFlags::IS_AUTOMATABLE | ParamInfoFlags::IS_STEPPED,
-            cookie: Cookie::default(),
-            name: b"Order",
-            module: b"",
-            min_value: 0.0,
-            max_value: f64::MAX,
-            default_value: DEFAULT_ORDER as f64,
-        });
-
-        info.set(&ParamInfo {
-            id: RetainParamsShared::PARAM_WINDOW_SIZE_ID,
-            flags: ParamInfoFlags::IS_READONLY,
-            cookie: Cookie::default(),
-            name: b"Window Size",
-            module: b"",
-            min_value: 128.0,
-            max_value: usize::MAX as f64,
-            default_value: DEFAULT_WINDOW_SIZE.inner() as f64,
-        });
-
-        info.set(&ParamInfo {
-            id: RetainParamsShared::PARAM_WINDOW_TYPE_ID,
-            flags: ParamInfoFlags::IS_READONLY,
-            cookie: Cookie::default(),
-            name: b"Window Function",
-            module: b"",
-            min_value: 0.0,
-            max_value: 4.0,
-            default_value: DEFAULT_WINDOW_TYPE.as_byte() as f64,
-        });
-
-        info.set(&ParamInfo {
-            id: RetainParamsShared::PARAM_COMPLEMENT_ID,
-            flags: ParamInfoFlags::IS_READONLY,
-            cookie: Cookie::default(),
-            name: b"Complement",
-            module: b"",
-            min_value: 0.0,
-            max_value: 1.0,
-            default_value: DEFAULT_COMPLEMENT as u8 as f64,
-        });
+        // cleaner than match is
+        if param_index == 0 {
+            info.set(&ParamInfo {
+                id: RetainParams::PARAM_ORDER_ID,
+                flags: ParamInfoFlags::IS_AUTOMATABLE | ParamInfoFlags::IS_STEPPED,
+                cookie: Cookie::default(),
+                name: b"Order",
+                module: b"",
+                min_value: 0.0,
+                max_value: 32768.0,
+                default_value: DEFAULT_ORDER as f64,
+            });
+        }
+
+        if param_index == 1 {
+            info.set(&ParamInfo {
+                id: RetainParams::PARAM_WINDOW_SIZE_ID,
+                flags: ParamInfoFlags::IS_READONLY,
+                cookie: Cookie::default(),
+                name: b"Window Size",
+                module: b"",
+                min_value: 256.0,
+                max_value: 32768.0,
+                default_value: DEFAULT_WINDOW_SIZE.inner() as f64,
+            });
+        }
+
+        if param_index == 2 {
+            info.set(&ParamInfo {
+                id: RetainParams::PARAM_WINDOW_TYPE_ID,
+                flags: ParamInfoFlags::IS_READONLY,
+                cookie: Cookie::default(),
+                name: b"Window Function",
+                module: b"",
+                min_value: 0.0,
+                max_value: 4.0,
+                default_value: DEFAULT_WINDOW_TYPE.as_byte() as f64,
+            });
+        }
+
+        if param_index == 3 {
+            info.set(&ParamInfo {
+                id: RetainParams::PARAM_COMPLEMENT_ID,
+                flags: ParamInfoFlags::IS_READONLY,
+                cookie: Cookie::default(),
+                name: b"Complement",
+                module: b"",
+                min_value: 0.0,
+                max_value: 1.0,
+                default_value: DEFAULT_COMPLEMENT as u8 as f64,
+            });
+        }
     }
 
     fn get_value(&mut self, param_id: ClapId) -> Option<f64> {
         match param_id {
-            RetainParamsShared::PARAM_ORDER_ID => Some(self.params.get_order() as f64),
-            RetainParamsShared::PARAM_WINDOW_SIZE_ID => Some(self.params.get_window_size() as f64),
-            RetainParamsShared::PARAM_WINDOW_TYPE_ID => {
-                Some(self.params.get_window_type().as_byte() as f64)
+            RetainParams::PARAM_ORDER_ID => Some(self.shared.params.get_order() as f64),
+            RetainParams::PARAM_WINDOW_SIZE_ID => {
+                Some(self.shared.params.get_window_size().inner() as f64)
+            }
+            RetainParams::PARAM_WINDOW_TYPE_ID => {
+                Some(self.shared.params.get_window_type().as_byte() as f64)
             }
-            RetainParamsShared::PARAM_COMPLEMENT_ID => {
-                Some(self.params.get_complement() as u8 as f64)
+            RetainParams::PARAM_COMPLEMENT_ID => {
+                Some(self.shared.params.get_complement() as u8 as f64)
             }
             _ => None,
         }
     }
 
-    // TODO: update for order
     fn value_to_text(
         &mut self,
         param_id: ClapId,
         value: f64,
         writer: &mut ParamDisplayWriter,
     ) -> std::fmt::Result {
-        if param_id == RetainParamsShared::PARAM_ORDER_ID {
-            write!(writer, "{0:.2} %", value * 100.0)
+        if param_id == RetainParams::PARAM_ORDER_ID {
+            write!(writer, "{}", value as u64)
         } else {
             Err(std::fmt::Error)
         }
     }
 
-    // TODO: update for order
     fn text_to_value(&mut self, param_id: ClapId, text: &CStr) -> Option<f64> {
         let text = text.to_str().ok()?;
-        if param_id == RetainParamsShared::PARAM_ORDER_ID {
-            let text = text.strip_suffix('%').unwrap_or(text).trim();
-            let percentage: f64 = text.parse().ok()?;
 
-            Some(percentage / 100.0)
+        if param_id == RetainParams::PARAM_ORDER_ID {
+            let max = self.shared.params.get_window_size().inner() as f64;
+
+            let order_value = text.parse::<f64>().ok()?;
+
+            Some(order_value.clamp(0.0, max))
         } else {
             None
         }
@@ -385,7 +319,7 @@ impl PluginMainThreadParams for RetainPluginMainThread<'_> {
         _output_parameter_changes: &mut OutputEvents,
     ) {
         for event in input_parameter_changes {
-            self.params.handle_event(event);
+            self.shared.params.handle_event(event);
         }
     }
 }