v0.8.0: Filled waveform rendering, peak mipmaps, theme-aware slice UI

- Waveform renders as filled anti-aliased path instead of vertical lines
- Pre-computed 3-level peak mipmaps (64/512/4096 spp) for fast cache rebuilds
- Centre-line stroke in transition zone prevents waveform disappearing
- Max zoom increased from 2048x to 16384x
- Slice handles, labels, and lane numbers use theme foreground color

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: tucktuckg00se

README.md

@@ -24,7 +24,7 @@ A nondestructive, time-stretching, and intersecting sample slicer plugin with in
 - **Duplicate slice** — clone a slice with all its locked parameters
 - **Hi-DPI scaling** — adjustable UI scale factor (0.5x to 3x)
 - **Full state recall** — all parameters, slices, and audio data saved/restored with the DAW session
-- **Theming** — dark and light themes
+- **Custom theming** — dark, light, and custom theming
 
 ## Usage
 

src/PluginEditor.cpp

@@ -107,6 +107,7 @@ void IntersectEditor::timerCallback()
     {
         lastScale = scale;
         setTransform (juce::AffineTransform::scale (scale));
+        IntersectLookAndFeel::setMenuScale (scale);
         saveUserSettings (scale, getTheme().name);
     }
 

src/PluginProcessor.cpp

@@ -345,8 +345,7 @@ void IntersectProcessor::handleCommand (const Command& cmd)
                 // Build boundary list: [startS, ...positions..., endS]
                 std::vector<int> bounds;
                 bounds.push_back (startS);
-                for (int p : cmd.positions)
-                    bounds.push_back (p);
+                std::copy (cmd.positions.begin(), cmd.positions.end(), std::back_inserter (bounds));
                 bounds.push_back (endS);
 
                 int firstNew = -1;
@@ -393,7 +392,7 @@ void IntersectProcessor::handleCommand (const Command& cmd)
     }
 }
 
