v0.6.0: Auto-chop with transient detection, undo/redo, UI polish

- Transient detection auto-chop with adjustable sensitivity and live preview
- AutoChopPanel overlay: sensitivity slider, equal divisions, detect transients
- Log-ratio onset detection with percentile threshold and peak-picking
- Snapshot-based undo/redo (UNDO/REDO buttons in header bar)
- Rename S -> ZX (snap-to-zero-crossing), M -> FM (follow MIDI)
- Remove unused SliceListPanel
- Move screenshot to .github/assets/, update README

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

Author: tucktuckg00se

docs/screenshot.png .github/assets/screenshot.pngdocs/screenshot.png renamed to .github/assets/screenshot.png

@@ -2,7 +2,7 @@
 
 A nondestructive, time-stretching, and intersecting sample slicer plugin with independent per-slice parameter control.
 
-![INTERSECT screenshot](docs/screenshot.png)
+![INTERSECT screenshot](.github/assets/screenshot.png)
 
 ## Features
 
@@ -14,13 +14,17 @@ A nondestructive, time-stretching, and intersecting sample slicer plugin with in
   - **Stretch** — independent pitch and time control via [Signalsmith Stretch](https://github.com/Signalsmith-Audio/signalsmith-stretch), with tonality, formant shift, and formant compensation controls
   - **Bungee** — grain-based time-stretch via [Bungee](https://github.com/bungee-audio-stretch/bungee), with adjustable grain mode (Fast / Normal / Smooth)
 - **Lazy chop** — play the sample continuously and place slice boundaries in real time by pressing MIDI keys
+- **Auto chop** — split slices equally (2-128 divisions) or detect transients with adjustable sensitivity and live preview
+- **Snap-to-zero-crossing** — click-free slice boundaries (ZX button)
+- **Undo/redo** — snapshot-based undo/redo for all slice and parameter changes
 - **SET BPM** — calculate BPM from a slice length and a musical time unit (4 bars down to 1/32 bar)
 - **Mute groups** — voices in the same group cut each other off
-- **MIDI-selects-slice** — optionally auto-select a slice in the UI when its MIDI note is played
+- **Follow MIDI** — optionally auto-select a slice in the UI when its MIDI note is played (FM button)
 - **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
+- **Theming** — dark and light themes
+
 ## Usage
 
 ### Getting Started
@@ -33,16 +37,26 @@ A nondestructive, time-stretching, and intersecting sample slicer plugin with in
 
 - **ADD** — click the button, then click and drag on the waveform to draw a slice region
 - **LAZY** — starts continuous playback; press any MIDI key to place a slice boundary at the current playhead. Click **STOP** when done. The final slice closes at the end of the sample
-- **AUTO** — splits the selected slice into equal parts (2-128 divisions)
+- **AUTO** — opens the Auto Chop panel over the waveform:
+  - **Sensitivity slider** (0-100%) — adjusts transient detection sensitivity with live preview lines on the waveform
+  - **Divisions field** — number of equal parts for time-based splitting (2-128)
+  - **Split Equal** — splits the selected slice into equal divisions
+  - **Detect Transients** — splits at detected transient positions
 - **COPY** — duplicates the selected slice with all its parameters
 - **DEL** — deletes the selected slice
 
 ### Editing Slices
 
 - Drag the **S** handle (left edge) or **E** handle (right edge) to resize a slice
 - Drag the middle of a slice to move it
-- Click a slice in the waveform, slice lane, or slice list to select it
-- Scroll wheel to zoom, shift+scroll or middle-drag to scroll
+- Click a slice in the waveform or slice lane to select it
+- Toggle **ZX** to snap slice edges to zero-crossings (eliminates clicks)
+
+### Keyboard / Mouse Shortcuts
+
+- **Scroll wheel** — zoom in/out (anchored to cursor position)
+- **Shift + scroll wheel** — scroll horizontally
+- **Middle-click drag** — simultaneous scroll (horizontal) and zoom (vertical)
 
 ### Sample Controls (top bar)
 
@@ -57,6 +71,7 @@ These are the defaults inherited by all slices:
 - **STRETCH** — enable time-stretching (syncs playback to DAW tempo)
 - **GAIN** — master gain in dB (-100 to +24 dB)
 - **TAIL** — release tail — when enabled, audio continues reading past the slice boundary during the release phase
+- **<** / **>** — undo / redo
 
 ### Slice Controls (second bar)
 
@@ -66,9 +81,9 @@ Per-slice overrides. Each parameter has a **lock icon** — click it to override
 
 Calculates BPM from a slice's length. Select a slice, click **SET BPM**, and choose a time division (4 bars, 1 bar, 1/4 note, etc.). INTERSECT sets the BPM so that slice equals the chosen duration at your DAW's tempo.
 
-### MIDI-Selects-Slice
+### Follow MIDI
 
-Click the **M** button to toggle. When active, playing a MIDI note automatically selects that slice in the UI.
+Click the **FM** button to toggle. When active, playing a MIDI note automatically selects that slice in the UI.
 
 ## Install
 

README.md

@@ -82,6 +82,7 @@ target_sources(Intersect PRIVATE
     src/ui/ScrollZoomBar.cpp
     src/ui/SliceLane.cpp
     src/ui/ActionPanel.cpp
+    src/ui/AutoChopPanel.cpp
 )
 
 target_include_directories(Intersect PRIVATE

project/CMakeLists.txt

@@ -1,6 +1,7 @@
 #include "PluginProcessor.h"
 #include "PluginEditor.h"
 #include "audio/GrainEngine.h"
+#include "audio/AudioAnalysis.h"
 
 IntersectProcessor::IntersectProcessor()
     : AudioProcessor (BusesProperties()
@@ -90,8 +91,51 @@ void IntersectProcessor::drainCommands()
         updateHostDisplay (ChangeDetails().withNonParameterStateChanged (true));
 }
 
+void IntersectProcessor::captureSnapshot()
+{
+    UndoManager::Snapshot snap;
+    for (int i = 0; i < SliceManager::kMaxSlices; ++i)
+        snap.slices[(size_t) i] = sliceManager.getSlice (i);
+    snap.numSlices = sliceManager.getNumSlices();
+    snap.selectedSlice = sliceManager.selectedSlice;
+    snap.rootNote = sliceManager.rootNote.load();
+    snap.apvtsState = apvts.copyState();
+    snap.midiSelectsSlice = midiSelectsSlice.load();
+    snap.snapToZeroCrossing = snapToZeroCrossing.load();
+    undoMgr.push (snap);
+}
+
+void IntersectProcessor::restoreSnapshot (const UndoManager::Snapshot& snap)
+{
+    for (int i = 0; i < SliceManager::kMaxSlices; ++i)
+        sliceManager.getSlice (i) = snap.slices[(size_t) i];
+    sliceManager.setNumSlices (snap.numSlices);
+    sliceManager.selectedSlice = snap.selectedSlice;
+    sliceManager.rootNote.store (snap.rootNote);
+    apvts.replaceState (snap.apvtsState);
+    midiSelectsSlice.store (snap.midiSelectsSlice);
+    snapToZeroCrossing.store (snap.snapToZeroCrossing);
+    sliceManager.rebuildMidiMap();
+}
+
 void IntersectProcessor::handleCommand (const Command& cmd)
 {
+    // Capture snapshot before modifying commands (not for load/relink/lazychop/undo/redo/none)
+    switch (cmd.type)
+    {
+        case CmdNone:
+        case CmdLoadFile:
+        case CmdRelinkFile:
+        case CmdLazyChopStart:
+        case CmdLazyChopStop:
+        case CmdUndo:
+        case CmdRedo:
+            break;
+        default:
+            captureSnapshot();
+            break;
+    }
+
     switch (cmd.type)
     {
         case CmdLoadFile:
@@ -136,7 +180,8 @@ void IntersectProcessor::handleCommand (const Command& cmd)
                 psp.grainMode      = (int) grainModeParam->load();
                 psp.sampleRate     = currentSampleRate;
                 psp.sample         = &sampleData;
-                lazyChop.start (sampleData.getNumFrames(), sliceManager, psp);
+                lazyChop.start (sampleData.getNumFrames(), sliceManager, psp,
+                                snapToZeroCrossing.load(), &sampleData.getBuffer());
             }
             break;
 
@@ -259,11 +304,21 @@ void IntersectProcessor::handleCommand (const Command& cmd)
 
                 sliceManager.deleteSlice (sel);
 
+                bool doSnap = snapToZeroCrossing.load() && sampleData.isLoaded();
                 int firstNew = -1;
                 for (int i = 0; i < count; ++i)
                 {
                     int s = startS + i * len / count;
                     int e = startS + (i + 1) * len / count;
+                    // Snap interior boundaries (not first start / last end)
+                    if (doSnap)
+                    {
+                        if (i > 0)
+                            s = AudioAnalysis::findNearestZeroCrossing (sampleData.getBuffer(), s);
+                        if (i < count - 1)
+                            e = AudioAnalysis::findNearestZeroCrossing (sampleData.getBuffer(), e);
+                    }
+                    if (e - s < 64) e = s + 64;
                     int idx = sliceManager.createSlice (s, e);
                     if (i == 0) firstNew = idx;
                 }
@@ -275,6 +330,41 @@ void IntersectProcessor::handleCommand (const Command& cmd)
             break;
         }
 
+        case CmdTransientChop:
+        {
+            int sel = sliceManager.selectedSlice;
+            if (sel >= 0 && sel < sliceManager.getNumSlices() && ! cmd.positions.empty())
+            {
+                const auto& src = sliceManager.getSlice (sel);
+                int startS = src.startSample;
+                int endS = src.endSample;
+
+                sliceManager.deleteSlice (sel);
+
+                // Build boundary list: [startS, ...positions..., endS]
+                std::vector<int> bounds;
+                bounds.push_back (startS);
+                for (int p : cmd.positions)
+                    bounds.push_back (p);
+                bounds.push_back (endS);
+
+                int firstNew = -1;
+                for (size_t i = 0; i + 1 < bounds.size(); ++i)
+                {
+                    int s = bounds[i];
+                    int e = bounds[i + 1];
+                    if (e - s < 64) continue;
+                    int idx = sliceManager.createSlice (s, e);
+                    if (firstNew < 0) firstNew = idx;
+                }
+
+                sliceManager.rebuildMidiMap();
+                if (firstNew >= 0)
+                    sliceManager.selectedSlice = firstNew;
+            }
+            break;
+        }
+
         case CmdRelinkFile:
             if (sampleData.loadFromFile (cmd.fileParam, currentSampleRate))
             {
@@ -284,6 +374,16 @@ void IntersectProcessor::handleCommand (const Command& cmd)
             }
             break;
 
+        case CmdUndo:
+            if (undoMgr.canUndo())
+                restoreSnapshot (undoMgr.undo());
+            break;
+
+        case CmdRedo:
+            if (undoMgr.canRedo())
+                restoreSnapshot (undoMgr.redo());
+            break;
+
         case CmdNone:
             break;
     }
@@ -454,7 +554,7 @@ void IntersectProcessor::getStateInformation (juce::MemoryBlock& destData)
     juce::MemoryOutputStream stream (destData, false);
 
     // Version
-    stream.writeInt (11);
+    stream.writeInt (12);
 
     // APVTS state
     auto state = apvts.copyState();
@@ -509,14 +609,17 @@ void IntersectProcessor::getStateInformation (juce::MemoryBlock& destData)
     // v9: store file path only (no PCM)
     stream.writeString (sampleData.getFilePath());
     stream.writeString (sampleData.getFileName());
+
+    // v12: snap-to-zero-crossing toggle
+    stream.writeBool (snapToZeroCrossing.load());
 }
 
 void IntersectProcessor::setStateInformation (const void* data, int sizeInBytes)
 {
     juce::MemoryInputStream stream (data, (size_t) sizeInBytes, false);
 
     int version = stream.readInt();
-    if (version < 9 || version > 11)
+    if (version < 9 || version > 12)
         return;
 
     // APVTS state
@@ -621,6 +724,12 @@ void IntersectProcessor::setStateInformation (const void* data, int sizeInBytes)
     }
 
     sliceManager.rebuildMidiMap();
+
+    // v12: snap-to-zero-crossing
+    if (version >= 12)
+        snapToZeroCrossing.store (stream.readBool());
+    else
+        snapToZeroCrossing.store (false);
 }
 
 juce::AudioProcessor* JUCE_CALLTYPE createPluginFilter()

