Update Scale and Arpeggiator

Author: odoare

Arpeggiator.h

@@ -88,14 +88,6 @@ class Arpeggiator
     */
     juce::MidiBuffer processBlock(int numSamples)
     {
-        // std::cout << "In Arpeggiator::processBlock()" << std::endl;
-        // std::cout << "samplesPerNote = " << samplesPerNote << std::endl;        
-        // std::cout << "samplesUntilNextNote = " << samplesUntilNextNote << std::endl;
-
-        // std::cout << "numSamples = " << numSamples << std::endl;
-        // std::cout << "pattern = " << pattern << std::endl;
-        // std::cout << "sampleRate = " << sampleRate << std::endl;
-        
         juce::MidiBuffer generatedMidi;
         if (sampleRate <= 0.0 || samplesPerNote <= 0.0 || pattern.isEmpty())
             return generatedMidi;
@@ -161,16 +153,20 @@ class Arpeggiator
                 char octaveCommand = pattern[pos];
                 pos = (pos + 1) % pattern.length(); // Consume octave command
 
-                // Start with the current global octave to calculate the new value.
-                int targetOctave = octave;
+                // Determine the starting point for this calculation.
+                // If a local octave is already set for this step, use it. Otherwise, use the global octave.
+                int currentStepOctave = (localOctave != -1) ? localOctave : octave;
+                int targetOctave = currentStepOctave;
 
                 if (octaveCommand == '+')
-                    targetOctave = juce::jmin(7, octave + 1);
+                    targetOctave = juce::jmin(7, currentStepOctave + 1);
                 else if (octaveCommand == '-')
-                    targetOctave = juce::jmax(0, octave - 1);
+                    targetOctave = juce::jmax(0, currentStepOctave - 1);
                 else if (juce::CharacterFunctions::isDigit(octaveCommand))
                     targetOctave = octaveCommand - '0'; // Correctly convert char '0'-'7' to int 0-7
 
+                // For both 'o' and 'O', we first set the localOctave for the current step's parsing.
+                // If it's 'O', we'll also promote it to the global octave later.
                 if (command == 'o')
                     localOctave = targetOctave;
                 else // 'O'
@@ -584,6 +580,8 @@ class Arpeggiator
             case 5: return 6.0;  // 1/16T
             case 6: return 8.0;  // 1/32
             case 7: return 12.0; // 1/32T
+            case 8: return 16.0; // 1/64
+            case 9: return 24.0; // 1/64T
             default: return 4.0;
         }
     }

MidiTools.h

