start of break||

MEMLNaut-NISPS.ino

@@ -23,11 +23,13 @@
 #include "modes/MEMLNautModeChannelStrip.hpp"
 #include "modes/MEMLNautModeSoundAnalysisMIDI.hpp"
 #include "modes/MEMLNautModeXIASRI.hpp"
+#include "modes/MEMLNautModeBreakOr.hpp"
 
 //hook up the memlnaut mode 
 
 // #define MEMLNAUT_MODE_TYPE MEMLNautModeSoundAnalysisMIDI
-#define MEMLNAUT_MODE_TYPE MEMLNautModeXIASRI
+// #define MEMLNAUT_MODE_TYPE MEMLNautModeXIASRI
+#define MEMLNAUT_MODE_TYPE MEMLNautModeBreakOr
 // #define MEMLNAUT_MODE_TYPE MEMLNautModeChannelStrip
 // #define MEMLNAUT_MODE_TYPE MEMLNautModePAFSynth
 

modes/AudioApps/BreakOrAudioApp.hpp

@@ -0,0 +1,97 @@
+#ifndef __BREAKOR_AUDIO_APP_HPP__
+#define __BREAKOR_AUDIO_APP_HPP__
+
+#include "../../src/memllib/audio/AudioAppBase.hpp" 
+#include "../../src/memllib/synth/maximilian.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory> // Added for std::shared_ptr
+
+#include "../../src/memllib/interface/InterfaceBase.hpp" // Added missing include
+
+#include <span>
+
+#include "../../voicespaces/VoiceSpaces.hpp"
+
+
+
+template<size_t NPARAMS=33>
+
+class BreakOrAudioApp : public AudioAppBase<NPARAMS>
+{
+public:
+    static constexpr size_t kN_Params = NPARAMS;
+    static constexpr size_t nVoiceSpaces=0;
+
+    std::array<VoiceSpace<NPARAMS>, nVoiceSpaces> voiceSpaces;
+    
+    VoiceSpaceFn<NPARAMS> currentVoiceSpace;
+
+    std::array<String, nVoiceSpaces> getVoiceSpaceNames() {
+        std::array<String, nVoiceSpaces> names;
+        for(size_t i=0; i < voiceSpaces.size(); i++) {
+            names[i] = voiceSpaces[i].name;
+        }
+        return names;
+    }
+
+    void setVoiceSpace(size_t i) {
+        if (i < voiceSpaces.size()) {
+            currentVoiceSpace = voiceSpaces[i].mappingFunction;
+        }
+    }
+
+    BreakOrAudioApp() : AudioAppBase<NPARAMS>() {
+        // currentVoiceSpace = voiceSpaces[0].mappingFunction;   
+
+    };
+
+    bool __force_inline euclidean(float phase, const size_t n, const size_t k, const size_t offset, const float pulseWidth)
+    {
+        // Euclidean function
+        const float fi = phase * n;
+        int i = static_cast<int>(fi);
+        const float rem = fi - i;
+        if (i == n)
+        {
+            i--;
+        }
+        const int idx = ((i + n - offset) * k) % n;
+        return (idx < k && rem < pulseWidth) ? 1 : 0;
+    }
+
+    stereosample_t __force_inline Process(const stereosample_t x) override
+    {
+        stereosample_t ret { 0.f,0.f };
+        return ret;
+    }
+
+    void Setup(float sample_rate, std::shared_ptr<InterfaceBase> interface) override
+    {
+        AudioAppBase<NPARAMS>::Setup(sample_rate, interface);
+        maxiSettings::sampleRate = sample_rate;
+        sampleRatef = static_cast<float>(sample_rate);
+    }
+
+
+    void loop() override {
+        AudioAppBase<NPARAMS>::loop();
+    }
+
+    void ProcessParams(const std::array<float, NPARAMS>& params)
+    {
+        firstParamsReceived = true;
+        // currentVoiceSpace(params);
+    }
+
+    
+
+protected:
+
+    float sampleRatef;
+    bool firstParamsReceived = false;
+};
+
+#endif  // __BREAKOR_AUDIO_APP_HPP__
+

modes/MEMLNautModeBreakOr.hpp