project/src/PluginProcessor.cpp

@@ -1,9 +1,11 @@
 #pragma once
 #include <juce_audio_processors/juce_audio_processors.h>
+#include <vector>
 #include "audio/SampleData.h"
 #include "audio/SliceManager.h"
 #include "audio/VoicePool.h"
 #include "audio/LazyChopEngine.h"
+#include "UndoManager.h"
 #include "params/ParamIds.h"
 #include "params/ParamLayout.h"
 
@@ -49,7 +51,10 @@ class IntersectProcessor : public juce::AudioProcessor
         CmdSetSliceParam,
         CmdDuplicateSlice,
         CmdSplitSlice,
+        CmdTransientChop,
         CmdRelinkFile,
+        CmdUndo,
+        CmdRedo,
     };
 
     // Param field identifiers for CmdSetSliceParam
@@ -83,6 +88,7 @@ class IntersectProcessor : public juce::AudioProcessor
         int intParam2 = 0;
         float floatParam1 = 0.0f;
         juce::File fileParam;
+        std::vector<int> positions;
     };
 
     void pushCommand (Command cmd);
@@ -105,6 +111,12 @@ class IntersectProcessor : public juce::AudioProcessor
     // MIDI-selects-slice toggle
     std::atomic<bool> midiSelectsSlice { false };
 