@@ -48,10 +48,36 @@ namespace MidiTools
         /** The available scale types. */
         enum class Type
         {
+            // Major Scale Modes
             Major,
+            Dorian,
+            Phrygian,
+            Lydian,
+            Mixolydian,
+            Aeolian,
+            Locrian,
+            // Melodic Minor Modes
             MelodicMinor,
+            Dorianb9,
+            LydianSharp5,
+            Lydianb7, // Previously Bartok
+            Mixolydianb13,
+            LocrianNatural9,
+            Altered,
+            // Harmonic Minor Modes
             HarmonicMinor,
-            Bartok
+            LocrianNatural6,
+            IonianSharp5,
+            DorianSharp4,
+            PhrygianDominant,
+            LydianSharp2,
+            Altered_bb7,
+            // Other 7-note scales
+            HarmonicMajor,
+            DoubleHarmonicMajor,
+            HungarianMinor,
+            NeapolitanMajor,
+            NeapolitanMinor
         };
 
         /**
@@ -88,14 +114,75 @@ namespace MidiTools
             return notes;
         }
 
+        /** Returns an ordered list of names for all available scale types. */
+        static const juce::StringArray& getScaleTypeNames()
+        {
+            static const juce::StringArray names = {
+                // Major Scale Modes
+                "Major (Ionian)",
+                "Dorian",
+                "Phrygian",
+                "Lydian",
+                "Mixolydian",
+                "Aeolian",
+                "Locrian",
+                // Melodic Minor Modes
+                "Melodic Minor",
+                "Dorian b9",
+                "Lydian #5",
+                "Lydian b7 (Bartok)",
+                "Mixolydian b13",
+                "Locrian Natural 9",
+                "Altered",
+                // Harmonic Minor Modes
+                "Harmonic Minor",
+                "Locrian Natural 6",
+                "Ionian #5",
+                "Dorian #4",
+                "Phrygian Dominant",
+                "Lydian #2",
+                "Altered bb7 (Ultralocrian)",
+                // Other 7-note scales
+                "Harmonic Major",
+                "Double Harmonic Major",
+                "Hungarian Minor",
+                "Neapolitan Major",
+                "Neapolitan Minor"
+            };
+            return names;
+        }
+
     private:
         void buildScale(int rootSemitone, Type scaleType)
         {
             static const std::map<Type, juce::Array<int>> scaleIntervals = {
-                {Type::Major,         {0, 2, 4, 5, 7, 9, 11}},
-                {Type::MelodicMinor,  {0, 2, 3, 5, 7, 9, 11}},
-                {Type::HarmonicMinor, {0, 2, 3, 5, 7, 8, 11}},
-                {Type::Bartok,        {0, 2, 4, 6, 7, 9, 10}} // Lydian Dominant
+                {Type::Major,           {0, 2, 4, 5, 7, 9, 11}}, // Ionian
+                {Type::Dorian,          {0, 2, 3, 5, 7, 9, 10}},
+                {Type::Phrygian,        {0, 1, 3, 5, 7, 8, 10}},
+                {Type::Lydian,          {0, 2, 4, 6, 7, 9, 11}},
+                {Type::Mixolydian,      {0, 2, 4, 5, 7, 9, 10}},
+                {Type::Aeolian,         {0, 2, 3, 5, 7, 8, 10}},
+                {Type::Locrian,         {0, 1, 3, 5, 6, 8, 10}},
+                {Type::MelodicMinor,    {0, 2, 3, 5, 7, 9, 11}},
+                {Type::Dorianb9,        {0, 1, 3, 5, 7, 9, 10}},
+                {Type::LydianSharp5,    {0, 2, 4, 6, 8, 9, 11}},
+                {Type::Lydianb7,        {0, 2, 4, 6, 7, 9, 10}}, // Bartok / Lydian Dominant
+                {Type::Mixolydianb13,   {0, 2, 4, 5, 7, 8, 10}},
+                {Type::LocrianNatural9, {0, 2, 3, 5, 6, 8, 10}},
+                {Type::Altered,         {0, 1, 3, 4, 6, 8, 10}},
+                {Type::HarmonicMinor,   {0, 2, 3, 5, 7, 8, 11}},
+                {Type::LocrianNatural6, {0, 1, 3, 5, 6, 9, 10}},
+                {Type::IonianSharp5,    {0, 2, 4, 5, 8, 9, 11}},
+                {Type::DorianSharp4,    {0, 2, 3, 6, 7, 9, 10}},
+                {Type::PhrygianDominant,{0, 1, 4, 5, 7, 8, 10}},
+                {Type::LydianSharp2,    {0, 3, 4, 6, 7, 9, 11}},
+                {Type::Altered_bb7,     {0, 1, 3, 4, 6, 8, 9}},
+                // Other 7-note scales
+                {Type::HarmonicMajor,       {0, 2, 4, 5, 7, 8, 11}},
+                {Type::DoubleHarmonicMajor, {0, 1, 4, 5, 7, 8, 11}},
+                {Type::HungarianMinor,      {0, 2, 3, 6, 7, 8, 11}},
+                {Type::NeapolitanMajor,     {0, 1, 4, 5, 7, 9, 11}},
+                {Type::NeapolitanMinor,     {0, 1, 3, 5, 7, 8, 11}}
             };
 
             const auto& intervals = scaleIntervals.at(scaleType);