-void IntersectProcessor::processMidi (juce::MidiBuffer& midi)
+void IntersectProcessor::processMidi (const juce::MidiBuffer& midi)
 {
     for (const auto metadata : midi)
     {

src/PluginProcessor.h

@@ -125,7 +125,7 @@ class IntersectProcessor : public juce::AudioProcessor
 private:
     void drainCommands();
     void handleCommand (const Command& cmd);
-    void processMidi (juce::MidiBuffer& midi);
+    void processMidi (const juce::MidiBuffer& midi);
     void captureSnapshot();
     void restoreSnapshot (const UndoManager::Snapshot& snap);
 

src/audio/AudioAnalysis.h

@@ -3,6 +3,7 @@
 #include <vector>
 #include <cmath>
 #include <algorithm>
+#include <iterator>
 
 namespace AudioAnalysis
 {
@@ -101,9 +102,8 @@ inline std::vector<int> detectTransients (const juce::AudioBuffer<float>& buffer
     // sensitivity 1.0 -> low percentile (many detections)
     // sensitivity 0.0 -> high percentile (only biggest hits)
     std::vector<float> sorted;
-    for (float v : odf)
-        if (v > 0.0f)
-            sorted.push_back (v);
+    std::copy_if (odf.begin(), odf.end(), std::back_inserter (sorted),
+                  [] (float v) { return v > 0.0f; });
 
     if (sorted.empty())
         return onsets;

src/audio/SampleData.cpp

@@ -61,6 +61,7 @@ bool SampleData::loadFromFile (const juce::File& file, double projectSampleRate)
     loadedFileName = file.getFileName();
     loadedFilePath = file.getFullPathName();
     loaded = true;
+    buildMipmaps();
     return true;
 }
 
@@ -78,3 +79,48 @@ float SampleData::getInterpolatedSample (double pos, int channel) const
     auto* data = buffer.getReadPointer (channel);
     return data[ipos] + (data[ipos + 1] - data[ipos]) * frac;
 }
+
+void SampleData::buildMipmaps()
+{
+    int numFrames = buffer.getNumSamples();
+    if (numFrames <= 0)
+    {
+        for (auto& m : peakMipmaps)
+        {
+            m.samplesPerPeak = 0;
+            m.maxPeaks.clear();
+            m.minPeaks.clear();
+        }
+        return;
+    }
+
+    const float* dataL = buffer.getReadPointer (0);
+    const float* dataR = buffer.getNumChannels() > 1 ? buffer.getReadPointer (1) : dataL;
+
+    static constexpr int kBlockSizes[kNumMipmapLevels] = { 64, 512, 4096 };
+
+    for (int level = 0; level < kNumMipmapLevels; ++level)
+    {
+        auto& m = peakMipmaps[(size_t) level];
+        m.samplesPerPeak = kBlockSizes[level];
+        int numPeaks = (numFrames + m.samplesPerPeak - 1) / m.samplesPerPeak;
+        m.maxPeaks.resize ((size_t) numPeaks);
+        m.minPeaks.resize ((size_t) numPeaks);
+
+        for (int i = 0; i < numPeaks; ++i)
+        {
+            int start = i * m.samplesPerPeak;
+            int end = std::min (start + m.samplesPerPeak, numFrames);
+            float hi = -1.0f;
+            float lo = 1.0f;
+            for (int s = start; s < end; ++s)
+            {
+                float val = (dataL[s] + dataR[s]) * 0.5f;
+                if (val > hi) hi = val;
+                if (val < lo) lo = val;
+            }
+            m.maxPeaks[(size_t) i] = hi;
+            m.minPeaks[(size_t) i] = lo;
+        }
+    }
+}

src/audio/SampleData.h

@@ -1,10 +1,21 @@
 #pragma once
 #include <juce_audio_basics/juce_audio_basics.h>
 #include <juce_audio_formats/juce_audio_formats.h>
+#include <array>
+#include <vector>
 
 class SampleData
 {
 public:
+    struct PeakMipmap
+    {
+        int samplesPerPeak = 0;
+        std::vector<float> maxPeaks;
+        std::vector<float> minPeaks;
+    };
+
+    static constexpr int kNumMipmapLevels = 3;
+
     SampleData();
 
     bool loadFromFile (const juce::File& file, double projectSampleRate);
@@ -15,14 +26,19 @@ class SampleData
     bool isLoaded() const { return loaded; }
 
     const juce::AudioBuffer<float>& getBuffer() const { return buffer; }
+    const std::array<PeakMipmap, kNumMipmapLevels>& getMipmaps() const { return peakMipmaps; }
+
     const juce::String& getFileName() const { return loadedFileName; }
     void setFileName (const juce::String& name) { loadedFileName = name; }
 
     const juce::String& getFilePath() const { return loadedFilePath; }
     void setFilePath (const juce::String& path) { loadedFilePath = path; }
 
 private:
+    void buildMipmaps();
+
     juce::AudioBuffer<float> buffer;  // always stereo
+    std::array<PeakMipmap, kNumMipmapLevels> peakMipmaps;
     juce::AudioFormatManager formatManager;
     juce::String loadedFileName;
     juce::String loadedFilePath;

src/audio/VoicePool.cpp

@@ -7,6 +7,7 @@
 // Include Bungee
 #include "bungee/Bungee.h"
 
+#include <algorithm>
 #include <cmath>
 
 static constexpr int kStretchBlockSize = 128;
@@ -26,9 +27,10 @@ VoicePool::VoicePool()
 int VoicePool::allocate()
 {
     // First pass: find inactive voice within maxActive range
-    for (int i = 0; i < maxActive; ++i)
-        if (! voices[i].active)
-            return i;
+    auto it = std::find_if (voices.begin(), voices.begin() + maxActive,
+                            [] (const Voice& v) { return ! v.active; });
+    if (it != voices.begin() + maxActive)
+        return (int) std::distance (voices.begin(), it);
 
     // Second pass: steal — prefer releasing voices with lowest envelope
     int best = 0;

src/audio/VoicePool.h

@@ -31,8 +31,8 @@ class VoicePool
     void processSample (const SampleData& sample, double sampleRate,
                         float& outL, float& outR);
 
-    void processSampleMultiOut (const SampleData& sample, double sampleRate,
-                                float* outPtrs[], int numOuts);
+    static void processSampleMultiOut (const SampleData& sample, double sampleRate,
+                                      float* outPtrs[], int numOuts);
 
     void setSampleRate (double sr) { sampleRate = sr; }
     double getSampleRate() const { return sampleRate; }

src/ui/AutoChopPanel.cpp

@@ -3,6 +3,7 @@
 #include "WaveformView.h"
 #include "../PluginProcessor.h"
 #include "../audio/AudioAnalysis.h"
+#include <algorithm>
 
 AutoChopPanel::AutoChopPanel (IntersectProcessor& p, WaveformView& wv)
     : processor (p), waveformView (wv)
@@ -165,9 +166,9 @@ void AutoChopPanel::updatePreview()
 
     if (processor.snapToZeroCrossing.load())
     {
-        for (auto& p : positions)
-            p = AudioAnalysis::findNearestZeroCrossing (
-                processor.sampleData.getBuffer(), p);
+        std::transform (positions.begin(), positions.end(), positions.begin(),
+                        [this] (int p) { return AudioAnalysis::findNearestZeroCrossing (
+                            processor.sampleData.getBuffer(), p); });
     }
 
     waveformView.transientPreviewPositions = std::move (positions);