macros for parameters // work on cassette player

l-Luna · l-Luna · commit 5ceb76bf0350 · 2025-04-24T20:43:49.000+01:00
diff --git a/cassette_player/src/cassette_player.rs b/cassette_player/src/cassette_player.rs
@@ -2,24 +2,37 @@ use circular_buffer::CircularBuffer;
 use scamble::dsp::decode::decode_into;
 use scamble::dsp::signal::{Signal, SignalConst, SignalMut};
 use scamble::dsp::{Dsp, DspType, Parameter, ParameterType, ProcessResult};
+use scamble::{bool_param, enum_param, float_param, int_param};
+
+#[derive(Copy, Clone)]
+enum VoiceMode {
+    Combine,
+    Average,
+    Overtake,
+}
 
 #[derive(Copy, Clone)]
 struct TrailingNote {
     pos: usize,
     end: usize,
+    fadeout_samples: usize,
 }
 
 pub struct CassettePlayer {
     // user-specified parameters
     samples: Vec<f32>, // downsample to mono for now
     num_notes: usize,
+    _async: bool,
     start_offset_percent: f32,
     end_offset_percent: f32,
+    voices: u8,
+    voice_mode: VoiceMode,
     // game-state parameters
     note_frac: f32,
     // state
-    trailing_notes: CircularBuffer<4, TrailingNote>,
+    trailing_notes: CircularBuffer<8, TrailingNote>,
     prev_note_frac: f32,
+    async_note_tick: usize,
 }
 
 impl CassettePlayer {
@@ -37,11 +50,19 @@ impl CassettePlayer {
         self.end_idx().saturating_sub(self.start_idx())
     }
 
+    fn approx_note_len(&self) -> usize {
+        ((self.content_len() as f32) / (self.num_notes as f32)) as usize
+    }
+
     fn note_at_pos(&self, pos: f32) -> TrailingNote {
         let clen = self.content_len() as f32;
         let start = (clen * pos) as usize + self.start_idx();
         let end = start + (clen / self.num_notes as f32) as usize;
-        TrailingNote { pos: start, end }
+        TrailingNote {
+            pos: start,
+            end,
+            fadeout_samples: 0,
+        }
     }
 }
 