+    // Snap-to-zero-crossing toggle
+    std::atomic<bool> snapToZeroCrossing { false };
+
+    // Undo/redo
+    UndoManager undoMgr;
+
     // Missing sample state (for relink UI)
     std::atomic<bool> sampleMissing { false };
     juce::String missingFilePath;
@@ -113,6 +125,8 @@ class IntersectProcessor : public juce::AudioProcessor
     void drainCommands();
     void handleCommand (const Command& cmd);
     void processMidi (juce::MidiBuffer& midi);
+    void captureSnapshot();
+    void restoreSnapshot (const UndoManager::Snapshot& snap);
 
     // Command FIFO
     static constexpr int kFifoSize = 64;

project/src/PluginProcessor.h

@@ -0,0 +1,65 @@
+#pragma once
+#include <deque>
+#include <juce_data_structures/juce_data_structures.h>
+#include "audio/Slice.h"
+#include "audio/SliceManager.h"
+
+class UndoManager
+{
+public:
+    static constexpr int kMaxSnapshots = 32;
+
+    struct Snapshot
+    {
+        std::array<Slice, SliceManager::kMaxSlices> slices;
+        int numSlices = 0;
+        int selectedSlice = -1;
+        int rootNote = 36;
+        juce::ValueTree apvtsState;
+        bool midiSelectsSlice = false;
+        bool snapToZeroCrossing = false;
+    };
+
+    void push (const Snapshot& snap)
+    {
+        // Discard any redo history
+        while (undoStack.size() > pos)
+            undoStack.pop_back();
+
+        undoStack.push_back (snap);
+
+        // Enforce max size
+        while ((int) undoStack.size() > kMaxSnapshots)
+            undoStack.pop_front();
+
+        pos = (int) undoStack.size();
+    }
+
+    bool canUndo() const { return pos > 0; }
+    bool canRedo() const { return pos < (int) undoStack.size(); }
+
+    // Returns the snapshot to restore (the state before the last change)
+    Snapshot undo()
+    {
+        if (pos > 0)
+            --pos;
+        return undoStack[(size_t) pos];
+    }
+
+    Snapshot redo()
+    {
+        if (pos < (int) undoStack.size())
+            ++pos;
+        return undoStack[(size_t) pos - 1];
+    }
+
+    void clear()
+    {
+        undoStack.clear();
+        pos = 0;
+    }
+
+private:
+    std::deque<Snapshot> undoStack;
+    int pos = 0;  // position after the last pushed snapshot
+};