From d5d1902ea4b43521fffa83f6ad07638e01f648fd Mon Sep 17 00:00:00 2001 From: daniel-c-harvey Date: Mon, 27 Jul 2026 18:25:03 -0400 Subject: [PATCH 1/2] FA2: bounded-schematic Gate envelope (15% sustain reserve, in-bounds release) + zero-fade-out grabbable via nearest-node hit-test; all nodes clamp in-canvas --- src/vst/envelope_edit.cpp | 41 ++++++-- src/vst/envelope_edit.h | 17 +++- src/vst/envelope_overlay.cpp | 63 ++++++++---- src/vst/envelope_overlay.h | 99 ++++++++++++------ tests/test_envelope_edit.cpp | 121 +++++++++++++++++----- tests/test_envelope_overlay.cpp | 172 ++++++++++++++++++++++++++------ 6 files changed, 392 insertions(+), 121 deletions(-) diff --git a/src/vst/envelope_edit.cpp b/src/vst/envelope_edit.cpp index a8f3e55..96e06e1 100644 --- a/src/vst/envelope_edit.cpp +++ b/src/vst/envelope_edit.cpp @@ -23,6 +23,15 @@ double secondsPerPixel(const Rect& area, double totalSeconds) { return totalSeconds / static_cast(w); } +// Seconds per pixel in the GATE timed region (FA2): the Gate schematic maps A/H/D/R onto +// gateTimedWidth(area) px, not the full canvas, so a Gate time-node drag must use this scale for +// the handle to track the cursor. Matches envelope_overlay::gatePolyline. +double gateSecondsPerPixel(const Rect& area, double totalSeconds) { + const int w = gateTimedWidth(area); + if (w <= 0 || totalSeconds <= 0.0) return 0.0; + return totalSeconds / static_cast(w); +} + // Level (0..1) represented by one vertical pixel. levelToY spans (height-1) rows for [0,1], so one // pixel is 1/(height-1). Zero when degenerate. Matches envelope_overlay::levelToY. double levelPerPixel(const Rect& area) { @@ -46,14 +55,23 @@ bool isDraggable(EnvNode n) { NodeHit nodeAtPoint(const AmpEnvelope& env, const Rect& area, double totalSeconds, int x, int y) { const std::vector poly = buildEnvelopePolyline(env, area, totalSeconds); - // First-match in draw order (deterministic tie-break), skipping non-draggable anchors. + // NEAREST draggable node within the pick radius wins (Chebyshev distance — the square grab + // box); ties break to the earlier draw-order node (FA2). Nearest-wins keeps every handle + // grabbable when nodes sit close (e.g. a short hold), while the draw-order tie-break makes + // exactly-coincident nodes deterministic: at zero fade-out, FadeOutStart overlays LengthEnd + // and WINS the tie, so the fade-out handle is grabbable at the right edge and can be dragged + // inward from zero. + NodeHit best; + int bestDist = kNodeGrabRadius + 1; for (const EnvVertex& v : poly) { if (!isDraggable(v.node)) continue; - if (std::abs(x - v.x) <= kNodeGrabRadius && std::abs(y - v.y) <= kNodeGrabRadius) { - return NodeHit{true, v.node}; + const int dist = std::max(std::abs(x - v.x), std::abs(y - v.y)); + if (dist < bestDist) { // strictly closer only: earlier draw order keeps ties + bestDist = dist; + best = NodeHit{true, v.node}; } } - return NodeHit{false, EnvNode::Origin}; + return best; } AmpEnvelope resolveNodeDrag(const AmpEnvelope& grabEnv, EnvNode node, const Rect& area, @@ -65,21 +83,28 @@ AmpEnvelope resolveNodeDrag(const AmpEnvelope& grabEnv, EnvNode node, const Rect const double secPerPx = secondsPerPixel(area, totalSeconds); if (secPerPx <= 0.0) return out; // degenerate area / duration — no motion const double dSec = static_cast(dxPixels) * secPerPx; + // Gate time nodes live in the TIMED region of the Gate schematic (FA2), which is narrower + // than the canvas by the sustain-plateau reserve — their px->seconds scale differs so the + // dragged handle tracks the cursor 1:1. gateTimedWidth >= 1 whenever the area is non-empty, + // so gateDSec is well-defined past the degenerate guard above. + const double gateDSec = + static_cast(dxPixels) * gateSecondsPerPixel(area, totalSeconds); switch (node) { // --- Gate: each cumulative-time node edits its OWN segment duration. Non-negative // durations ARE the monotonic-in-time guarantee (a node can never cross a neighbour // because every segment stays >= 0), so the [0, max] clamp is the whole constraint. case EnvNode::AttackEnd: - out.attackSeconds = clamp(grabEnv.attackSeconds + dSec, 0.0, bounds.maxAttackSeconds); + out.attackSeconds = + clamp(grabEnv.attackSeconds + gateDSec, 0.0, bounds.maxAttackSeconds); break; case EnvNode::HoldEnd: - out.holdSeconds = clamp(grabEnv.holdSeconds + dSec, 0.0, bounds.maxHoldSeconds); + out.holdSeconds = clamp(grabEnv.holdSeconds + gateDSec, 0.0, bounds.maxHoldSeconds); break; case EnvNode::DecayEnd: { // Sustain node: X sets decay time, Y sets sustain level (drag DOWN = higher y = lower // level, so subtract the level delta). - out.decaySeconds = clamp(grabEnv.decaySeconds + dSec, 0.0, bounds.maxDecaySeconds); + out.decaySeconds = clamp(grabEnv.decaySeconds + gateDSec, 0.0, bounds.maxDecaySeconds); const double lvlPerPx = levelPerPixel(area); const double dLevel = -static_cast(dyPixels) * lvlPerPx; out.sustainLevel = clamp(grabEnv.sustainLevel + dLevel, 0.0, 1.0); @@ -87,7 +112,7 @@ AmpEnvelope resolveNodeDrag(const AmpEnvelope& grabEnv, EnvNode node, const Rect } case EnvNode::ReleaseEnd: out.releaseSeconds = - clamp(grabEnv.releaseSeconds + dSec, 0.0, bounds.maxReleaseSeconds); + clamp(grabEnv.releaseSeconds + gateDSec, 0.0, bounds.maxReleaseSeconds); break; // --- Trigger: fades + length are FRACTIONS. X pixels convert to a fraction of the PLAYED diff --git a/src/vst/envelope_edit.h b/src/vst/envelope_edit.h index 1b26351..63c261c 100644 --- a/src/vst/envelope_edit.h +++ b/src/vst/envelope_edit.h @@ -20,11 +20,16 @@ // CALLER-SUPPLIED here (EnvClampBounds): the shell passes the same maxima it feeds the slider, // so the two surfaces share one clamp by construction. // -// WHICH AXES. Time-only nodes (attack-end, hold-end, release-end; fade-in-end, length-end, -// fade-out-end) drag on X only. The sustain node (DecayEnd) drags on BOTH axes — its X sets the +// WHICH AXES. Time-only nodes (AttackEnd, HoldEnd, ReleaseEnd; FadeInEnd, FadeOutStart, +// LengthEnd) drag on X only. The sustain node (DecayEnd) drags on BOTH axes — its X sets the // decay time, its Y sets the sustain level (the standard ADSR-editor grammar). Origin and the // drawing-only ReleaseStart vertex are NOT draggable. // +// GATE DRAG SCALE (FA2). Gate time nodes live in the Gate schematic's TIMED region +// (gateTimedWidth(area) px — the canvas minus the sustain-plateau reserve), so their px->seconds +// conversion uses that width, not the full canvas; Trigger nodes keep the full-canvas scale. +// Both match the forward map in envelope_overlay, so a dragged handle tracks the cursor 1:1. +// // Reuses editor_geometry's Rect + the EnvNode / AmpEnvelope / EnvMode types from // envelope_overlay (one shared node vocabulary across draw + edit), and the shared timeToX / // levelToY maps so the handle the overlay drew and the grab region here agree pixel-for-pixel. @@ -64,9 +69,11 @@ struct EnvClampBounds { // Which node a grab at (x, y) lands on, given the CURRENT envelope + overlay rect + sample // duration (the same inputs buildEnvelopePolyline drew from, so the grab tests the drawn handles). // Returns EnvNode::Origin's NON-membership as a miss via the bool return: `hit` is false for a -// point off every DRAGGABLE node. Origin and ReleaseStart are never returned (not draggable). On a -// tie (two handles within the radius) the earlier draw-order node wins (deterministic, mirroring -// waveform_view::markerAtPoint's first-match). Pure. +// point off every DRAGGABLE node. Origin and ReleaseStart are never returned (not draggable). +// The NEAREST node within the radius wins (Chebyshev distance); an exact tie goes to the earlier +// draw-order node (FA2 — deterministic, and it makes coincident nodes grabbable: at zero +// fade-out, FadeOutStart overlays LengthEnd, wins the tie, and can be dragged inward from the +// right edge; at zero hold, AttackEnd wins over HoldEnd). Pure. struct NodeHit { bool hit = false; EnvNode node = EnvNode::Origin; // meaningful only when hit == true diff --git a/src/vst/envelope_overlay.cpp b/src/vst/envelope_overlay.cpp index 6833923..06e2029 100644 --- a/src/vst/envelope_overlay.cpp +++ b/src/vst/envelope_overlay.cpp @@ -10,13 +10,22 @@ int timeToX(const Rect& area, double totalSeconds, double t) { const int w = std::max(0, area.width()); if (w <= 0 || totalSeconds <= 0.0) return area.left; if (t < 0.0) t = 0.0; - // Linear map, NOT clamped on the high side: t past totalSeconds maps past area.right (the Gate - // release tail, drawn after the sample end by design). Round to the nearest pixel. + // Linear map, clamped on BOTH sides (FA2 bounds invariant): t past totalSeconds pins to the + // last in-bounds column area.right-1. Round to the nearest pixel. const double frac = t / totalSeconds; - const long xi = static_cast(frac * static_cast(w) + 0.5); + long xi = static_cast(frac * static_cast(w) + 0.5); + if (xi > w - 1) xi = w - 1; return area.left + static_cast(xi); } +int gateTimedWidth(const Rect& area) { + const int w = std::max(0, area.width()); + if (w <= 0) return 0; + const int sustainPx = + static_cast(kGateSustainDisplayFraction * static_cast(w) + 0.5); + return std::max(1, w - sustainPx); +} + int levelToY(const Rect& area, double level) { const int h = std::max(0, area.height()); if (h <= 0) return area.top; @@ -46,6 +55,22 @@ EnvVertex vtx(EnvNode node, const Rect& area, double totalSeconds, double t, dou return v; } +// One Gate vertex from a pixel offset inside the area (the Gate schematic works in px space — +// timed px + the fixed sustain-plateau reserve — not through the plain timeToX map). Clamps x to +// the last in-bounds column (FA2 bounds invariant). +EnvVertex gateVtx(EnvNode node, const Rect& area, double px, double level) { + const int w = std::max(1, area.width()); + long xi = static_cast(px + 0.5); + if (xi < 0) xi = 0; + if (xi > w - 1) xi = w - 1; + EnvVertex v; + v.node = node; + v.x = area.left + static_cast(xi); + v.y = levelToY(area, level); + v.level = level; + return v; +} + std::vector gatePolyline(const AmpEnvelope& env, const Rect& area, double totalSeconds) { // Non-negative segment durations (a stored negative would be an upstream bug; clamp defensively). const double a = std::max(0.0, env.attackSeconds); @@ -54,23 +79,27 @@ std::vector gatePolyline(const AmpEnvelope& env, const Rect& area, do const double r = std::max(0.0, env.releaseSeconds); const double sus = clamp01(env.sustainLevel); - // Cumulative wall-clock times of each breakpoint from t=0. - const double tAttack = a; - const double tHold = tAttack + h; - const double tDecay = tHold + d; - // The sustain plateau runs to the sample end; if the pre-sustain stages already overrun the - // sample, the plateau collapses to zero width (its end clamps up to tDecay). - const double tSustainEnd = std::max(tDecay, totalSeconds); - const double tRelease = tSustainEnd + r; // release trails PAST the sample end, by design + // BOUNDED SCHEMATIC (FA2): A/H/D and R map onto the TIMED region (canvas minus the reserved + // sustain-plateau width) at the sample's time scale; the sustain plateau is the fixed reserve + // between DecayEnd and ReleaseStart. Cumulative px, clamped in gateVtx, stay monotonic. + const int timedW = gateTimedWidth(area); + const int sustainPx = std::max(0, area.width()) - timedW; + const double pxPerSec = static_cast(timedW) / totalSeconds; + + const double pxAttack = a * pxPerSec; + const double pxHold = (a + h) * pxPerSec; + const double pxDecay = (a + h + d) * pxPerSec; + const double pxPlateau = pxDecay + static_cast(sustainPx); // schematic note-off + const double pxRelease = pxPlateau + r * pxPerSec; std::vector pts; pts.reserve(6); - pts.push_back(vtx(EnvNode::Origin, area, totalSeconds, 0.0, 0.0)); - pts.push_back(vtx(EnvNode::AttackEnd, area, totalSeconds, tAttack, 1.0)); - pts.push_back(vtx(EnvNode::HoldEnd, area, totalSeconds, tHold, 1.0)); - pts.push_back(vtx(EnvNode::DecayEnd, area, totalSeconds, tDecay, sus)); // sustain node - pts.push_back(vtx(EnvNode::ReleaseStart, area, totalSeconds, tSustainEnd, sus)); // plateau end - pts.push_back(vtx(EnvNode::ReleaseEnd, area, totalSeconds, tRelease, 0.0)); + pts.push_back(gateVtx(EnvNode::Origin, area, 0.0, 0.0)); + pts.push_back(gateVtx(EnvNode::AttackEnd, area, pxAttack, 1.0)); + pts.push_back(gateVtx(EnvNode::HoldEnd, area, pxHold, 1.0)); + pts.push_back(gateVtx(EnvNode::DecayEnd, area, pxDecay, sus)); // sustain node + pts.push_back(gateVtx(EnvNode::ReleaseStart, area, pxPlateau, sus)); // plateau end + pts.push_back(gateVtx(EnvNode::ReleaseEnd, area, pxRelease, 0.0)); return pts; } diff --git a/src/vst/envelope_overlay.h b/src/vst/envelope_overlay.h index 0b46ff8..7ef671e 100644 --- a/src/vst/envelope_overlay.h +++ b/src/vst/envelope_overlay.h @@ -4,16 +4,37 @@ // the DAW, while the editor shell (reasampler_editor.cpp) traces the polyline in an accent hue // and draws the node handles (via envelope_edit's hit-test). // -// WHAT IT DRAWS. The amp envelope over the Sample view's hero waveform at accurate wall-clock -// time (Simpler / Phase-Plant grammar): +// WHAT IT DRAWS. The amp envelope over the Sample view's hero waveform (Simpler / Phase-Plant +// grammar): // * Gate -> the AHDSR shape: attack ramp 0->1, hold plateau at 1, decay 1->sustain, -// sustain plateau, release sustain->0. +// sustain plateau, release sustain->0. Since there is no held note-off to draw +// against, Gate is a BOUNDED SCHEMATIC (FA2): a fixed fraction of the canvas +// width (kGateSustainDisplayFraction) is RESERVED for the sustain plateau, and +// the remaining "timed" width carries A/H/D AND the release at the sample's time +// scale — so A -> (H) -> D -> S-plateau -> R all render INSIDE the canvas and the +// release is a visible, draggable segment (it no longer trails past area.right). // * Trigger -> the fade/%-length shape: fade-in 0->1, unity plateau, fade-out 1->0 anchored -// to playEnd (= lengthFraction of the post-start span). -// The horizontal axis is wall-clock TIME across the waveform rect; the vertical axis is LEVEL -// (0 at rect bottom, 1 at rect top). The overlay shares the waveform's time base so the drawn -// shape lines up with the PCM under it: the same [0, frameCount] span waveform_view maps, so the -// envelope's own duration is placed at the SAME frames the voice plays it over. +// to playEnd (= lengthFraction of the post-start span). Trigger keeps the +// waveform's exact time base so the shape lines up with the PCM under it. +// The horizontal axis is TIME (Gate: schematic, see above; Trigger: wall-clock across the rect); +// the vertical axis is LEVEL (0 at rect bottom, 1 at rect top). +// +// BOUNDS INVARIANT (FA2). EVERY vertex of EVERY polyline is clamped inside the canvas: +// x in [area.left, area.right-1], y in [area.top, area.bottom-1] (half-open rect convention). +// No node and no drawn segment ever exceeds the canvas — paint-time clipping of handles is no +// longer needed (and never fires) in the shell. +// +// FA2 CONTRACT CHANGE — WAVE B SHELL AUTHOR, READ THIS: +// * The EnvNode enum is UNCHANGED (same node set, same draggable set — Origin + ReleaseStart +// remain the only non-draggable anchors). +// * ALL vertices are now in-bounds (see above). The shell's previous "skip handle when +// v.x >= waveArea.right" clip is dead code: ReleaseEnd (Gate) and FadeOutStart/LengthEnd +// (Trigger, at full length / zero fade-out) now land at area.right-1 and MUST get handles. +// * Gate's x-axis is schematic, not PCM-aligned (the sustain reserve compresses the timed +// region); Trigger's x-axis is still PCM-aligned. +// * nodeAtPoint (envelope_edit) now resolves to the NEAREST node within the grab radius, +// draw-order tie-break — coincident nodes (zero fade-out at the right edge, zero hold) are +// deterministically grabbable. // // DELIBERATELY ENGINE-FREE (house pattern — param_slider does the same). It does NOT depend on // sample_map / sampler_core (which would drag bank_book / wav_trim in). The shell reads the @@ -44,7 +65,8 @@ enum class EnvMode { Gate, Trigger }; // // Gate nodes: Origin -> AttackEnd -> HoldEnd -> DecayEnd(=sustain corner) -> ReleaseStart // -> ReleaseEnd. The sustain node is DecayEnd (its Y is the sustain level); -// ReleaseStart is a drawing-only plateau-end vertex. +// ReleaseStart is a drawing-only plateau-end vertex (the schematic note-off); +// release is edited by dragging ReleaseEnd. // Trigger nodes: Origin -> FadeInEnd -> FadeOutStart -> LengthEnd(playEnd, level 0). The fade-out // ramp is the FadeOutStart->LengthEnd segment; LengthEnd is the playEnd terminal. enum class EnvNode { @@ -55,7 +77,8 @@ enum class EnvNode { // Y sets sustainLevel) ReleaseStart, // Gate: end of the sustain plateau / start of the release (sustain level) — // a DRAWING vertex only, not a draggable handle (release is edited at - // ReleaseEnd; this vertex tracks its X = sample end, Y = sustain level) + // ReleaseEnd; this vertex sits a fixed sustain-plateau width right of + // DecayEnd — the schematic note-off — Y = sustain level) ReleaseEnd, // Gate: end of the release tail (level 0) — X sets releaseSeconds FadeInEnd, // Trigger: top of the fade-in (level 1) — X sets fadeInFraction FadeOutStart, // Trigger: end of the unity plateau / start of the fade-out (level 1) — @@ -121,36 +144,46 @@ struct EnvVertex { } }; +// The fraction of the canvas width RESERVED for the Gate sustain-plateau display (FA2). The +// plateau is a fixed-width schematic region between DecayEnd and ReleaseStart; the remaining +// width is the "timed" region A/H/D/R map onto at the sample's time scale. One constant shared +// by the forward map (here) and the inverse map (envelope_edit) so a drag tracks the cursor. +inline constexpr double kGateSustainDisplayFraction = 0.15; + +// The pixel width of the Gate timed region: area.width() minus the sustain-plateau reserve, +// floored at 1 px so the px<->seconds scale never degenerates for a non-empty area. Returns 0 +// for a zero/negative-width area. Shared by gatePolyline and envelope_edit's gate drag scale. +int gateTimedWidth(const Rect& area); + // Map an amp envelope to its polyline vertices inside `area`, over a sample of `totalSeconds` // wall-clock duration. `area` is the waveform rect (left/top inclusive, right/bottom exclusive); -// x maps time 0..totalSeconds across [area.left, area.right], y maps level 0..1 across -// [area.bottom-1 .. area.top] (level 1 at the TOP). The polyline reads left-to-right in draw -// order, Origin first. +// y maps level 0..1 across [area.bottom-1 .. area.top] (level 1 at the TOP). The polyline reads +// left-to-right in draw order, Origin first. // -// TIME BASE. The envelope's own segment durations are placed on the SAME time axis the waveform -// occupies, so the curve lines up with the PCM: -// * Gate: attack/hold/decay run from t=0; the sustain plateau runs to the note-off. Since the -// overlay has no held note-off to draw against, the sustain plateau is drawn to the END of -// the sample (totalSeconds) and the release tail is drawn AFTER that boundary — i.e. the -// release is appended past the sample end (the standard "release after key-up at end of -// view" convention). When attack+hold+decay already exceed totalSeconds the plateau collapses -// to zero width (nodes clamp to the sample end) and release still trails past it. -// * Trigger: the played span is lengthFraction * totalSeconds; fade-in/out are fractions OF -// that played span. Nodes past the played span never appear (LengthEnd/FadeOutEnd sit at the -// played span's right edge). +// TIME BASE (FA2). +// * Gate: a bounded schematic. The canvas splits into a TIMED region of gateTimedWidth(area) +// px — where attack/hold/decay run from t=0 and the release ramp runs after the plateau, all +// at totalSeconds-over-timed-width scale — plus a FIXED sustain plateau of +// (width - timedWidth) px between DecayEnd and ReleaseStart (the schematic note-off). Every +// vertex x clamps to area.right-1, so when the stages overrun the visible span the trailing +// nodes pile up (still monotonic, still in-bounds, still draggable back left). +// * Trigger: the waveform's exact time base (PCM-aligned). The played span is +// lengthFraction * totalSeconds; fade-in/out are fractions OF that played span. Nodes past +// the played span never appear (FadeOutStart/LengthEnd sit at the played span's right edge). // -// A time beyond totalSeconds (the Gate release tail) maps past area.right — the shell clips at -// paint time (the same way waveform_view lets a frame past the count pin the marker). A degenerate -// area (zero width/height) or totalSeconds <= 0 yields the two-point flat baseline [Origin, end at -// level 0] so the shell always has a drawable line. Pure — same inputs, same polyline. +// BOUNDS: every vertex is inside the canvas — x in [area.left, area.right-1], y in +// [area.top, area.bottom-1]. Nothing maps past area.right (the pre-FA2 release tail is gone). A +// degenerate area (zero width/height) or totalSeconds <= 0 yields the two-point flat baseline +// [Origin, end at level 0] so the shell always has a drawable line. Pure — same inputs, same +// polyline. std::vector buildEnvelopePolyline(const AmpEnvelope& env, const Rect& area, double totalSeconds); -// Map a time (seconds) to a pixel x inside `area`: t=0 -> area.left, t=totalSeconds -> area.right, -// linear. t is NOT clamped on the high side (a Gate release past the sample end maps past -// area.right, by design — see buildEnvelopePolyline); t < 0 pins to area.left. A zero-width area -// or totalSeconds <= 0 yields area.left. Pure — the shared time->x map both the polyline and the -// node hit-test (envelope_edit) use, so the drawn handle and its grab region agree. +// Map a time (seconds) to a pixel x inside `area`: t=0 -> area.left, t=totalSeconds -> +// area.right-1, linear, CLAMPED on both sides (t < 0 pins to area.left; t past totalSeconds pins +// to area.right-1 — the in-bounds invariant, FA2). A zero-width area or totalSeconds <= 0 yields +// area.left. Pure — the shared time->x map the Trigger polyline and the node hit-test +// (envelope_edit) use, so the drawn handle and its grab region agree. int timeToX(const Rect& area, double totalSeconds, double t); // Map a level (0..1) to a pixel y inside `area`: level 1 -> area.top, level 0 -> area.bottom-1 diff --git a/tests/test_envelope_edit.cpp b/tests/test_envelope_edit.cpp index a1575dc..d94d9e0 100644 --- a/tests/test_envelope_edit.cpp +++ b/tests/test_envelope_edit.cpp @@ -4,12 +4,14 @@ // boundaries (the load-bearing "a drag can never produce a param a slider couldn't" invariant). // // Covers: nodeAtPoint (grabs a drawn handle within the pick radius; misses off every node; skips -// the non-draggable Origin/ReleaseStart anchors; first-match determinism); resolveNodeDrag Gate -// (each cumulative node edits its OWN segment; X->time, sustain node's Y->level; lower clamp at 0; -// upper clamp at the caller's max; only the dragged param changes); resolveNodeDrag Trigger (fades -// as fractions of the played span; fadeIn/fadeOut mutual clamp so they never cross; length clamp; -// FadeOutStart moves OPPOSITE the pixel delta); degenerate area/duration + non-draggable node -> -// no motion. +// the non-draggable Origin/ReleaseStart anchors; NEAREST-node-wins with draw-order tie-break — +// FA2); resolveNodeDrag Gate (each cumulative node edits its OWN segment at the TIMED-region px +// scale; X->time, sustain node's Y->level; lower clamp at 0; upper clamp at the caller's max; +// only the dragged param changes; ReleaseEnd grabbable + draggable — FA2); resolveNodeDrag +// Trigger (fades as fractions of the played span; fadeIn/fadeOut mutual clamp so they never +// cross; length clamp; FadeOutStart moves OPPOSITE the pixel delta; zero-fade-out node grabbable +// at the right edge and draggable inward — FA2); degenerate area/duration + non-draggable node +// -> no motion. #include "../src/vst/envelope_edit.h" @@ -24,9 +26,12 @@ static int g_fail = 0; static bool near(double a, double b, double eps = 1e-9) { return std::fabs(a - b) <= eps; } -// 1000px wide, 100px tall, offset origin. 2.0s total => 500 px/s => 0.002 s/px. +// 1000px wide, 100px tall, offset origin. Trigger scale: 2.0s over 1000px => 0.002 s/px. Gate +// scale (FA2 schematic): 2.0s over the 850px TIMED region (150px sustain-plateau reserve) => +// 2/850 s/px, and the gateEnv() nodes draw at A x@85, H x@128, D x@255, RS x@405, RE x@575. static Rect wideArea() { return Rect{20, 10, 1020, 110}; } static constexpr double kTotal = 2.0; +static constexpr double kGateSecPerPx = kTotal / 850.0; static AmpEnvelope gateEnv() { AmpEnvelope e; @@ -53,18 +58,18 @@ static AmpEnvelope triggerEnv() { static void testHitGrabsDrawnHandle() { const AmpEnvelope e = gateEnv(); const Rect a = wideArea(); - // AttackEnd draws at x = left+100 (0.2s), y = top (level 1). A grab there hits it. - NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 100, a.top); + // AttackEnd draws at x = left+85 (0.2s * 425 px/s in the timed region), y = top (level 1). + NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 85, a.top); CHECK(h.hit && h.node == EnvNode::AttackEnd); - // The sustain node (DecayEnd) at 0.6s -> left+300, level 0.5 -> ~top+50. - NodeHit s = nodeAtPoint(e, a, kTotal, a.left + 300, a.top + 50); + // The sustain node (DecayEnd) at 0.6s -> left+255, level 0.5 -> ~top+50. + NodeHit s = nodeAtPoint(e, a, kTotal, a.left + 255, a.top + 50); CHECK(s.hit && s.node == EnvNode::DecayEnd); } static void testHitMissesOffEveryNode() { const AmpEnvelope e = gateEnv(); const Rect a = wideArea(); - // A point far from any drawn handle (mid plateau, well away from a node). + // A point far from any drawn handle (right of the release ramp, well away from a node). NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 700, a.top + 5); CHECK(!h.hit); } @@ -75,22 +80,42 @@ static void testHitSkipsNonDraggableAnchors() { // Origin draws at (left, bottom-1). Even a pixel-perfect grab there is NOT a draggable node. NodeHit o = nodeAtPoint(e, a, kTotal, a.left, a.bottom - 1); CHECK(!o.hit); - // ReleaseStart draws at (right, sustain level). It is drawing-only -> not grabbable. But - // ReleaseEnd is elsewhere, so a grab exactly at ReleaseStart's point must miss. - // ReleaseStart x == right (plateau to sample end), y == sustain (~top+50). - NodeHit rs = nodeAtPoint(e, a, kTotal, a.right, a.top + 50); + // ReleaseStart draws at (left+405, sustain level ~top+50) — the fixed plateau end. It is + // drawing-only -> not grabbable; no other node is within the radius, so this grab misses. + NodeHit rs = nodeAtPoint(e, a, kTotal, a.left + 405, a.top + 50); CHECK(!rs.hit); } +static void testHitNearestNodeWinsOverDrawOrder() { + // FA2 nearest-wins: with a SHORT hold, AttackEnd (x@85) and HoldEnd (x@89) both fall within + // the grab radius of a point at x@90 — the NEAREST (HoldEnd, 1px) must win, not the earlier + // draw-order AttackEnd (5px), so tightly packed handles stay individually grabbable. + AmpEnvelope e = gateEnv(); + e.holdSeconds = 0.01; // hold end at 0.21s -> x@round(89.25)=89 + const Rect a = wideArea(); + NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 90, a.top); + CHECK(h.hit && h.node == EnvNode::HoldEnd); +} + +static void testHitCoincidentNodesTieToEarlierDrawOrder() { + // Zero hold: AttackEnd and HoldEnd draw at the SAME pixel. The tie goes to the earlier + // draw-order node (AttackEnd) — deterministic, mirroring the pre-FA2 first-match rule. + AmpEnvelope e = gateEnv(); + e.holdSeconds = 0.0; + const Rect a = wideArea(); + NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 85, a.top); + CHECK(h.hit && h.node == EnvNode::AttackEnd); +} + // --- resolveNodeDrag Gate ----------------------------------------------------- static void testGateAttackDragMovesOnlyAttack() { const AmpEnvelope e = gateEnv(); const Rect a = wideArea(); EnvClampBounds b; // default maxima 4.0s - // +50px at 0.002 s/px = +0.1s on attack (0.2 -> 0.3). Nothing else moves. + // +50px at the GATE timed-region scale (2/850 s/px) on attack. Nothing else moves. AmpEnvelope out = resolveNodeDrag(e, EnvNode::AttackEnd, a, kTotal, b, 50, 0); - CHECK(near(out.attackSeconds, 0.3)); + CHECK(near(out.attackSeconds, 0.2 + 50.0 * kGateSecPerPx)); CHECK(near(out.holdSeconds, e.holdSeconds)); CHECK(near(out.decaySeconds, e.decaySeconds)); CHECK(near(out.sustainLevel, e.sustainLevel)); @@ -101,8 +126,8 @@ static void testGateTimeLowerClampAtZero() { const AmpEnvelope e = gateEnv(); const Rect a = wideArea(); EnvClampBounds b; - // Drag attack far LEFT (-500px = -1.0s) from 0.2s: clamps to 0, never negative (monotonic: - // the segment cannot go below zero). + // Drag attack far LEFT (-500px ~= -1.18s at the gate scale) from 0.2s: clamps to 0, never + // negative (monotonic: the segment cannot go below zero). AmpEnvelope out = resolveNodeDrag(e, EnvNode::AttackEnd, a, kTotal, b, -500, 0); CHECK(near(out.attackSeconds, 0.0)); } @@ -112,8 +137,8 @@ static void testGateTimeUpperClampAtSliderMax() { const Rect a = wideArea(); EnvClampBounds b; b.maxDecaySeconds = 1.0; // the shell's decay slider tops out at 1.0s - // Drag decay far RIGHT (+2000px = +4.0s) from 0.3s: clamps to the slider max 1.0, NOT beyond - // (the drag can't produce a param the slider couldn't). + // Drag decay far RIGHT (+2000px ~= +4.7s at the gate scale) from 0.3s: clamps to the slider + // max 1.0, NOT beyond (the drag can't produce a param the slider couldn't). AmpEnvelope out = resolveNodeDrag(e, EnvNode::DecayEnd, a, kTotal, b, 2000, 0); CHECK(near(out.decaySeconds, 1.0)); } @@ -122,10 +147,10 @@ static void testGateSustainNodeBothAxes() { const AmpEnvelope e = gateEnv(); const Rect a = wideArea(); EnvClampBounds b; - // DecayEnd: +100px X = +0.2s decay (0.3 -> 0.5); +bottom-ward Y LOWERS the level. Level span is - // 99 px for [0,1]; drag DOWN by ~10px (positive dy) lowers sustain by ~10/99 ~= 0.101. + // DecayEnd: +100px X at the gate timed scale on decay; +bottom-ward Y LOWERS the level. Level + // span is 99 px for [0,1]; drag DOWN by ~10px (positive dy) lowers sustain by ~10/99 ~= 0.101. AmpEnvelope out = resolveNodeDrag(e, EnvNode::DecayEnd, a, kTotal, b, 100, 10); - CHECK(near(out.decaySeconds, 0.5)); + CHECK(near(out.decaySeconds, 0.3 + 100.0 * kGateSecPerPx)); CHECK(out.sustainLevel < e.sustainLevel); // dragged DOWN -> lower sustain CHECK(near(out.sustainLevel, 0.5 - 10.0 / 99.0, 1e-6)); } @@ -152,6 +177,26 @@ static void testGateTimeOnlyNodeIgnoresY() { CHECK(near(out.sustainLevel, e.sustainLevel)); // Y ignored for a time-only node } +static void testGateReleaseEndGrabAndDrag() { + // The FA2 fix: ReleaseEnd is a drawn, IN-BOUNDS, grabbable handle (pre-FA2 it mapped past + // area.right and could never be grabbed). gateEnv() draws it at x@575, level 0 (bottom row). + const AmpEnvelope e = gateEnv(); + const Rect a = wideArea(); + EnvClampBounds b; + NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 575, a.bottom - 1); + CHECK(h.hit && h.node == EnvNode::ReleaseEnd); + // Dragging it RIGHT lengthens the release at the gate timed scale; only release changes. + AmpEnvelope out = resolveNodeDrag(e, EnvNode::ReleaseEnd, a, kTotal, b, 85, 0); + CHECK(near(out.releaseSeconds, 0.4 + 85.0 * kGateSecPerPx)); + CHECK(near(out.sustainLevel, e.sustainLevel)); + CHECK(near(out.decaySeconds, e.decaySeconds)); + // Far LEFT clamps to 0; far RIGHT clamps to the slider max. + AmpEnvelope lo = resolveNodeDrag(e, EnvNode::ReleaseEnd, a, kTotal, b, -2000, 0); + CHECK(near(lo.releaseSeconds, 0.0)); + AmpEnvelope hi = resolveNodeDrag(e, EnvNode::ReleaseEnd, a, kTotal, b, 5000, 0); + CHECK(near(hi.releaseSeconds, b.maxReleaseSeconds)); +} + // --- resolveNodeDrag Trigger -------------------------------------------------- static void testTriggerFadeInIsFractionOfPlaySpan() { @@ -188,6 +233,28 @@ static void testTriggerFadeOutMovesOppositePixelDelta() { CHECK(near(out.fadeInFraction, e.fadeInFraction)); } +static void testTriggerZeroFadeOutGrabbableAtRightEdge() { + // The FA2 fix: at fade-out == 0 and full length, FadeOutStart draws AT the right edge + // (right-1, level 1). It must be grabbable there and draggable INWARD to grow the fade from + // zero (drag LEFT -> longer fade-out, opposite the pixel delta). + AmpEnvelope e; + e.mode = EnvMode::Trigger; + e.lengthFraction = 1.0; // played span = full 2.0s -> 1000px + e.fadeInFraction = 0.1; + e.fadeOutFraction = 0.0; + const Rect a = wideArea(); + EnvClampBounds b; + NodeHit h = nodeAtPoint(e, a, kTotal, a.right - 1, a.top); + CHECK(h.hit && h.node == EnvNode::FadeOutStart); + // -100px = -0.2s on the 2.0s played span, applied OPPOSITE -> fadeOut 0.0 -> 0.1. + AmpEnvelope out = resolveNodeDrag(e, EnvNode::FadeOutStart, a, kTotal, b, -100, 0); + CHECK(near(out.fadeOutFraction, 0.1)); + CHECK(near(out.lengthFraction, e.lengthFraction)); // length untouched + // LengthEnd sits at the same x but level 0 (bottom row) — grabbable at ITS drawn point. + NodeHit le = nodeAtPoint(e, a, kTotal, a.right - 1, a.bottom - 1); + CHECK(le.hit && le.node == EnvNode::LengthEnd); +} + static void testTriggerLengthClampsAtMax() { const AmpEnvelope e = triggerEnv(); // length 0.5 const Rect a = wideArea(); @@ -226,6 +293,8 @@ int main() { testHitGrabsDrawnHandle(); testHitMissesOffEveryNode(); testHitSkipsNonDraggableAnchors(); + testHitNearestNodeWinsOverDrawOrder(); + testHitCoincidentNodesTieToEarlierDrawOrder(); testGateAttackDragMovesOnlyAttack(); testGateTimeLowerClampAtZero(); @@ -233,10 +302,12 @@ int main() { testGateSustainNodeBothAxes(); testGateSustainLevelClamps01(); testGateTimeOnlyNodeIgnoresY(); + testGateReleaseEndGrabAndDrag(); testTriggerFadeInIsFractionOfPlaySpan(); testTriggerFadesCannotCross(); testTriggerFadeOutMovesOppositePixelDelta(); + testTriggerZeroFadeOutGrabbableAtRightEdge(); testTriggerLengthClampsAtMax(); testNonDraggableNodeNoMotion(); diff --git a/tests/test_envelope_overlay.cpp b/tests/test_envelope_overlay.cpp index 6108090..483ba62 100644 --- a/tests/test_envelope_overlay.cpp +++ b/tests/test_envelope_overlay.cpp @@ -1,14 +1,15 @@ // Standalone tests for reasampler::vst::envelope_overlay — no VST3, no REAPER, no framework. -// Same fast assert loop as the sibling pure tests. Assert the S-VIEW-3 amp-envelope -> polyline -// FORWARD map: the Gate AHDSR shape (attack ramp / hold plateau / decay-to-sustain / plateau / -// release) and the Trigger fade/%-length shape, at the waveform time base (so the drawn curve -// lines up with the PCM under it). +// Same fast assert loop as the sibling pure tests. Assert the S-VIEW-3/FA2 amp-envelope -> +// polyline FORWARD map: the Gate BOUNDED-SCHEMATIC AHDSR shape (attack ramp / hold plateau / +// decay-to-sustain / fixed-width sustain plateau / in-bounds release) and the Trigger +// fade/%-length shape at the waveform time base. // -// Covers: timeToX / levelToY (linear maps, edge clamps, release-past-end NOT clamped, degenerate -// area/duration); buildEnvelopePolyline Gate (node order, levels, cumulative time placement, -// sustain plateau to sample end, release past end, collapsed plateau when stages overrun); +// Covers: timeToX / levelToY (linear maps, edge clamps, past-end CLAMPED to right-1 — the FA2 +// bounds invariant, degenerate area/duration); gateTimedWidth; buildEnvelopePolyline Gate (node +// order, levels, timed-region placement, fixed sustain-plateau reserve, release visible +// in-bounds, overrun pile-up clamped at the right edge, every vertex in-bounds); // buildEnvelopePolyline Trigger (fade-in/unity/fade-out at fractions of the played span, overlap -// clamp); degenerate flat baseline. +// clamp, full-length/zero-fade-out nodes in-bounds at right-1); degenerate flat baseline. #include "../src/vst/envelope_overlay.h" @@ -37,8 +38,8 @@ static bool findNode(const std::vector& poly, EnvNode node, EnvVertex static void testTimeToXEndpoints() { const Rect a = wideArea(); - CHECK(timeToX(a, 2.0, 0.0) == a.left); // t=0 -> left - CHECK(timeToX(a, 2.0, 2.0) == a.right); // t=total -> right + CHECK(timeToX(a, 2.0, 0.0) == a.left); // t=0 -> left + CHECK(timeToX(a, 2.0, 2.0) == a.right - 1); // t=total -> last in-bounds column CHECK(timeToX(a, 2.0, 1.0) == a.left + 500); // midpoint } @@ -47,11 +48,19 @@ static void testTimeToXNegativePinsLeft() { CHECK(timeToX(a, 2.0, -0.5) == a.left); // t<0 pins left } -static void testTimeToXPastEndNotClamped() { - // The Gate release tail is drawn past the sample end BY DESIGN: t past total maps past right. +static void testTimeToXPastEndClamps() { + // FA2 bounds invariant: t past total pins to the last in-bounds column, never past right. const Rect a = wideArea(); - CHECK(timeToX(a, 2.0, 3.0) > a.right); // t=1.5x total -> past the right edge - CHECK(timeToX(a, 2.0, 3.0) == a.left + 1500); + CHECK(timeToX(a, 2.0, 3.0) == a.right - 1); + CHECK(timeToX(a, 2.0, 1000.0) == a.right - 1); +} + +static void testGateTimedWidth() { + // 15% of the 1000px canvas is reserved for the sustain plateau -> 850px timed region. + CHECK(gateTimedWidth(wideArea()) == 850); + // Zero-width area -> 0; a tiny area still yields >= 1 so the px<->s scale never degenerates. + CHECK(gateTimedWidth(Rect{5, 5, 5, 45}) == 0); + CHECK(gateTimedWidth(Rect{0, 0, 1, 10}) == 1); } static void testTimeToXDegenerate() { @@ -108,35 +117,81 @@ static void testGateNodeOrderAndLevels() { CHECK(poly[5].level == 0.0); } -static void testGateCumulativeTimePlacement() { - // total 2.0s over 1000px => 500 px/s. attack .2 -> x@100, hold end .3 -> x@150, decay end .6 - // -> x@300. Sustain plateau runs to the sample END (2.0 -> right). Release .4 trails past. +static void testGateSchematicPlacement() { + // FA2 bounded schematic: timed region = 850px (150px reserved plateau), total 2.0s => + // 425 px/s in the timed region. attack .2 -> x@85, hold end .3 -> x@round(127.5)=128, decay + // end .6 -> x@255. Plateau is the FIXED 150px reserve -> ReleaseStart x@405. Release .4 -> + // 170px ramp -> ReleaseEnd x@575, well inside the canvas. AmpEnvelope env; env.mode = EnvMode::Gate; env.attackSeconds = 0.2; env.holdSeconds = 0.1; // hold end at 0.3s env.decaySeconds = 0.3; // decay end at 0.6s env.sustainLevel = 0.5; - env.releaseSeconds = 0.4; // release end at 2.4s (past the 2.0s end) + env.releaseSeconds = 0.4; const Rect a = wideArea(); const std::vector poly = buildEnvelopePolyline(env, a, 2.0); EnvVertex v; - CHECK(findNode(poly, EnvNode::AttackEnd, v) && v.x == a.left + 100); - CHECK(findNode(poly, EnvNode::HoldEnd, v) && v.x == a.left + 150); - CHECK(findNode(poly, EnvNode::DecayEnd, v) && v.x == a.left + 300); - CHECK(findNode(poly, EnvNode::ReleaseStart, v) && v.x == a.right); // plateau to end - CHECK(findNode(poly, EnvNode::ReleaseEnd, v) && v.x == a.left + 1200); // 2.4s -> 1200px past + CHECK(findNode(poly, EnvNode::AttackEnd, v) && v.x == a.left + 85); + CHECK(findNode(poly, EnvNode::HoldEnd, v) && v.x == a.left + 128); + CHECK(findNode(poly, EnvNode::DecayEnd, v) && v.x == a.left + 255); + CHECK(findNode(poly, EnvNode::ReleaseStart, v) && v.x == a.left + 405); + CHECK(findNode(poly, EnvNode::ReleaseEnd, v) && v.x == a.left + 575); } -static void testGatePlateauCollapsesWhenStagesOverrun() { - // A/H/D sum to 3.0s > the 2.0s sample: the plateau collapses (ReleaseStart clamps to DecayEnd's - // time), and the release still trails past. +static void testGateSustainPlateauFixedWidth() { + // The sustain plateau is ALWAYS the reserved width (canvas - timed region), independent of + // the AHDSR times — the bounded region that replaces the old plateau-to-sample-end. + AmpEnvelope env; + env.mode = EnvMode::Gate; + env.attackSeconds = 0.1; + env.holdSeconds = 0.0; + env.decaySeconds = 0.2; + env.sustainLevel = 0.6; + env.releaseSeconds = 0.3; + const Rect a = wideArea(); + const int plateauPx = a.width() - gateTimedWidth(a); // 150 + const std::vector poly = buildEnvelopePolyline(env, a, 2.0); + + EnvVertex decay, plateauEnd; + CHECK(findNode(poly, EnvNode::DecayEnd, decay)); + CHECK(findNode(poly, EnvNode::ReleaseStart, plateauEnd)); + CHECK(plateauEnd.x - decay.x == plateauPx); + CHECK(plateauEnd.level == 0.6); // plateau holds the sustain level +} + +static void testGateReleaseVisibleInBounds() { + // The FA2 fix: Release is a VISIBLE, in-bounds segment — ReleaseEnd sits strictly right of + // the plateau end and strictly inside the canvas (pre-FA2 it mapped past area.right and the + // shell clipped its handle away). + AmpEnvelope env; + env.mode = EnvMode::Gate; + env.attackSeconds = 0.2; + env.holdSeconds = 0.1; + env.decaySeconds = 0.3; + env.sustainLevel = 0.5; + env.releaseSeconds = 0.4; + const Rect a = wideArea(); + const std::vector poly = buildEnvelopePolyline(env, a, 2.0); + + EnvVertex plateauEnd, rel; + CHECK(findNode(poly, EnvNode::ReleaseStart, plateauEnd)); + CHECK(findNode(poly, EnvNode::ReleaseEnd, rel)); + CHECK(rel.x > plateauEnd.x); // a visible ramp, not a collapsed point + CHECK(rel.x < a.right); // strictly in-bounds + CHECK(rel.level == 0.0); +} + +static void testGateOverrunClampsToCanvas() { + // A/H/D/R overrun the visible span (sum 3.5s > 2.0s total): the trailing nodes pile up at + // the last in-bounds column — monotonic, in-bounds, still individually draggable back left. + // NOTHING maps past area.right (the pre-FA2 release tail is gone). AmpEnvelope env; env.mode = EnvMode::Gate; env.attackSeconds = 1.0; env.holdSeconds = 1.0; - env.decaySeconds = 1.0; // decay end at 3.0s + env.decaySeconds = 1.0; // decay end at 3.0s -> already past the timed span env.sustainLevel = 0.7; env.releaseSeconds = 0.5; const Rect a = wideArea(); @@ -146,11 +201,37 @@ static void testGatePlateauCollapsesWhenStagesOverrun() { CHECK(findNode(poly, EnvNode::DecayEnd, decay)); CHECK(findNode(poly, EnvNode::ReleaseStart, plateauEnd)); CHECK(findNode(poly, EnvNode::ReleaseEnd, rel)); - CHECK(plateauEnd.x == decay.x); // collapsed: plateau has zero width - CHECK(rel.x > decay.x); // release trails past + CHECK(decay.x == a.right - 1); // pinned to the last in-bounds column + CHECK(plateauEnd.x == a.right - 1); + CHECK(rel.x == a.right - 1); CHECK(plateauEnd.level == 0.7); // still at sustain } +static void testGateAllVerticesInBounds() { + // The FA2 bounds invariant, swept over representative param sets (including extremes): every + // vertex of every polyline stays inside the canvas rect. + const Rect a = wideArea(); + const AmpEnvelope base; // defaults + AmpEnvelope big = base; + big.mode = EnvMode::Gate; + big.attackSeconds = 4.0; big.holdSeconds = 4.0; big.decaySeconds = 4.0; + big.sustainLevel = 1.0; big.releaseSeconds = 4.0; + AmpEnvelope zero = base; + zero.mode = EnvMode::Gate; + zero.attackSeconds = 0.0; zero.holdSeconds = 0.0; zero.decaySeconds = 0.0; + zero.sustainLevel = 0.0; zero.releaseSeconds = 0.0; + AmpEnvelope trig = base; + trig.mode = EnvMode::Trigger; + trig.lengthFraction = 1.0; trig.fadeInFraction = 0.0; trig.fadeOutFraction = 0.0; + + for (const AmpEnvelope& env : {base, big, zero, trig}) { + for (const EnvVertex& v : buildEnvelopePolyline(env, a, 2.0)) { + CHECK(v.x >= a.left && v.x < a.right); + CHECK(v.y >= a.top && v.y < a.bottom); + } + } +} + // --- Trigger polyline --------------------------------------------------------- static void testTriggerShape() { @@ -193,6 +274,26 @@ static void testTriggerFadeOverlapClamp() { CHECK(fin.x == a.left + 800); } +static void testTriggerFullLengthZeroFadeOutInBounds() { + // The FA2 fix: at full length + zero fade-out, FadeOutStart and LengthEnd land AT the last + // in-bounds column (right-1), NOT at the half-open right edge — so the shell draws their + // handles and the fade-out node is grabbable even when fade-out == 0. + AmpEnvelope env; + env.mode = EnvMode::Trigger; + env.lengthFraction = 1.0; + env.fadeInFraction = 0.1; + env.fadeOutFraction = 0.0; + const Rect a = wideArea(); + const std::vector poly = buildEnvelopePolyline(env, a, 2.0); + + EnvVertex fout, lend; + CHECK(findNode(poly, EnvNode::FadeOutStart, fout)); + CHECK(findNode(poly, EnvNode::LengthEnd, lend)); + CHECK(fout.x == a.right - 1); // present + in-bounds at zero fade-out + CHECK(lend.x == a.right - 1); + CHECK(fout.level == 1.0 && lend.level == 0.0); +} + // --- Degenerate --------------------------------------------------------------- static void testDegenerateFlatBaseline() { @@ -206,23 +307,28 @@ static void testDegenerateFlatBaseline() { const std::vector p2 = buildEnvelopePolyline(env, ok, 0.0); // no duration CHECK(p2.size() == 2); CHECK(p2.front().level == 0.0 && p2.back().level == 0.0); - CHECK(p2.front().x == ok.left && p2.back().x == ok.right); // spans the whole area flat + CHECK(p2.front().x == ok.left && p2.back().x == ok.right - 1); // spans the area, in-bounds } int main() { testTimeToXEndpoints(); testTimeToXNegativePinsLeft(); - testTimeToXPastEndNotClamped(); + testTimeToXPastEndClamps(); testTimeToXDegenerate(); + testGateTimedWidth(); testLevelToYEndpoints(); testLevelToYClamps(); testGateNodeOrderAndLevels(); - testGateCumulativeTimePlacement(); - testGatePlateauCollapsesWhenStagesOverrun(); + testGateSchematicPlacement(); + testGateSustainPlateauFixedWidth(); + testGateReleaseVisibleInBounds(); + testGateOverrunClampsToCanvas(); + testGateAllVerticesInBounds(); testTriggerShape(); testTriggerFadeOverlapClamp(); + testTriggerFullLengthZeroFadeOutInBounds(); testDegenerateFlatBaseline(); From 99f377db28c95543ebe9548f07cc7e953e3a9afb Mon Sep 17 00:00:00 2001 From: daniel-c-harvey Date: Mon, 27 Jul 2026 19:09:47 -0400 Subject: [PATCH 2/2] FA2: param-domain Gate schematic + 8px node min-sep (all nodes grabbable at defaults); cross-mode drag guard; double-clamp px overflow fix --- src/vst/envelope_edit.cpp | 64 ++++++++++----- src/vst/envelope_edit.h | 27 ++++--- src/vst/envelope_overlay.cpp | 92 +++++++++++++++------- src/vst/envelope_overlay.h | 66 ++++++++++++---- tests/test_envelope_edit.cpp | 135 +++++++++++++++++++++++--------- tests/test_envelope_overlay.cpp | 118 ++++++++++++++++++++-------- 6 files changed, 360 insertions(+), 142 deletions(-) diff --git a/src/vst/envelope_edit.cpp b/src/vst/envelope_edit.cpp index 96e06e1..56381fa 100644 --- a/src/vst/envelope_edit.cpp +++ b/src/vst/envelope_edit.cpp @@ -23,13 +23,14 @@ double secondsPerPixel(const Rect& area, double totalSeconds) { return totalSeconds / static_cast(w); } -// Seconds per pixel in the GATE timed region (FA2): the Gate schematic maps A/H/D/R onto -// gateTimedWidth(area) px, not the full canvas, so a Gate time-node drag must use this scale for -// the handle to track the cursor. Matches envelope_overlay::gatePolyline. -double gateSecondsPerPixel(const Rect& area, double totalSeconds) { - const int w = gateTimedWidth(area); - if (w <= 0 || totalSeconds <= 0.0) return 0.0; - return totalSeconds / static_cast(w); +// Seconds per pixel for a GATE time-node drag (FA2): the reciprocal of the overlay's +// param-domain gatePxPerSecond(area) scale — sample-length-free, matching +// envelope_overlay::gatePolyline exactly so the dragged handle tracks the cursor 1:1 (each +// node's x is affine in its own segment duration with slope gatePxPerSecond). Zero when the +// area is degenerate. +double gateSecondsPerPixel(const Rect& area) { + const double pps = gatePxPerSecond(area); + return pps > 0.0 ? 1.0 / pps : 0.0; } // Level (0..1) represented by one vertical pixel. levelToY spans (height-1) rows for [0,1], so one @@ -51,20 +52,42 @@ bool isDraggable(EnvNode n) { } } +// True when the node belongs to the envelope's active mode. Guards the degenerate cross-mode +// write: the degenerate baseline polyline carries a ReleaseEnd vertex regardless of mode, so a +// zero-height Trigger-mode grab of it must not write releaseSeconds (and vice versa for Gate +// nodes vs Trigger fields). Applied by BOTH the hit-test and the drag resolver so they agree. +bool nodeInMode(EnvNode n, EnvMode m) { + switch (n) { + case EnvNode::AttackEnd: + case EnvNode::HoldEnd: + case EnvNode::DecayEnd: + case EnvNode::ReleaseEnd: + return m == EnvMode::Gate; + case EnvNode::FadeInEnd: + case EnvNode::FadeOutStart: + case EnvNode::LengthEnd: + return m == EnvMode::Trigger; + case EnvNode::Origin: + case EnvNode::ReleaseStart: + return false; // never draggable in any mode (isDraggable filters these anyway) + } + return false; +} + } // namespace NodeHit nodeAtPoint(const AmpEnvelope& env, const Rect& area, double totalSeconds, int x, int y) { const std::vector poly = buildEnvelopePolyline(env, area, totalSeconds); - // NEAREST draggable node within the pick radius wins (Chebyshev distance — the square grab - // box); ties break to the earlier draw-order node (FA2). Nearest-wins keeps every handle - // grabbable when nodes sit close (e.g. a short hold), while the draw-order tie-break makes - // exactly-coincident nodes deterministic: at zero fade-out, FadeOutStart overlays LengthEnd - // and WINS the tie, so the fade-out handle is grabbable at the right edge and can be dragged - // inward from zero. + // NEAREST draggable, mode-matching node within the pick radius wins (Chebyshev distance — + // the square grab box); ties break to the earlier draw-order node (FA2). Gate nodes never + // coincide (the forward map enforces kGateNodeSepPx separation), so the tie-break only + // matters for Trigger's zero-fade-out coincidence: FadeOutStart overlays LengthEnd, WINS the + // tie, and can be dragged inward from the right edge. The mode filter keeps the degenerate + // baseline's ReleaseEnd vertex from registering as a grabbable node in Trigger mode. NodeHit best; int bestDist = kNodeGrabRadius + 1; for (const EnvVertex& v : poly) { - if (!isDraggable(v.node)) continue; + if (!isDraggable(v.node) || !nodeInMode(v.node, env.mode)) continue; const int dist = std::max(std::abs(x - v.x), std::abs(y - v.y)); if (dist < bestDist) { // strictly closer only: earlier draw order keeps ties bestDist = dist; @@ -78,17 +101,16 @@ AmpEnvelope resolveNodeDrag(const AmpEnvelope& grabEnv, EnvNode node, const Rect double totalSeconds, const EnvClampBounds& bounds, int dxPixels, int dyPixels) { AmpEnvelope out = grabEnv; - if (!isDraggable(node)) return out; + if (!isDraggable(node) || !nodeInMode(node, grabEnv.mode)) return out; const double secPerPx = secondsPerPixel(area, totalSeconds); if (secPerPx <= 0.0) return out; // degenerate area / duration — no motion const double dSec = static_cast(dxPixels) * secPerPx; - // Gate time nodes live in the TIMED region of the Gate schematic (FA2), which is narrower - // than the canvas by the sustain-plateau reserve — their px->seconds scale differs so the - // dragged handle tracks the cursor 1:1. gateTimedWidth >= 1 whenever the area is non-empty, - // so gateDSec is well-defined past the degenerate guard above. - const double gateDSec = - static_cast(dxPixels) * gateSecondsPerPixel(area, totalSeconds); + // Gate time nodes use the schematic's PARAM-DOMAIN px->seconds scale (FA2) — the reciprocal + // of the overlay's gatePxPerSecond, sample-length-free — so the dragged handle tracks the + // cursor 1:1. gateTimedWidth >= 1 whenever the area is non-empty, so gateDSec is + // well-defined past the degenerate guard above. + const double gateDSec = static_cast(dxPixels) * gateSecondsPerPixel(area); switch (node) { // --- Gate: each cumulative-time node edits its OWN segment duration. Non-negative diff --git a/src/vst/envelope_edit.h b/src/vst/envelope_edit.h index 63c261c..abd7c62 100644 --- a/src/vst/envelope_edit.h +++ b/src/vst/envelope_edit.h @@ -25,10 +25,13 @@ // decay time, its Y sets the sustain level (the standard ADSR-editor grammar). Origin and the // drawing-only ReleaseStart vertex are NOT draggable. // -// GATE DRAG SCALE (FA2). Gate time nodes live in the Gate schematic's TIMED region -// (gateTimedWidth(area) px — the canvas minus the sustain-plateau reserve), so their px->seconds -// conversion uses that width, not the full canvas; Trigger nodes keep the full-canvas scale. -// Both match the forward map in envelope_overlay, so a dragged handle tracks the cursor 1:1. +// GATE DRAG SCALE (FA2). Gate time nodes convert px->seconds via the reciprocal of the +// schematic's PARAM-DOMAIN scale (envelope_overlay's gatePxPerSecond — sample-length-free), so +// a dragged handle tracks the cursor exactly 1:1 for stages within the schematic domain (each +// node's x is affine in its own segment duration). Trigger nodes keep the full-canvas +// PCM-aligned scale. Both match the forward map in envelope_overlay. A node is only editable in +// its OWN mode: Gate nodes ignore drags while the envelope is in Trigger mode and vice versa +// (guards the degenerate baseline's cross-mode ReleaseEnd vertex from writing releaseSeconds). // // Reuses editor_geometry's Rect + the EnvNode / AmpEnvelope / EnvMode types from // envelope_overlay (one shared node vocabulary across draw + edit), and the shared timeToX / @@ -69,11 +72,14 @@ struct EnvClampBounds { // Which node a grab at (x, y) lands on, given the CURRENT envelope + overlay rect + sample // duration (the same inputs buildEnvelopePolyline drew from, so the grab tests the drawn handles). // Returns EnvNode::Origin's NON-membership as a miss via the bool return: `hit` is false for a -// point off every DRAGGABLE node. Origin and ReleaseStart are never returned (not draggable). -// The NEAREST node within the radius wins (Chebyshev distance); an exact tie goes to the earlier -// draw-order node (FA2 — deterministic, and it makes coincident nodes grabbable: at zero -// fade-out, FadeOutStart overlays LengthEnd, wins the tie, and can be dragged inward from the -// right edge; at zero hold, AttackEnd wins over HoldEnd). Pure. +// point off every DRAGGABLE node. Origin and ReleaseStart are never returned (not draggable), +// and a node from the OTHER mode is never returned (the degenerate baseline's ReleaseEnd vertex +// is not grabbable in Trigger mode). The NEAREST node within the radius wins (Chebyshev +// distance); an exact tie goes to the earlier draw-order node (FA2 — deterministic). Gate nodes +// never coincide (the forward map enforces kGateNodeSepPx separation, so every Gate handle is +// individually grabbable in every state); the tie-break matters only for Trigger's zero-fade-out +// coincidence, where FadeOutStart overlays LengthEnd, wins the tie, and can be dragged inward +// from the right edge. Pure. struct NodeHit { bool hit = false; EnvNode node = EnvNode::Origin; // meaningful only when hit == true @@ -90,7 +96,8 @@ NodeHit nodeAtPoint(const AmpEnvelope& env, const Rect& area, double totalSecond // duration (e.g. dragging HoldEnd changes holdSeconds, not attack). // * Y delta -> the LEVEL param, but ONLY for the sustain node (DecayEnd); clamped to [0,1]. // dyPixels is IGNORED for every time-only node. -// * Non-draggable node (Origin / ReleaseStart) or a zero-width/zero-height area or +// * Non-draggable node (Origin / ReleaseStart), a node from the OTHER mode (a Gate node while +// grabEnv.mode is Trigger, or vice versa), a zero-width/zero-height area, or // totalSeconds <= 0 -> `grabEnv` returned unchanged (no motion). // Only the dragged node's param(s) change; every other field carries through from `grabEnv`. Pure // — rounding is to the param's continuous value (no snapping, matching the sliders' resolution). diff --git a/src/vst/envelope_overlay.cpp b/src/vst/envelope_overlay.cpp index 06e2029..f413e41 100644 --- a/src/vst/envelope_overlay.cpp +++ b/src/vst/envelope_overlay.cpp @@ -11,11 +11,11 @@ int timeToX(const Rect& area, double totalSeconds, double t) { if (w <= 0 || totalSeconds <= 0.0) return area.left; if (t < 0.0) t = 0.0; // Linear map, clamped on BOTH sides (FA2 bounds invariant): t past totalSeconds pins to the - // last in-bounds column area.right-1. Round to the nearest pixel. - const double frac = t / totalSeconds; - long xi = static_cast(frac * static_cast(w) + 0.5); - if (xi > w - 1) xi = w - 1; - return area.left + static_cast(xi); + // last in-bounds column area.right-1. Clamp in DOUBLE space BEFORE the integer cast — a huge + // t would overflow a 32-bit long (Windows) and wrap to the WRONG edge — then round. + double px = (t / totalSeconds) * static_cast(w); + if (px > static_cast(w - 1)) px = static_cast(w - 1); + return area.left + static_cast(px + 0.5); } int gateTimedWidth(const Rect& area) { @@ -26,6 +26,17 @@ int gateTimedWidth(const Rect& area) { return std::max(1, w - sustainPx); } +double gatePxPerSecond(const Rect& area) { + const int timedW = gateTimedWidth(area); + if (timedW <= 0) return 0.0; + // Usable width = timed region minus the four per-segment separation bases and the last + // in-bounds column, floored at 1 px so the scale never degenerates; the domain is the four + // stages end-to-end at their schematic maxima (param-domain scale — sample-length-free). + const double usable = + std::max(1.0, static_cast(timedW - 1 - 4 * kGateNodeSepPx)); + return usable / (4.0 * kGateStageMaxSeconds); +} + int levelToY(const Rect& area, double level) { const int h = std::max(0, area.height()); if (h <= 0) return area.top; @@ -56,22 +67,22 @@ EnvVertex vtx(EnvNode node, const Rect& area, double totalSeconds, double t, dou } // One Gate vertex from a pixel offset inside the area (the Gate schematic works in px space — -// timed px + the fixed sustain-plateau reserve — not through the plain timeToX map). Clamps x to -// the last in-bounds column (FA2 bounds invariant). +// timed px + the fixed sustain-plateau reserve — not through the plain timeToX map). Clamps x in +// DOUBLE space to the last in-bounds column BEFORE the integer cast (FA2 bounds invariant; a +// huge px would overflow a 32-bit long on Windows and wrap to the WRONG edge). EnvVertex gateVtx(EnvNode node, const Rect& area, double px, double level) { const int w = std::max(1, area.width()); - long xi = static_cast(px + 0.5); - if (xi < 0) xi = 0; - if (xi > w - 1) xi = w - 1; + if (px < 0.0) px = 0.0; + if (px > static_cast(w - 1)) px = static_cast(w - 1); EnvVertex v; v.node = node; - v.x = area.left + static_cast(xi); + v.x = area.left + static_cast(px + 0.5); v.y = levelToY(area, level); v.level = level; return v; } -std::vector gatePolyline(const AmpEnvelope& env, const Rect& area, double totalSeconds) { +std::vector gatePolyline(const AmpEnvelope& env, const Rect& area) { // Non-negative segment durations (a stored negative would be an upstream bug; clamp defensively). const double a = std::max(0.0, env.attackSeconds); const double h = std::max(0.0, env.holdSeconds); @@ -80,26 +91,47 @@ std::vector gatePolyline(const AmpEnvelope& env, const Rect& area, do const double sus = clamp01(env.sustainLevel); // BOUNDED SCHEMATIC (FA2): A/H/D and R map onto the TIMED region (canvas minus the reserved - // sustain-plateau width) at the sample's time scale; the sustain plateau is the fixed reserve - // between DecayEnd and ReleaseStart. Cumulative px, clamped in gateVtx, stay monotonic. - const int timedW = gateTimedWidth(area); - const int sustainPx = std::max(0, area.width()) - timedW; - const double pxPerSec = static_cast(timedW) / totalSeconds; + // sustain-plateau width) at the PARAM-DOMAIN scale — sample-length-free — and every segment + // gets a kGateNodeSepPx base so consecutive nodes never coincide (every node individually + // grabbable at any params, incl. the tier-0 zero-hold/zero-decay defaults). The sustain + // plateau is the fixed reserve between DecayEnd and ReleaseStart. + const int W = std::max(1, area.width()); + const double sustainPx = static_cast(W - gateTimedWidth(area)); + const double sep = static_cast(kGateNodeSepPx); + const double pps = gatePxPerSecond(area); - const double pxAttack = a * pxPerSec; - const double pxHold = (a + h) * pxPerSec; - const double pxDecay = (a + h + d) * pxPerSec; - const double pxPlateau = pxDecay + static_cast(sustainPx); // schematic note-off - const double pxRelease = pxPlateau + r * pxPerSec; + double xAttack = sep + a * pps; // AttackEnd + double xHold = xAttack + sep + h * pps; // HoldEnd + double xDecay = xHold + sep + d * pps; // DecayEnd (sustain node) + double xPlateau = xDecay + sustainPx; // ReleaseStart (schematic note-off) + double xRelease = xPlateau + sep + r * pps; // ReleaseEnd + + // Right-edge overrun (a stored stage beyond the schematic domain): compress from the RIGHT + // preserving the minimum gaps, so trailing nodes stay individually separated instead of + // piling on the last column. The re-floor pass only bites when the canvas is too narrow to + // hold the minimum gaps at all — then gateVtx's [0, W-1] clamp wins (in-bounds > separation). + const double xMax = static_cast(W - 1); + if (xRelease > xMax) { + xRelease = xMax; + xPlateau = std::min(xPlateau, xRelease - sep); + xDecay = std::min(xDecay, xPlateau - sustainPx); + xHold = std::min(xHold, xDecay - sep); + xAttack = std::min(xAttack, xHold - sep); + xAttack = std::max(xAttack, sep); + xHold = std::max(xHold, xAttack + sep); + xDecay = std::max(xDecay, xHold + sep); + xPlateau = std::max(xPlateau, xDecay + sustainPx); + xRelease = std::max(xRelease, xPlateau + sep); + } std::vector pts; pts.reserve(6); - pts.push_back(gateVtx(EnvNode::Origin, area, 0.0, 0.0)); - pts.push_back(gateVtx(EnvNode::AttackEnd, area, pxAttack, 1.0)); - pts.push_back(gateVtx(EnvNode::HoldEnd, area, pxHold, 1.0)); - pts.push_back(gateVtx(EnvNode::DecayEnd, area, pxDecay, sus)); // sustain node - pts.push_back(gateVtx(EnvNode::ReleaseStart, area, pxPlateau, sus)); // plateau end - pts.push_back(gateVtx(EnvNode::ReleaseEnd, area, pxRelease, 0.0)); + pts.push_back(gateVtx(EnvNode::Origin, area, 0.0, 0.0)); + pts.push_back(gateVtx(EnvNode::AttackEnd, area, xAttack, 1.0)); + pts.push_back(gateVtx(EnvNode::HoldEnd, area, xHold, 1.0)); + pts.push_back(gateVtx(EnvNode::DecayEnd, area, xDecay, sus)); // sustain node + pts.push_back(gateVtx(EnvNode::ReleaseStart, area, xPlateau, sus)); // plateau end + pts.push_back(gateVtx(EnvNode::ReleaseEnd, area, xRelease, 0.0)); return pts; } @@ -135,7 +167,9 @@ std::vector buildEnvelopePolyline(const AmpEnvelope& env, const Rect& return {vtx(EnvNode::Origin, area, 1.0, 0.0, 0.0), vtx(EnvNode::ReleaseEnd, area, 1.0, 1.0, 0.0)}; } - return env.mode == EnvMode::Gate ? gatePolyline(env, area, totalSeconds) + // Gate is a param-domain schematic — totalSeconds only gates the degenerate branch above + // (no loaded duration -> baseline); Trigger is PCM-aligned and consumes it. + return env.mode == EnvMode::Gate ? gatePolyline(env, area) : triggerPolyline(env, area, totalSeconds); } diff --git a/src/vst/envelope_overlay.h b/src/vst/envelope_overlay.h index 7ef671e..fc3780e 100644 --- a/src/vst/envelope_overlay.h +++ b/src/vst/envelope_overlay.h @@ -10,9 +10,14 @@ // sustain plateau, release sustain->0. Since there is no held note-off to draw // against, Gate is a BOUNDED SCHEMATIC (FA2): a fixed fraction of the canvas // width (kGateSustainDisplayFraction) is RESERVED for the sustain plateau, and -// the remaining "timed" width carries A/H/D AND the release at the sample's time -// scale — so A -> (H) -> D -> S-plateau -> R all render INSIDE the canvas and the -// release is a visible, draggable segment (it no longer trails past area.right). +// the remaining "timed" width carries A/H/D AND the release at the PARAM-DOMAIN +// scale — the timed width represents 4 x kGateStageMaxSeconds (the four stage +// sliders end-to-end at their maxima), NOT the sample's duration, so the layout +// is identical for a 0.3s and a 10s capture. Each segment additionally gets a +// kGateNodeSepPx pixel base, so consecutive nodes NEVER coincide: every Gate +// node is individually grabbable at ANY param values, including the tier-0 +// defaults (hold 0 / decay 0). A -> (H) -> D -> S-plateau -> R all render INSIDE +// the canvas and the release is a visible, draggable segment. // * Trigger -> the fade/%-length shape: fade-in 0->1, unity plateau, fade-out 1->0 anchored // to playEnd (= lengthFraction of the post-start span). Trigger keeps the // waveform's exact time base so the shape lines up with the PCM under it. @@ -30,11 +35,15 @@ // * ALL vertices are now in-bounds (see above). The shell's previous "skip handle when // v.x >= waveArea.right" clip is dead code: ReleaseEnd (Gate) and FadeOutStart/LengthEnd // (Trigger, at full length / zero fade-out) now land at area.right-1 and MUST get handles. -// * Gate's x-axis is schematic, not PCM-aligned (the sustain reserve compresses the timed -// region); Trigger's x-axis is still PCM-aligned. -// * nodeAtPoint (envelope_edit) now resolves to the NEAREST node within the grab radius, -// draw-order tie-break — coincident nodes (zero fade-out at the right edge, zero hold) are -// deterministically grabbable. +// * Gate's x-axis is SCHEMATIC, not PCM-aligned: the timed region is scaled to the param +// domain (4 x kGateStageMaxSeconds), the sustain reserve is a fixed width, and every +// segment carries a kGateNodeSepPx pixel base. The Gate curve does NOT line up with the +// waveform under it — do not label it as if it did. Trigger's x-axis IS still PCM-aligned. +// * Gate nodes never coincide (min-separation, above), so every Gate handle is individually +// grabbable in every state. nodeAtPoint (envelope_edit) resolves to the NEAREST node within +// the grab radius with a draw-order tie-break; the tie-break only matters for the one +// remaining coincidence, Trigger's zero-fade-out (FadeOutStart overlays LengthEnd at the +// right edge and wins the tie, so the fade can be dragged open from zero). // // DELIBERATELY ENGINE-FREE (house pattern — param_slider does the same). It does NOT depend on // sample_map / sampler_core (which would drag bank_book / wav_trim in). The shell reads the @@ -146,27 +155,52 @@ struct EnvVertex { // The fraction of the canvas width RESERVED for the Gate sustain-plateau display (FA2). The // plateau is a fixed-width schematic region between DecayEnd and ReleaseStart; the remaining -// width is the "timed" region A/H/D/R map onto at the sample's time scale. One constant shared -// by the forward map (here) and the inverse map (envelope_edit) so a drag tracks the cursor. +// width is the "timed" region A/H/D/R map onto at the schematic param-domain scale. One +// constant shared by the forward map (here) and the inverse map (envelope_edit). inline constexpr double kGateSustainDisplayFraction = 0.15; +// The minimum pixel separation between consecutive Gate polyline nodes: every Gate segment gets +// this many px as a base, PLUS its time-proportional extent, so zero-duration stages (tier-0 +// defaults: hold 0, decay 0) still render as distinct, individually grabbable handles. Chosen +// larger than envelope_edit's kNodeGrabRadius (6) so a click dead-on a node can never tie with +// its neighbour. Shared by the forward map and the drag inverse. +inline constexpr int kGateNodeSepPx = 8; + +// The Gate schematic's per-stage time domain (seconds): the timed region represents the four +// stages end-to-end at this maximum each (4 x this total). MIRRORS the shell's stage-slider +// ceiling (kEnvTimeMaxSeconds in reasampler_editor.cpp) — keep the two equal so a stage at its +// slider max lands exactly at the canvas edge. Drag safety does NOT depend on this constant +// (param clamps are caller-supplied in envelope_edit); only layout does. +inline constexpr double kGateStageMaxSeconds = 2.0; + // The pixel width of the Gate timed region: area.width() minus the sustain-plateau reserve, // floored at 1 px so the px<->seconds scale never degenerates for a non-empty area. Returns 0 // for a zero/negative-width area. Shared by gatePolyline and envelope_edit's gate drag scale. int gateTimedWidth(const Rect& area); +// Pixels per second of the Gate timed region under the PARAM-DOMAIN scale: the timed width, +// minus the four per-segment kGateNodeSepPx bases and the last in-bounds column, spread over +// 4 x kGateStageMaxSeconds. Independent of the sample's duration. Returns 0 for a +// zero/negative-width area; otherwise > 0 (the usable width floors at 1 px). The ONE px<->sec +// scale shared by the forward map (gatePolyline) and the drag inverse (envelope_edit), so a +// dragged handle tracks the cursor 1:1. +double gatePxPerSecond(const Rect& area); + // Map an amp envelope to its polyline vertices inside `area`, over a sample of `totalSeconds` // wall-clock duration. `area` is the waveform rect (left/top inclusive, right/bottom exclusive); // y maps level 0..1 across [area.bottom-1 .. area.top] (level 1 at the TOP). The polyline reads // left-to-right in draw order, Origin first. // // TIME BASE (FA2). -// * Gate: a bounded schematic. The canvas splits into a TIMED region of gateTimedWidth(area) -// px — where attack/hold/decay run from t=0 and the release ramp runs after the plateau, all -// at totalSeconds-over-timed-width scale — plus a FIXED sustain plateau of -// (width - timedWidth) px between DecayEnd and ReleaseStart (the schematic note-off). Every -// vertex x clamps to area.right-1, so when the stages overrun the visible span the trailing -// nodes pile up (still monotonic, still in-bounds, still draggable back left). +// * Gate: a bounded schematic, INDEPENDENT of totalSeconds. The canvas splits into a TIMED +// region of gateTimedWidth(area) px — where attack/hold/decay run from t=0 and the release +// ramp runs after the plateau, at the gatePxPerSecond(area) PARAM-DOMAIN scale, each segment +// carrying a kGateNodeSepPx base so consecutive nodes never coincide — plus a FIXED sustain +// plateau of (width - timedWidth) px between DecayEnd and ReleaseStart (the schematic +// note-off). Stages beyond the schematic domain (a stored stage > kGateStageMaxSeconds) +// compress from the RIGHT preserving the minimum gaps, so trailing nodes stay individually +// separated instead of piling on the last column; only a canvas too narrow to hold the +// minimum gaps at all sacrifices separation (in-bounds wins). // * Trigger: the waveform's exact time base (PCM-aligned). The played span is // lengthFraction * totalSeconds; fade-in/out are fractions OF that played span. Nodes past // the played span never appear (FadeOutStart/LengthEnd sit at the played span's right edge). diff --git a/tests/test_envelope_edit.cpp b/tests/test_envelope_edit.cpp index d94d9e0..6b40cac 100644 --- a/tests/test_envelope_edit.cpp +++ b/tests/test_envelope_edit.cpp @@ -4,19 +4,22 @@ // boundaries (the load-bearing "a drag can never produce a param a slider couldn't" invariant). // // Covers: nodeAtPoint (grabs a drawn handle within the pick radius; misses off every node; skips -// the non-draggable Origin/ReleaseStart anchors; NEAREST-node-wins with draw-order tie-break — -// FA2); resolveNodeDrag Gate (each cumulative node edits its OWN segment at the TIMED-region px -// scale; X->time, sustain node's Y->level; lower clamp at 0; upper clamp at the caller's max; -// only the dragged param changes; ReleaseEnd grabbable + draggable — FA2); resolveNodeDrag -// Trigger (fades as fractions of the played span; fadeIn/fadeOut mutual clamp so they never -// cross; length clamp; FadeOutStart moves OPPOSITE the pixel delta; zero-fade-out node grabbable -// at the right edge and draggable inward — FA2); degenerate area/duration + non-draggable node -// -> no motion. +// the non-draggable Origin/ReleaseStart anchors AND other-mode nodes; NEAREST-node-wins with +// draw-order tie-break; EVERY Gate node individually grabbable at the tier-0 defaults — FA2); +// resolveNodeDrag Gate (each cumulative node edits its OWN segment at the PARAM-DOMAIN px scale; +// X->time, sustain node's Y->level; lower clamp at 0; upper clamp at the caller's max; only the +// dragged param changes; ReleaseEnd grabbable + draggable; per-node drag round-trip tracks the +// cursor ~1:1 — FA2); resolveNodeDrag Trigger (fades as fractions of the played span; +// fadeIn/fadeOut mutual clamp so they never cross; length clamp; FadeOutStart moves OPPOSITE the +// pixel delta; zero-fade-out node grabbable at the right edge and draggable inward — FA2); +// degenerate area/duration + non-draggable node + cross-mode node -> no motion. #include "../src/vst/envelope_edit.h" #include #include +#include +#include using namespace reasampler::vst; @@ -26,12 +29,21 @@ static int g_fail = 0; static bool near(double a, double b, double eps = 1e-9) { return std::fabs(a - b) <= eps; } +// Find the first vertex with a given node in a polyline; asserts presence via the returned bool. +static bool findNode(const std::vector& poly, EnvNode node, EnvVertex& out) { + for (const EnvVertex& v : poly) { + if (v.node == node) { out = v; return true; } + } + return false; +} + // 1000px wide, 100px tall, offset origin. Trigger scale: 2.0s over 1000px => 0.002 s/px. Gate -// scale (FA2 schematic): 2.0s over the 850px TIMED region (150px sustain-plateau reserve) => -// 2/850 s/px, and the gateEnv() nodes draw at A x@85, H x@128, D x@255, RS x@405, RE x@575. +// scale (FA2 param-domain schematic — sample-length-free): (850-1-32)px over the 8.0s schematic +// domain => 102.125 px/s, each segment prefixed by the 8px separation base; the gateEnv() nodes +// draw at A x@28, H x@47, D x@85, RS x@235, RE x@284. static Rect wideArea() { return Rect{20, 10, 1020, 110}; } static constexpr double kTotal = 2.0; -static constexpr double kGateSecPerPx = kTotal / 850.0; +static const double kGateSecPerPx = 1.0 / gatePxPerSecond(wideArea()); static AmpEnvelope gateEnv() { AmpEnvelope e; @@ -58,11 +70,11 @@ static AmpEnvelope triggerEnv() { static void testHitGrabsDrawnHandle() { const AmpEnvelope e = gateEnv(); const Rect a = wideArea(); - // AttackEnd draws at x = left+85 (0.2s * 425 px/s in the timed region), y = top (level 1). - NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 85, a.top); + // AttackEnd draws at x = left+28 (8px base + 0.2s * 102.125 px/s), y = top (level 1). + NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 28, a.top); CHECK(h.hit && h.node == EnvNode::AttackEnd); - // The sustain node (DecayEnd) at 0.6s -> left+255, level 0.5 -> ~top+50. - NodeHit s = nodeAtPoint(e, a, kTotal, a.left + 255, a.top + 50); + // The sustain node (DecayEnd) at left+85, level 0.5 -> ~top+50. + NodeHit s = nodeAtPoint(e, a, kTotal, a.left + 85, a.top + 50); CHECK(s.hit && s.node == EnvNode::DecayEnd); } @@ -80,31 +92,39 @@ static void testHitSkipsNonDraggableAnchors() { // Origin draws at (left, bottom-1). Even a pixel-perfect grab there is NOT a draggable node. NodeHit o = nodeAtPoint(e, a, kTotal, a.left, a.bottom - 1); CHECK(!o.hit); - // ReleaseStart draws at (left+405, sustain level ~top+50) — the fixed plateau end. It is + // ReleaseStart draws at (left+235, sustain level ~top+50) — the fixed plateau end. It is // drawing-only -> not grabbable; no other node is within the radius, so this grab misses. - NodeHit rs = nodeAtPoint(e, a, kTotal, a.left + 405, a.top + 50); + NodeHit rs = nodeAtPoint(e, a, kTotal, a.left + 235, a.top + 50); CHECK(!rs.hit); } static void testHitNearestNodeWinsOverDrawOrder() { - // FA2 nearest-wins: with a SHORT hold, AttackEnd (x@85) and HoldEnd (x@89) both fall within - // the grab radius of a point at x@90 — the NEAREST (HoldEnd, 1px) must win, not the earlier - // draw-order AttackEnd (5px), so tightly packed handles stay individually grabbable. + // FA2 nearest-wins: with a SHORT hold, AttackEnd (x@28) and HoldEnd (x@37 — the 8px base + // plus 0.01s ~= 1px) both fall within the grab radius of a point at x@33 — the NEAREST + // (HoldEnd, 4px) must win, not the earlier draw-order AttackEnd (5px), so tightly packed + // handles stay individually grabbable. AmpEnvelope e = gateEnv(); - e.holdSeconds = 0.01; // hold end at 0.21s -> x@round(89.25)=89 + e.holdSeconds = 0.01; const Rect a = wideArea(); - NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 90, a.top); + NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 33, a.top); CHECK(h.hit && h.node == EnvNode::HoldEnd); } -static void testHitCoincidentNodesTieToEarlierDrawOrder() { - // Zero hold: AttackEnd and HoldEnd draw at the SAME pixel. The tie goes to the earlier - // draw-order node (AttackEnd) — deterministic, mirroring the pre-FA2 first-match rule. - AmpEnvelope e = gateEnv(); - e.holdSeconds = 0.0; +static void testGateDefaultsEveryNodeGrabbable() { + // THE FA2 headline regression: at the tier-0 Gate defaults (attack 3ms, hold 0, decay 0, + // sustain 1.0, release 60ms) the forward map's kGateNodeSepPx separation keeps every + // draggable node distinct, and a grab AT each drawn vertex resolves to THAT node — HoldEnd + // and DecayEnd are no longer shadowed by AttackEnd (pre-fix they were permanently + // ungrabbable in the default state). + const AmpEnvelope e; // struct defaults ARE the tier-0 Gate defaults const Rect a = wideArea(); - NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 85, a.top); - CHECK(h.hit && h.node == EnvNode::AttackEnd); + const std::vector poly = buildEnvelopePolyline(e, a, kTotal); + CHECK(poly.size() == 6); + for (const EnvVertex& v : poly) { + if (v.node == EnvNode::Origin || v.node == EnvNode::ReleaseStart) continue; + const NodeHit h = nodeAtPoint(e, a, kTotal, v.x, v.y); + CHECK(h.hit && h.node == v.node); + } } // --- resolveNodeDrag Gate ----------------------------------------------------- @@ -113,7 +133,7 @@ static void testGateAttackDragMovesOnlyAttack() { const AmpEnvelope e = gateEnv(); const Rect a = wideArea(); EnvClampBounds b; // default maxima 4.0s - // +50px at the GATE timed-region scale (2/850 s/px) on attack. Nothing else moves. + // +50px at the GATE param-domain scale (~0.0098 s/px) on attack. Nothing else moves. AmpEnvelope out = resolveNodeDrag(e, EnvNode::AttackEnd, a, kTotal, b, 50, 0); CHECK(near(out.attackSeconds, 0.2 + 50.0 * kGateSecPerPx)); CHECK(near(out.holdSeconds, e.holdSeconds)); @@ -126,7 +146,7 @@ static void testGateTimeLowerClampAtZero() { const AmpEnvelope e = gateEnv(); const Rect a = wideArea(); EnvClampBounds b; - // Drag attack far LEFT (-500px ~= -1.18s at the gate scale) from 0.2s: clamps to 0, never + // Drag attack far LEFT (-500px ~= -4.9s at the gate scale) from 0.2s: clamps to 0, never // negative (monotonic: the segment cannot go below zero). AmpEnvelope out = resolveNodeDrag(e, EnvNode::AttackEnd, a, kTotal, b, -500, 0); CHECK(near(out.attackSeconds, 0.0)); @@ -137,7 +157,7 @@ static void testGateTimeUpperClampAtSliderMax() { const Rect a = wideArea(); EnvClampBounds b; b.maxDecaySeconds = 1.0; // the shell's decay slider tops out at 1.0s - // Drag decay far RIGHT (+2000px ~= +4.7s at the gate scale) from 0.3s: clamps to the slider + // Drag decay far RIGHT (+2000px ~= +19.6s at the gate scale) from 0.3s: clamps to the slider // max 1.0, NOT beyond (the drag can't produce a param the slider couldn't). AmpEnvelope out = resolveNodeDrag(e, EnvNode::DecayEnd, a, kTotal, b, 2000, 0); CHECK(near(out.decaySeconds, 1.0)); @@ -179,11 +199,11 @@ static void testGateTimeOnlyNodeIgnoresY() { static void testGateReleaseEndGrabAndDrag() { // The FA2 fix: ReleaseEnd is a drawn, IN-BOUNDS, grabbable handle (pre-FA2 it mapped past - // area.right and could never be grabbed). gateEnv() draws it at x@575, level 0 (bottom row). + // area.right and could never be grabbed). gateEnv() draws it at x@284, level 0 (bottom row). const AmpEnvelope e = gateEnv(); const Rect a = wideArea(); EnvClampBounds b; - NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 575, a.bottom - 1); + NodeHit h = nodeAtPoint(e, a, kTotal, a.left + 284, a.bottom - 1); CHECK(h.hit && h.node == EnvNode::ReleaseEnd); // Dragging it RIGHT lengthens the release at the gate timed scale; only release changes. AmpEnvelope out = resolveNodeDrag(e, EnvNode::ReleaseEnd, a, kTotal, b, 85, 0); @@ -197,6 +217,31 @@ static void testGateReleaseEndGrabAndDrag() { CHECK(near(hi.releaseSeconds, b.maxReleaseSeconds)); } +static void testGateDragRoundTripTracksPixels() { + // 1:1 tracking (FA2): drag a Gate node by N px, rebuild the polyline from the edited params, + // and the node's drawn vertex has moved by ~N px (rounding may shift the landing by 1). The + // forward map is affine in each node's own segment duration with slope gatePxPerSecond and + // the inverse uses exactly the reciprocal, so the handle follows the cursor. + const AmpEnvelope e = gateEnv(); + const Rect a = wideArea(); + EnvClampBounds b; + const int dx = 25; + for (EnvNode n : {EnvNode::AttackEnd, EnvNode::HoldEnd, EnvNode::DecayEnd, + EnvNode::ReleaseEnd}) { + EnvVertex before, after; + CHECK(findNode(buildEnvelopePolyline(e, a, kTotal), n, before)); + const AmpEnvelope edited = resolveNodeDrag(e, n, a, kTotal, b, dx, 0); + CHECK(findNode(buildEnvelopePolyline(edited, a, kTotal), n, after)); + CHECK(std::abs((after.x - before.x) - dx) <= 1); + } + // The sustain node's Y axis tracks too: +10px down moves the drawn vertex ~10px down. + EnvVertex before, after; + CHECK(findNode(buildEnvelopePolyline(e, a, kTotal), EnvNode::DecayEnd, before)); + const AmpEnvelope edited = resolveNodeDrag(e, EnvNode::DecayEnd, a, kTotal, b, 0, 10); + CHECK(findNode(buildEnvelopePolyline(edited, a, kTotal), EnvNode::DecayEnd, after)); + CHECK(std::abs((after.y - before.y) - 10) <= 1); +} + // --- resolveNodeDrag Trigger -------------------------------------------------- static void testTriggerFadeInIsFractionOfPlaySpan() { @@ -289,12 +334,30 @@ static void testDegenerateAreaNoMotion() { CHECK(near(o2.attackSeconds, e.attackSeconds)); } +static void testCrossModeNodeNoMotion() { + // A node from the OTHER mode never writes (FA2 guard): the degenerate baseline polyline + // carries a ReleaseEnd vertex regardless of mode, so a Trigger-mode grab of it (e.g. over a + // zero-height canvas) must NOT write releaseSeconds — and symmetrically a Trigger node is + // inert on a Gate envelope. + EnvClampBounds b; + const AmpEnvelope t = triggerEnv(); + AmpEnvelope out = resolveNodeDrag(t, EnvNode::ReleaseEnd, wideArea(), kTotal, b, 50, 0); + CHECK(near(out.releaseSeconds, t.releaseSeconds)); + const AmpEnvelope g = gateEnv(); + out = resolveNodeDrag(g, EnvNode::FadeInEnd, wideArea(), kTotal, b, 50, 0); + CHECK(near(out.fadeInFraction, g.fadeInFraction)); + // And the zero-height baseline's ReleaseEnd is not even reported grabbable in Trigger mode. + const Rect flat = Rect{0, 0, 100, 0}; + const NodeHit h = nodeAtPoint(t, flat, kTotal, 99, 0); + CHECK(!h.hit); +} + int main() { testHitGrabsDrawnHandle(); testHitMissesOffEveryNode(); testHitSkipsNonDraggableAnchors(); testHitNearestNodeWinsOverDrawOrder(); - testHitCoincidentNodesTieToEarlierDrawOrder(); + testGateDefaultsEveryNodeGrabbable(); testGateAttackDragMovesOnlyAttack(); testGateTimeLowerClampAtZero(); @@ -303,6 +366,7 @@ int main() { testGateSustainLevelClamps01(); testGateTimeOnlyNodeIgnoresY(); testGateReleaseEndGrabAndDrag(); + testGateDragRoundTripTracksPixels(); testTriggerFadeInIsFractionOfPlaySpan(); testTriggerFadesCannotCross(); @@ -312,6 +376,7 @@ int main() { testNonDraggableNodeNoMotion(); testDegenerateAreaNoMotion(); + testCrossModeNodeNoMotion(); if (g_fail == 0) std::printf("envelope_edit: all tests passed\n"); else std::printf("envelope_edit: %d FAILED\n", g_fail); diff --git a/tests/test_envelope_overlay.cpp b/tests/test_envelope_overlay.cpp index 483ba62..bd09245 100644 --- a/tests/test_envelope_overlay.cpp +++ b/tests/test_envelope_overlay.cpp @@ -5,11 +5,14 @@ // fade/%-length shape at the waveform time base. // // Covers: timeToX / levelToY (linear maps, edge clamps, past-end CLAMPED to right-1 — the FA2 -// bounds invariant, degenerate area/duration); gateTimedWidth; buildEnvelopePolyline Gate (node -// order, levels, timed-region placement, fixed sustain-plateau reserve, release visible -// in-bounds, overrun pile-up clamped at the right edge, every vertex in-bounds); -// buildEnvelopePolyline Trigger (fade-in/unity/fade-out at fractions of the played span, overlap -// clamp, full-length/zero-fade-out nodes in-bounds at right-1); degenerate flat baseline. +// bounds invariant, no 32-bit overflow on huge times, degenerate area/duration); gateTimedWidth +// + gatePxPerSecond; buildEnvelopePolyline Gate (node order, levels, PARAM-DOMAIN timed-region +// placement independent of sample duration, per-segment kGateNodeSepPx separation — every node +// distinct even at the tier-0 zero-hold/zero-decay defaults, fixed sustain-plateau reserve, +// release visible in-bounds, overrun compressed from the right preserving the minimum gaps, +// every vertex in-bounds); buildEnvelopePolyline Trigger (fade-in/unity/fade-out at fractions of +// the played span, overlap clamp, full-length/zero-fade-out nodes in-bounds at right-1); +// degenerate flat baseline. #include "../src/vst/envelope_overlay.h" @@ -53,6 +56,9 @@ static void testTimeToXPastEndClamps() { const Rect a = wideArea(); CHECK(timeToX(a, 2.0, 3.0) == a.right - 1); CHECK(timeToX(a, 2.0, 1000.0) == a.right - 1); + // A HUGE t must clamp in double space, not overflow the integer cast (32-bit long on + // Windows would wrap to LONG_MIN and pin to the WRONG edge). + CHECK(timeToX(a, 2.0, 1e15) == a.right - 1); } static void testGateTimedWidth() { @@ -63,6 +69,15 @@ static void testGateTimedWidth() { CHECK(gateTimedWidth(Rect{0, 0, 1, 10}) == 1); } +static void testGatePxPerSecond() { + // PARAM-DOMAIN scale: (timedW - 1 - 4*sep) px spread over 4 x kGateStageMaxSeconds. For the + // 1000px canvas: (850 - 1 - 32) / 8.0s = 817/8 px/s. Independent of any sample duration. + const double expected = 817.0 / (4.0 * kGateStageMaxSeconds); + CHECK(gatePxPerSecond(wideArea()) == expected); + CHECK(gatePxPerSecond(Rect{5, 5, 5, 45}) == 0.0); // zero-width area -> 0 + CHECK(gatePxPerSecond(Rect{0, 0, 10, 10}) > 0.0); // tiny area: usable floors at 1px, > 0 +} + static void testTimeToXDegenerate() { const Rect a = wideArea(); CHECK(timeToX(a, 0.0, 1.0) == a.left); // no duration -> left @@ -118,26 +133,55 @@ static void testGateNodeOrderAndLevels() { } static void testGateSchematicPlacement() { - // FA2 bounded schematic: timed region = 850px (150px reserved plateau), total 2.0s => - // 425 px/s in the timed region. attack .2 -> x@85, hold end .3 -> x@round(127.5)=128, decay - // end .6 -> x@255. Plateau is the FIXED 150px reserve -> ReleaseStart x@405. Release .4 -> - // 170px ramp -> ReleaseEnd x@575, well inside the canvas. + // FA2 bounded schematic at the PARAM-DOMAIN scale: timed region = 850px (150px reserved + // plateau), pps = (850-1-32)/8s = 102.125 px/s, each segment prefixed by the 8px separation + // base. attack .2 -> x@round(8+20.425)=28; hold .1 -> x@round(28.425+8+10.2125)=47; decay + // .3 -> x@round(46.6375+8+30.6375)=85; plateau is the FIXED 150px reserve -> ReleaseStart + // x@235; release .4 -> x@round(235.275+8+40.85)=284, well inside the canvas. AmpEnvelope env; env.mode = EnvMode::Gate; env.attackSeconds = 0.2; - env.holdSeconds = 0.1; // hold end at 0.3s - env.decaySeconds = 0.3; // decay end at 0.6s + env.holdSeconds = 0.1; + env.decaySeconds = 0.3; env.sustainLevel = 0.5; env.releaseSeconds = 0.4; const Rect a = wideArea(); const std::vector poly = buildEnvelopePolyline(env, a, 2.0); EnvVertex v; - CHECK(findNode(poly, EnvNode::AttackEnd, v) && v.x == a.left + 85); - CHECK(findNode(poly, EnvNode::HoldEnd, v) && v.x == a.left + 128); - CHECK(findNode(poly, EnvNode::DecayEnd, v) && v.x == a.left + 255); - CHECK(findNode(poly, EnvNode::ReleaseStart, v) && v.x == a.left + 405); - CHECK(findNode(poly, EnvNode::ReleaseEnd, v) && v.x == a.left + 575); + CHECK(findNode(poly, EnvNode::AttackEnd, v) && v.x == a.left + 28); + CHECK(findNode(poly, EnvNode::HoldEnd, v) && v.x == a.left + 47); + CHECK(findNode(poly, EnvNode::DecayEnd, v) && v.x == a.left + 85); + CHECK(findNode(poly, EnvNode::ReleaseStart, v) && v.x == a.left + 235); + CHECK(findNode(poly, EnvNode::ReleaseEnd, v) && v.x == a.left + 284); +} + +static void testGateLayoutIndependentOfSampleDuration() { + // The Gate schematic is scaled by the PARAM domain, NOT the capture length: the same params + // produce the SAME polyline over a 0.3s and a 10s sample (pre-fix, a 60ms release on a 10s + // capture collapsed to ~5px while 2s stages on a 0.3s capture pinned to the right edge). + AmpEnvelope env; + env.mode = EnvMode::Gate; + env.attackSeconds = 0.2; + env.holdSeconds = 0.1; + env.decaySeconds = 0.3; + env.sustainLevel = 0.5; + env.releaseSeconds = 0.06; + const Rect a = wideArea(); + CHECK(buildEnvelopePolyline(env, a, 0.3) == buildEnvelopePolyline(env, a, 10.0)); +} + +static void testGateMinSeparationAtDefaults() { + // THE FA2 headline: at the tier-0 Gate defaults (attack 3ms, hold 0, decay 0, sustain 1.0, + // release 60ms) every consecutive node pair is at least kGateNodeSepPx apart — no node ever + // renders on top of its neighbour, so each is individually grabbable. + const AmpEnvelope env; // struct defaults ARE the tier-0 Gate defaults + const Rect a = wideArea(); + const std::vector poly = buildEnvelopePolyline(env, a, 2.0); + CHECK(poly.size() == 6); + for (size_t i = 1; i < poly.size(); ++i) { + CHECK(poly[i].x - poly[i - 1].x >= kGateNodeSepPx); + } } static void testGateSustainPlateauFixedWidth() { @@ -183,28 +227,32 @@ static void testGateReleaseVisibleInBounds() { CHECK(rel.level == 0.0); } -static void testGateOverrunClampsToCanvas() { - // A/H/D/R overrun the visible span (sum 3.5s > 2.0s total): the trailing nodes pile up at - // the last in-bounds column — monotonic, in-bounds, still individually draggable back left. - // NOTHING maps past area.right (the pre-FA2 release tail is gone). +static void testGateOverrunCompressesFromRight() { + // Stages BEYOND the schematic domain (4.0s each > kGateStageMaxSeconds): the layout + // compresses from the right preserving the minimum gaps — ReleaseEnd pins to the last + // in-bounds column, but the trailing nodes stay strictly increasing and individually + // separated (>= kGateNodeSepPx), NOT piled on one pixel. NOTHING maps past area.right. AmpEnvelope env; env.mode = EnvMode::Gate; - env.attackSeconds = 1.0; - env.holdSeconds = 1.0; - env.decaySeconds = 1.0; // decay end at 3.0s -> already past the timed span + env.attackSeconds = 4.0; + env.holdSeconds = 4.0; + env.decaySeconds = 4.0; env.sustainLevel = 0.7; - env.releaseSeconds = 0.5; + env.releaseSeconds = 4.0; const Rect a = wideArea(); const std::vector poly = buildEnvelopePolyline(env, a, 2.0); + CHECK(poly.size() == 6); - EnvVertex decay, plateauEnd, rel; - CHECK(findNode(poly, EnvNode::DecayEnd, decay)); + EnvVertex plateauEnd, rel; CHECK(findNode(poly, EnvNode::ReleaseStart, plateauEnd)); CHECK(findNode(poly, EnvNode::ReleaseEnd, rel)); - CHECK(decay.x == a.right - 1); // pinned to the last in-bounds column - CHECK(plateauEnd.x == a.right - 1); - CHECK(rel.x == a.right - 1); + CHECK(rel.x == a.right - 1); // pinned to the last in-bounds column CHECK(plateauEnd.level == 0.7); // still at sustain + for (size_t i = 1; i < poly.size(); ++i) { + CHECK(poly[i].x > poly[i - 1].x); // strictly monotonic + CHECK(poly[i].x - poly[i - 1].x >= kGateNodeSepPx - 1); // min gaps survive compression + CHECK(poly[i].x >= a.left && poly[i].x < a.right); // in-bounds + } } static void testGateAllVerticesInBounds() { @@ -223,8 +271,13 @@ static void testGateAllVerticesInBounds() { AmpEnvelope trig = base; trig.mode = EnvMode::Trigger; trig.lengthFraction = 1.0; trig.fadeInFraction = 0.0; trig.fadeOutFraction = 0.0; + // ABSURD stage values must clamp in double space, not overflow the integer cast (32-bit + // long on Windows would wrap negative and land on the WRONG edge). + AmpEnvelope huge = base; + huge.mode = EnvMode::Gate; + huge.releaseSeconds = 1e12; - for (const AmpEnvelope& env : {base, big, zero, trig}) { + for (const AmpEnvelope& env : {base, big, zero, trig, huge}) { for (const EnvVertex& v : buildEnvelopePolyline(env, a, 2.0)) { CHECK(v.x >= a.left && v.x < a.right); CHECK(v.y >= a.top && v.y < a.bottom); @@ -316,14 +369,17 @@ int main() { testTimeToXPastEndClamps(); testTimeToXDegenerate(); testGateTimedWidth(); + testGatePxPerSecond(); testLevelToYEndpoints(); testLevelToYClamps(); testGateNodeOrderAndLevels(); testGateSchematicPlacement(); + testGateLayoutIndependentOfSampleDuration(); + testGateMinSeparationAtDefaults(); testGateSustainPlateauFixedWidth(); testGateReleaseVisibleInBounds(); - testGateOverrunClampsToCanvas(); + testGateOverrunCompressesFromRight(); testGateAllVerticesInBounds(); testTriggerShape();