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

src/shell/instrument/editor_paint_waveform.cpp

@@ -0,0 +1,124 @@
+// editor_paint_waveform.cpp — the WAVEFORM band's painter: the channel lane(s), the loop
+// span + start/loop markers, and the amp-envelope overlay. Windows-only.
+//
+// Overlays that ride the waveform (the envelope trace, its node handles, the markers) draw
+// ONCE across the full band height, never per lane — the landed contract the stacked-lane
+// work consumes.
+
+#include "shell/instrument/reasampler_editor.h"
+
+#ifdef _WIN32
+
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+
+#include "core/audio/peaks.h"                   // computeEnvelope (waveform binning)
+#include "core/instrument/ui/sample_bands.h"    // waveformLanes (the band's lane inventory)
+#include "core/instrument/ui/waveform_view.h"   // frameToX (waveform markers)
+#include "shell/instrument/editor_internal.h"   // kit adapters
+#include "shell/instrument/reasampler_processor.h"
+
+namespace reasampler::vst {
+
+using namespace reasampler::ui;              // kit vocabulary
+using namespace reasampler::instrument::ui;  // lanes + waveform geometry
+using audio::computeEnvelope;
+
+namespace {
+// Marker roles — semantic, drawn through the kit's palette: start = teal (secondary), loop
+// start/end = purple (tertiary). The loop-span fill is a faint purple.
+constexpr Role kRoleStartMarker = Role::AccentSecondary;
+constexpr Role kRoleLoopMarker  = Role::AccentTertiary;
+}  // namespace
+
+void ReaSamplerEditor::paintWaveform(LICE_IBitmap* bmp, const Rect& band) {
+    fillSurface(bmp, toKitBox(band), Role::BgBase, InteractionState::Rest);
+    if (band.empty()) return;
+
+    const std::vector<AudioSample>& pcm = monoPcmFor(selectedId_);
+    const std::int64_t frames = static_cast<std::int64_t>(pcm.size());
+    if (frames <= 0) {
+        kitTextCentered(bmp, band, "(decoding...)", Font::Label, Role::TextDim);
+        return;
+    }
+
+    // One lane today: the cached PCM is a mono downmix, so there is no second channel to
+    // draw. The band is already sized for two, and the second lane lights up when the
+    // per-channel decode lands.
+    const WaveformLanes lanes = waveformLanes(band, /*stereo=*/false);
+    const Rect& lane = lanes.upper;
+    if (lane.width > 0) {
+        // Gap-free: one bin per drawn pixel column (kWaveformOversample == 1, so this
+        // multiplies by 1). The gap-free draw comes from peaks::columnMinMax's exact
+        // partition — extra bins produce no visible change. Clamped to frame count below.
+        const std::int64_t wantBins =
+            static_cast<std::int64_t>((std::max)(1, waveformColumnCount(toKitBox(lane)))) *
+            kWaveformOversample;
+        const std::size_t bins =
+            static_cast<std::size_t>(wantBins < frames ? wantBins : frames);
+        drawEnvelope(bmp, lane, computeEnvelope(pcm, 1, pcm.size(), bins));
+    }
+
+    // Markers and the loop span run the FULL band height (both lanes), so a stacked view
+    // reads one loop region rather than two.
+    const SetupMarkers m = pickedMarkers(frames);
+    if (m.hasLoop && m.loopEnd > m.loopStart) {
+        const int lx = frameToX(band, frames, m.loopStart);
+        const int rx = frameToX(band, frames, m.loopEnd);
+        if (rx > lx) {
+            LICE_FillRect(bmp, lx, band.y, rx - lx, band.height,
+                          toLice(roleColor(kRoleLoopMarker)), 0.20f, 0);
+        }
+    }
+    const std::int64_t markerFrames[3] = {m.start, m.loopStart, m.loopEnd};
+    const Role markerRoles[3] = {kRoleStartMarker, kRoleLoopMarker, kRoleLoopMarker};
+    for (int i = 0; i < 3; ++i) {
+        const int mx = frameToX(band, frames, markerFrames[i]);
+        const bool loopMarker = (i != 0);
+        const float alpha = (loopMarker && !m.hasLoop) ? 0.4f : 1.0f;
+        LICE_FillRect(bmp, mx - 1, band.y, 2, band.height,
+                      toLice(roleColor(markerRoles[i])), alpha, 0);
+    }
+
+    paintEnvelopeOverlay(bmp, band, frames);
+}
+
+void ReaSamplerEditor::paintEnvelopeOverlay(LICE_IBitmap* bmp, const Rect& waveArea,
+                                            std::int64_t frames) {
+    if (frames <= 0 || waveArea.width <= 0 || waveArea.height <= 0) return;
+    const double rate = liveSampleRate();
+    if (rate <= 0.0) return;
+    const double totalSeconds = static_cast<double>(frames) / rate;
+    const std::int64_t startFrame = params_.startPoint.value_or(0);
+    const AmpEnvelope env = packEnvelope(params_.play, frames, startFrame);
+    const std::vector<EnvVertex> poly = buildEnvelopePolyline(env, waveArea, totalSeconds);
+
+    // Trace the polyline in the categorical secondary accent (teal) so it reads as a distinct
+    // curve over the waveform. Clip x to the wave rect (a Gate release tail maps past the right).
+    const LICE_pixel line = toLice(roleColor(Role::AccentSecondary));
+    for (std::size_t i = 1; i < poly.size(); ++i) {
+        const int x0 = (std::max)(waveArea.x, (std::min)(waveArea.right() - 1, poly[i - 1].x));
+        const int x1 = (std::max)(waveArea.x, (std::min)(waveArea.right() - 1, poly[i].x));
+        LICE_Line(bmp, x0, poly[i - 1].y, x1, poly[i].y, line, 1.0f, 0, true);
+    }
+    // Draggable node handles: a small square per draggable node (Origin + ReleaseStart are
+    // draw-only). Lit accent-hot when this node is the grabbed one. Every vertex is
+    // guaranteed in-bounds (edge nodes like ReleaseEnd at area.right()-1 must get handles);
+    // the handle square is additionally clamped inside the band so a 6px box on an edge
+    // node never overhangs into the neighbouring bands.
+    const LICE_pixel handle = toLice(roleColor(Role::AccentPrimary));
+    const LICE_pixel handleHot = toLice(roleColor(Role::AccentHot));
+    for (const EnvVertex& v : poly) {
+        if (v.node == EnvNode::Origin || v.node == EnvNode::ReleaseStart) continue;
+        const bool grabbed = (drag_ == DragKind::kEnvNode && envNode_ == v.node);
+        const int r = 3;
+        const int hx = (std::max)(waveArea.x + r, (std::min)(waveArea.right() - 1 - r, v.x));
+        const int hy = (std::max)(waveArea.y + r, (std::min)(waveArea.bottom() - 1 - r, v.y));
+        LICE_FillRect(bmp, hx - r, hy - r, 2 * r, 2 * r, grabbed ? handleHot : handle, 1.0f, 0);
+    }
+}
+
+}  // namespace reasampler::vst
+
+#endif  // _WIN32