@@ -63,7 +84,6 @@ impl Dsp for CassettePlayer {
             Parameter {
                 ty: ParameterType::Data {
                     setter: |data, dsp| {
-                        // TODO: actually decode
                         dsp.samples.clear();
                         decode_into(data, &mut dsp.samples);
                     },
@@ -73,68 +93,32 @@ impl Dsp for CassettePlayer {
                 unit: "",
                 desc: "",
             },
-            Parameter {
-                ty: ParameterType::Int {
-                    min: 1,
-                    max: 4096,
-                    default: 256,
-                    max_is_inf: false,
-                    names: None,
-                    setter: |value, dsp| dsp.num_notes = value as usize,
-                    getter: |dsp| dsp.num_notes as i32,
-                },
-                name: "num_notes",
-                unit: "",
-                desc: "",
-            },
-            Parameter {
-                ty: ParameterType::Float {
-                    min: 0.0,
-                    max: 100.0,
-                    default: 0.0,
-                    setter: |value, dsp| dsp.start_offset_percent = value,
-                    getter: |dsp| dsp.start_offset_percent,
-                },
-                name: "start_offset",
-                unit: "%",
-                desc: "",
-            },
-            Parameter {
-                ty: ParameterType::Float {
-                    min: 0.0,
-                    max: 100.0,
-                    default: 100.0,
-                    setter: |value, dsp| dsp.end_offset_percent = value,
-                    getter: |dsp| dsp.end_offset_percent,
-                },
-                name: "end_offset",
-                unit: "%",
-                desc: "",
-            },
-            Parameter {
-                ty: ParameterType::Float {
-                    min: 0.,
-                    max: 1.,
-                    default: 0.,
-                    setter: |value, dsp| dsp.note_frac = value,
-                    getter: |dsp| dsp.note_frac,
-                },
-                name: "note",
-                unit: "",
-                desc: "",
-            },
+            Parameter::new("num_notes", int_param!(num_notes: usize, range: 1..4096, default: 256)),
+            Parameter::new("async", bool_param!(_async, default: false)),
+            Parameter::with_unit("start_offset", "%", float_param!(start_offset_percent, range: 0.0..100.0, default: 0.)),
+            Parameter::with_unit("end_offset", "%", float_param!(end_offset_percent, range: 0.0..100.0, default: 100.)),
+            Parameter::new("voices", int_param!(voices: u8, range: 1..8, default: 4)),
+            Parameter::new(
+                "voice_mode",
+                enum_param!(voice_mode: VoiceMode, options: [Combine, Average, Overtake], default: Combine),
+            ),
+            Parameter::new("note", float_param!(note_frac, range: 0.0..1.0, default: 0.)),
         ]
     }
 
     fn create() -> Self {
         CassettePlayer {
             samples: vec![],
             num_notes: 0,
+            _async: false,
             start_offset_percent: 0.0,
             end_offset_percent: 100.0,
+            voices: 4,
+            voice_mode: VoiceMode::Combine,
             note_frac: 0.,
             trailing_notes: Default::default(),
             prev_note_frac: 2., // make sure the initial beat always triggers
+            async_note_tick: 0,
         }
     }
 
@@ -158,8 +142,20 @@ impl Dsp for CassettePlayer {
 
         // trigger new notes when parameter changes
         if self.note_frac != self.prev_note_frac {
-            self.trailing_notes
-                .push_back(self.note_at_pos(self.note_frac));
+            if self._async {
+                // in async mode, run an internal timer disconnected from the input parameter
+                // (parameter changing is all that matter)
+                let async_note_frac = (self.async_note_tick as f32) / (self.num_notes as f32);
+                self.trailing_notes.push_back(self.note_at_pos(async_note_frac));
+                self.async_note_tick += 1;
+                self.async_note_tick %= self.num_notes;
+            } else {
+                // in sync mode, use the position of the input as the position of the note
+                self.trailing_notes.push_back(self.note_at_pos(self.note_frac));
+            }
+            if self.trailing_notes.len() > self.voices as usize {
+                self.trailing_notes.pop_front();
+            }
         }
         self.prev_note_frac = self.note_frac;
 
diff --git a/rustfmt.toml b/rustfmt.toml
@@ -0,0 +1 @@
+max_width = 160
diff --git a/src/dsp/mod.rs b/src/dsp/mod.rs
@@ -1,9 +1,9 @@
 use crate::data::*;
 use crate::dsp::signal::*;
 
+pub mod decode;
 pub mod interop;
 pub mod signal;
-pub mod decode;
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum DspType {
@@ -62,32 +62,32 @@ pub enum ParameterType<Dsp: ?Sized> {
     },
     DynamicResponse {
         setter: fn(DynamicResponseData, &mut Dsp),
-        getter: fn(&Dsp) -> DynamicResponseData
+        getter: fn(&Dsp) -> DynamicResponseData,
     },
     /// Read by FMOD Studio to decide when to virtualize sounds.
     OverallGain {
         setter: fn(OverallGainData, &mut Dsp),
-        getter: fn(&Dsp) -> OverallGainData
+        getter: fn(&Dsp) -> OverallGainData,
     },
     /// Set by FMOD Studio with the player's position and attributes.
     ListenerAttributes {
         setter: fn(ListenerAttributesData, &mut Dsp),
-        getter: fn(&Dsp) -> ListenerAttributesData
+        getter: fn(&Dsp) -> ListenerAttributesData,
     },
     /// Set by FMOD Studio with all player's positions and attributes, if there are multiple.
     ListenerAttributesList {
         setter: fn(ListenerAttributesListData, &mut Dsp),
-        getter: fn(&Dsp) -> ListenerAttributesListData
+        getter: fn(&Dsp) -> ListenerAttributesListData,
     },
     /// Set by FMOD Studio to the min/max range of the event containing this DSP.
     AttenuationRange {
         setter: fn(AttenuationRangeData, &mut Dsp),
-        getter: fn(&Dsp) -> AttenuationRangeData
+        getter: fn(&Dsp) -> AttenuationRangeData,
     },
     /// Set to provide access to FFT data to games.
     Fft {
         setter: fn(FftData, &mut Dsp),
-        getter: fn(&Dsp) -> FftData
+        getter: fn(&Dsp) -> FftData,
     },
 }
 
@@ -122,3 +122,97 @@ pub trait Dsp {
 
     fn read(&mut self, input: SignalConst, output: SignalMut);
 }
+
+impl<T: ?Sized> Parameter<T> {
+    pub const fn new(name: &'static str, ty: ParameterType<T>) -> Self {
+        Self {
+            ty,
+            name,
+            unit: "",
+            desc: "",
+        }
+    }
+
+    pub const fn with_unit(name: &'static str, unit: &'static str, ty: ParameterType<T>) -> Self {
+        Self {
+            ty,
+            name,
+            unit,
+            desc: "",
+        }
+    }
+}
+
+// float_param!(note, range: 0.0..1.0, default: 0.0)
+#[macro_export]
+macro_rules! float_param {
+    ($name:ident $(: $t:ty)?, range: $min:literal..$max:literal, default: $default:literal) => {
+        ParameterType::Float {
+            min: $min,
+            max: $max,
+            default: $default,
+            setter: |value, dsp| dsp.$name = value $(as $t)?,
+            getter: |dsp| dsp.$name as f32
+        }
+    }
+}
+
+// int_param!(value: u8, range: 0..24, default: 1)
+#[macro_export]
+macro_rules! int_param {
+    ($name:ident $(: $t:ty)?, range: $min:literal..$max:literal, default: $default:literal) => {
+        ParameterType::Int {
+            min: $min,
+            max: $max,
+            default: $default,
+            max_is_inf: false,
+            names: None,
+            setter: |value, dsp| dsp.$name = value $(as $t)?,
+            getter: |dsp| dsp.$name as i32
+        }
+    }
+}
+
+// bool_param!(_async, default: false)
+#[macro_export]
+macro_rules! bool_param {
+    ($name:ident, default: $default:literal) => {
+        ParameterType::Bool {
+            default: $default,
+            names: None,
+            setter: |value, dsp| dsp.$name = value,
+            getter: |dsp| dsp.$name,
+        }
+    };
+}
+
+// enum_param!(voice_mode: VoiceMode, options: [Sum, Average, Solo], default: Solo)
+#[macro_export]
+macro_rules! enum_param {
+    ($name:ident: $t:ty, options: [$($opt:ident $(,)?)*], default: $default:ident) => {
+        ParameterType::Int {
+            min: 0,
+            max: ${count($opt)} - 1,
+            default: {
+                // aid autocomplete/deref by claiming that it's a variant of $t
+                let _: $t = <$t>::$default;
+                // ...but match by name in the list
+                [$(stringify!($opt),)*].iter().position(|h| *h == stringify!($default)).unwrap() as i32
+            },
+            max_is_inf: false,
+            names: Some(vec![$(stringify!($opt),)*]),
+            setter: |value, dsp| dsp.$name = match value {
+                $(
+                    ${index()} => <$t>::$opt,
+                )*
+                _ => panic!(concat!("Unknown variant {} for field ", stringify!($name)), value)
+            },
+            getter: |dsp| match dsp.$name {
+                $(
+                    <$t>::$opt => ${index()},
+                )*
+                _ => panic!()
+            }
+        }
+    }
+}
