Add some of the building blocks for param handling

Cargo.lock

@@ -0,0 +1,16 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "atomic_float"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62af46d040ba9df09edc6528dae9d8e49f5f3e82f55b7d2ec31a733c38dbc49d"
+
+[[package]]
+name = "nih-plugs"
+version = "0.1.0"
+dependencies = [
+ "atomic_float",
+]

Cargo.toml

@@ -6,3 +6,4 @@ authors = ["Robbert van der Helm <mail@robbertvanderhelm.nl>"]
 license = "GPL-3.0-or-later"
 
 [dependencies]
+atomic_float = "0.1.0"

src/atomic.rs

@@ -0,0 +1,42 @@
+// nih-plugs: plugins, but rewritten in Rust
+// Copyright (C) 2022 Robbert van der Helm
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use atomic_float::AtomicF32;
+use std::sync::atomic::AtomicI32;
+
+// Type families galore!
+pub trait AtomicType {
+    /// An atomic version of this type with interior mutability.
+    type AtomicType;
+
+    fn new_atomic(self) -> Self::AtomicType;
+}
+
+impl AtomicType for f32 {
+    type AtomicType = AtomicF32;
+
+    fn new_atomic(self) -> AtomicF32 {
+        AtomicF32::new(self)
+    }
+}
+
+impl AtomicType for i32 {
+    type AtomicType = AtomicI32;
+
+    fn new_atomic(self) -> AtomicI32 {
+        AtomicI32::new(self)
+    }
+}

src/lib.rs

@@ -1,8 +1,18 @@
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        let result = 2 + 2;
-        assert_eq!(result, 4);
-    }
-}
+// nih-plugs: plugins, but rewritten in Rust
+// Copyright (C) 2022 Robbert van der Helm
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+pub mod atomic;
+pub mod params;

src/params.rs

@@ -0,0 +1,136 @@
+// nih-plugs: plugins, but rewritten in Rust
+// Copyright (C) 2022 Robbert van der Helm
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::atomic::AtomicType;
+
+/// Describes a single normalized parameter and also stores its value.
+pub enum Param {
+    FloatParam(PlainParam<f32>),
+    IntParam(PlainParam<i32>),
+}
+
+/// A distribution for a parameter's range. Probably need to add some forms of skewed ranges and
+/// maybe a callback based implementation at some point.
+#[derive(Debug)]
+pub enum Range<T> {
+    Linear { min: T, max: T },
+}
+
+trait Normalize<T> {
+    /// Normalize an unnormalized value. Will be clamped to the bounds of the range if the
+    /// normalized value exceeds `[0, 1]`.
+    fn normalize(&self, unnormalized: T) -> f32;
+
+    /// Unnormalize a normalized value. Will be clamped to `[0, 1]` if the unnormalized value would
+    /// exceed that range.
+    fn unnormalize(&self, normalized: f32) -> T;
+}
+
+/// A numerical parameter that's stored unnormalized. The range is used for the normalization
+/// process.
+pub struct PlainParam<T: AtomicType> {
+    /// The field's current, normalized value. Should be initialized with the default value using
+    /// `T::new_atomic(...)` ([AtomicType::new_atomic]).
+    pub value: <T as AtomicType>::AtomicType,
+
+    /// The distribution of the parameter's values.
+    pub range: Range<T>,
+    /// The parameter's human readable display name.
+    pub name: &'static str,
+    /// The parameter value's unit, added after `value_to_string` if that is set.
+    pub unit: &'static str,
+    /// Optional custom conversion function from an **unnormalized** value to a string.
+    pub value_to_string: Option<Box<dyn Fn(T) -> String>>,
+    /// Optional custom conversion function from a string to an **unnormalized** value.
+    pub string_to_value: Option<Box<dyn Fn(&str) -> T>>,
+}
+
+impl Normalize<f32> for Range<f32> {
+    fn normalize(&self, unnormalized: f32) -> f32 {
+        match &self {
+            Range::Linear { min, max } => (unnormalized - min) / (max - min),
+        }
+    }
+
+    fn unnormalize(&self, normalized: f32) -> f32 {
+        match &self {
+            Range::Linear { min, max } => (normalized * (max - min)) + min,
+        }
+    }
+}
+
+impl Normalize<i32> for Range<i32> {
+    fn normalize(&self, unnormalized: i32) -> f32 {
+        match &self {
+            Range::Linear { min, max } => (unnormalized - min) as f32 / (max - min) as f32,
+        }
+    }
+
+    fn unnormalize(&self, normalized: f32) -> i32 {
+        match &self {
+            Range::Linear { min, max } => (normalized * (max - min) as f32) as i32 + min,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_linear_float_range() -> Range<f32> {
+        Range::Linear {
+            min: 10.0,
+            max: 20.0,
+        }
+    }
+
+    fn make_linear_int_range() -> Range<i32> {
+        Range::Linear { min: -10, max: 10 }
+    }
+
+    #[test]
+    fn range_normalize_linear_float() {
+        let range = make_linear_float_range();
+        assert_eq!(range.normalize(17.5), 0.75);
+    }
+
+    #[test]
+    fn range_normalize_linear_int() {
+        let range = make_linear_int_range();
+        assert_eq!(range.normalize(-5), 0.25);
+    }
+
+    #[test]
+    fn range_unnormalize_linear_float() {
+        let range = make_linear_float_range();
+        assert_eq!(range.unnormalize(0.25), 12.5);
+    }
+
+    #[test]
+    fn range_unnormalize_linear_int() {
+        let range = make_linear_int_range();
+        assert_eq!(range.unnormalize(0.75), 5);
+    }
+}
+
+fn foo(param: &Param) -> f32 {
+    match param {
+        Param::FloatParam(p) => p
+            .range
+            .normalize(p.value.load(std::sync::atomic::Ordering::Relaxed)),
+        Param::IntParam(_) => todo!(),
+    }
+}