@@ -0,0 +1,111 @@
+#ifndef MEMLNAUT_MODE_RHYTHM_BOX_HPP
+#define MEMLNAUT_MODE_RHYTHM_BOX_HPP
+
+//Break||
+
+#include "../src/memllib/interface/MIDIInOut.hpp"
+#include "../src/memllib/hardware/memlnaut/MEMLNaut.hpp"
+#include "AudioApps/BreakOrAudioApp.hpp"
+#include "../src/memllib/examples/InterfaceRL.hpp"
+#include "../src/memllib/PicoDefs.hpp"
+#include "MEMLNautMode.hpp"
+#include <memory>
+#include <array>
+
+class MEMLNautModeBreakOr {
+public:
+    constexpr static size_t kN_InputParams = 4; // joystick x, y, rotate
+
+    inline static BreakOrAudioApp<> audioAppBreakOr;
+    std::array<String, BreakOrAudioApp<>::nVoiceSpaces> voiceSpaceList;
+
+    InterfaceRL interface;
+    std::shared_ptr<InterfaceRL> interfacePtr;
+
+    void setupInterface() {
+        interface.setup(kN_InputParams, BreakOrAudioApp<>::kN_Params);
+        interface.bindInterface(InterfaceRL::INPUT_MODES::JOYSTICK, true);
+        interfacePtr = make_non_owning(interface);    
+    }
+
+    String getHelpTitle() {
+        return "Break||";
+    }
+
+    __force_inline stereosample_t process(stereosample_t x) {
+        return audioAppBreakOr.Process(x);
+    }
+
+    void setupAudio(float sample_rate) {
+        audioAppBreakOr.Setup(sample_rate, interfacePtr);
+        voiceSpaceList = audioAppBreakOr.getVoiceSpaceNames();
+    }
+
+    __force_inline void loop() {
+      audioAppBreakOr.loop();
+    }
+
+    std::shared_ptr<MIDIInOut> midi_interf;
+
+    void setupMIDI(std::shared_ptr<MIDIInOut> new_midi_interf) {
+      midi_interf = new_midi_interf;
+      midi_interf->Setup(16);
+      midi_interf->SetMIDISendChannel(1);
+      interface.bindMIDI(midi_interf);
+    }
+
+    void addViews() {
+        // std::shared_ptr<VoiceSpaceSelectView> voiceSpaceSelectView;
+        // voiceSpaceSelectView = std::make_shared<VoiceSpaceSelectView>("Voice Spaces");
+
+        // MEMLNaut::Instance()->disp->InsertViewAfter(interface.rlStatsView, voiceSpaceSelectView);
+        // voiceSpaceSelectView->setOptions(voiceSpaceList);  //set by core 1 on startup
+        // voiceSpaceSelectView->setNewVoiceCallback(
+        //     [this](size_t idx) {
+        //         audioAppPAFSynth.setVoiceSpace(idx);
+        //     });
+
+
+    };
+
+    inline void processAnalysisParams() {}
+
+    void analyse(stereosample_t) {}
+
+};
+
+
+/*
+    // BODY
+    Value result = Value::nil();
+
+    auto ratios           = args[0].as_sequential();
+    const auto pulseWidth = args[1].as_float();
+    const auto phase      = args[2].as_float();
+
+    double trig     = 0;
+    double ratioSum = 0;
+    for (Value v : ratios)
+    {
+        ratioSum += v.as_float();
+    }
+    double phaseAdj           = ratioSum * phase;
+    double accumulatedSum     = 0;
+    double lastAccumulatedSum = 0;
+    for (Value v : ratios)
+    {
+        accumulatedSum += v.as_float();
+        if (phaseAdj <= accumulatedSum)
+        {
+            // check pulse width
+            double beatPhase = (phaseAdj - lastAccumulatedSum) /
+                               (accumulatedSum - lastAccumulatedSum);
+            trig = beatPhase <= pulseWidth;
+            break;
+        }
+        lastAccumulatedSum = accumulatedSum;
+    }
+    result = Value(trig);
+*/
+
+#endif // MEMLNAUT_MODE_RHYTHM_BOX_HPP

modes/MEMLNautModeChannelStrip.hpp

@@ -26,17 +26,6 @@ public:
     String getHelpTitle() {
         return "Channel Strip Mode";
     }
-    // size_t getNParams() {
-    //     return ChannelStripAudioApp<>::kN_Params;
-    // }
-
-    // void setVoiceSpace(size_t i) {
-    //     audioAppChannelStrip.setVoiceSpace(i);
-    // }
-
-    // std::span<String> getVoiceSpaceList() {
-    //     return voiceSpaceList;
-    // }
 
     __force_inline stereosample_t process(stereosample_t x) {
         return audioAppChannelStrip.Process(x);

modes/MEMLNautModePAFSynth.hpp

@@ -29,17 +29,6 @@ public:
     String getHelpTitle() {
         return "PAF Synth Mode";
     }
-    // size_t getNParams() {
-    //     return PAFSynthAudioApp<>::kN_Params;
-    // }
-
-    // void setVoiceSpace(size_t i) {
-    //     audioAppPAFSynth.setVoiceSpace(i);
-    // }
-
-    // std::span<String> getVoiceSpaceList() {
-    //     return voiceSpaceList;
-    // }
 
     __force_inline stereosample_t process(stereosample_t x) {
         return audioAppPAFSynth.Process(x);

src/memllib

@@ -1 +1 @@
-Subproject commit 42a937b24d79ec962acf03b55090b022d47176df
+Subproject commit 5bae63daa89332f333ace163818b23308cdf3518

src/memlp

@@ -1 +1 @@
-Subproject commit bf52e8e279343312348a7056b538861cc81ef462
+Subproject commit 5d2935d6420f5e6ab0ad8321bab5125cce2fb500