Retire the zone system: one capture = one parameter set, and re-seam the engine and Sample face into bands

src/shell/instrument/editor_input_waveform.cpp

@@ -0,0 +1,124 @@
+// editor_input_waveform.cpp — the WAVEFORM band's input: grabbing an envelope node or a
+// start/loop marker, and resolving both drags live against the pure inverse maps
+// (envelope_edit, waveform_view). Windows-only.
+
+#include "shell/instrument/reasampler_editor.h"
+
+#ifdef _WIN32
+
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+
+#include "core/instrument/ui/envelope_edit.h"   // nodeAtPoint / resolveNodeDrag
+#include "core/instrument/ui/waveform_view.h"   // markerAtPoint / resolveDragFrame / snap
+#include "shell/instrument/editor_internal.h"
+#include "shell/instrument/reasampler_processor.h"
+
+namespace reasampler::vst {
+
+using namespace reasampler::ui;
+using namespace reasampler::instrument::ui;
+
+bool ReaSamplerEditor::mouseDownWaveform(const FaceLayout& fl, int x, int y) {
+    const Rect& band = fl.bands.waveform;
+    const std::vector<AudioSample>& pcm = monoPcmFor(selectedId_);
+    const std::int64_t frames = static_cast<std::int64_t>(pcm.size());
+    if (frames <= 0) return false;
+
+    // Envelope nodes first (they sit on top of the markers), then the wave markers.
+    const double rate = liveSampleRate();
+    if (rate > 0.0) {
+        const std::int64_t startFrame = params_.startPoint.value_or(0);
+        const AmpEnvelope env = packEnvelope(params_.play, frames, startFrame);
+        const double totalSeconds = static_cast<double>(frames) / rate;
+        const NodeHit nh = nodeAtPoint(env, band, totalSeconds, x, y);
+        if (nh.hit) {
+            drag_ = DragKind::kEnvNode;
+            envNode_ = nh.node;
+            dragStartX_ = x;
+            dragStartY_ = y;
+            dragStartEnv_ = env;
+            dragSampleFrames_ = frames;
+            dragStartFrame_ = startFrame;
+            dragStartParams_ = params_;
+            return true;  // node moves once the cursor drags
+        }
+    }
+    const SetupMarkers m = pickedMarkers(frames);
+    const std::int64_t markerFrames[3] = {m.start, m.loopStart, m.loopEnd};
+    const int hit = markerAtPoint(band, frames, markerFrames, 3, x, y);
+    if (hit >= 0) {
+        drag_ = DragKind::kWaveMarker;
+        waveMarker_ = static_cast<WaveMarker>(hit);
+        dragStartX_ = x;
+        dragStartMarkers_ = m;
+        dragSampleFrames_ = frames;
+        dragStartParams_ = params_;
+        return true;
+    }
+    return false;
+}
+
+void ReaSamplerEditor::dragWaveform(const FaceLayout& fl, int x, int y) {
+    const Rect& band = fl.bands.waveform;
+    const int dx = x - dragStartX_;
+
+    if (drag_ == DragKind::kEnvNode) {
+        // Resolve the grabbed envelope node's new params from the pixel delta (through the
+        // pure envelope_edit inverse map, clamped + monotonic), then unpack them back onto
+        // the parameter set. The AmpEnvelope was snapshotted at grab (dragStartEnv_) so the
+        // delta is absolute.
+        const std::int64_t frames = dragSampleFrames_;
+        const double rate = liveSampleRate();
+        if (frames <= 0 || rate <= 0.0) return;
+        const double totalSeconds = static_cast<double>(frames) / rate;
+        const AmpEnvelope edited = resolveNodeDrag(dragStartEnv_, envNode_, band, totalSeconds,
+                                                   envClampBounds(), dx, y - dragStartY_);
+        unpackEnvelope(edited, frames, dragStartFrame_, params_.play);
+        invalidate();  // live feedback; commit on WM_LBUTTONUP
+        return;
+    }
+
+    // kWaveMarker: resolve the grabbed marker's new frame from the pixel delta,
+    // zero-crossing-snap it against the decoded PCM, apply the inter-marker clamps, and write
+    // the override live.
+    const std::int64_t frames = dragSampleFrames_;
+    if (frames <= 0) return;
+
+    // Grabbed frame at grab time, from the snapshot (so the delta is measured from grab).
+    const int idx = static_cast<int>(waveMarker_);
+    const std::int64_t startVals[3] = {dragStartMarkers_.start, dragStartMarkers_.loopStart,
+                                       dragStartMarkers_.loopEnd};
+    std::int64_t newFrame = resolveDragFrame(band, frames, startVals[idx], dx);
+
+    // Snap to the nearest zero crossing in the decoded PCM. Pure over the cached mono
+    // frames — no host types, no file I/O.
+    const std::vector<AudioSample>& pcm = monoPcmFor(selectedId_);
+    if (!pcm.empty()) {
+        newFrame = nearestZeroCrossing(pcm.data(), static_cast<std::int64_t>(pcm.size()),
+                                       newFrame);
+    }
+
+    // Build the edited marker set from the snapshot, moving only the grabbed marker, then
+    // clamp: loopStart <= loopEnd, start in [0, frames-1]. Dragging a loop marker MAKES a loop.
+    SetupMarkers m = dragStartMarkers_;
+    if (waveMarker_ == WaveMarker::kStart) {
+        m.start = newFrame;
+    } else if (waveMarker_ == WaveMarker::kLoopStart) {
+        m.loopStart = (std::min)(newFrame, m.loopEnd);
+        m.hasLoop = true;
+    } else {  // kLoopEnd
+        m.loopEnd = (std::max)(newFrame, m.loopStart);
+        m.hasLoop = true;
+    }
+    if (m.start < 0) m.start = 0;
+    if (m.start > frames - 1) m.start = frames - 1;
+
+    applyMarkers(m);
+    invalidate();  // live feedback; the commit lands on release
+}
+
+}  // namespace reasampler::vst
+
+#endif  // _WIN32