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_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).