instrument: one staged-envelope system — per-segment curves, the sustain-less AHD, and a shared overlay for all three envelopes
Trigger's fade pair folds into the AHD (and goes live); the release anchors right; Preserve rings its synthetic tail out instead of cutting it. Payload v10.
This commit is contained in:
+262
-341
@@ -1,24 +1,19 @@
|
||||
// Standalone tests for reasampler::instrument::ui::envelope_edit — no VST3, no REAPER, no framework.
|
||||
// Same fast assert loop as the sibling pure tests. Assert the S-VIEW-3 draggable-node INVERSE
|
||||
// map: node hit-test + pixel-delta -> clamped/monotonic param set, HARD at the clamp + monotonic
|
||||
// boundaries (the load-bearing "a drag can never produce a param a slider couldn't" invariant).
|
||||
// Standalone tests for reasampler::instrument::ui::envelope_edit — no VST3, no REAPER, no
|
||||
// framework. Same fast assert loop as the sibling pure tests. Assert the INVERSE (edit) map
|
||||
// against envelope_overlay's forward map: a grab lands on the node that was drawn there, and a
|
||||
// pixel delta produces exactly the param a knob would have.
|
||||
//
|
||||
// Covers: nodeAtPoint (grabs a drawn handle within the pick radius; misses off every node; skips
|
||||
// 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.
|
||||
// Covers: nodeAtPoint (every drawn handle grabbable, the anchored ReleaseEnd and the Origin
|
||||
// never grabbed, other-kind nodes rejected, misses outside the radius); resolveNodeDrag
|
||||
// (AHDSR stage times at the schematic scale, the sustain level on Y, the release dragged from
|
||||
// its START with the inverted sign, the caller's clamp domain, AHD stage times at the 1:1
|
||||
// scale, the hold FRACTION); curve-knot drags (the exponent domain, its endpoints, and the
|
||||
// round trip through the shared law that keeps knot and dial on one value); degenerate no-ops.
|
||||
|
||||
#include "../src/core/instrument/ui/envelope_edit.h"
|
||||
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <vector>
|
||||
|
||||
using namespace reasampler;
|
||||
@@ -28,9 +23,41 @@ static int g_fail = 0;
|
||||
#define CHECK(cond) do { if(!(cond)) { \
|
||||
std::printf("FAIL line %d: %s\n", __LINE__, #cond); ++g_fail; } } while(0)
|
||||
|
||||
static bool near(double a, double b, double eps = 1e-9) { return std::fabs(a - b) <= eps; }
|
||||
static OverlayArea overlayOf(const Rect& r) { return OverlayArea{r}; }
|
||||
static Rect wideArea() { return Rect::ltrb(20, 10, 1020, 110); } // width 1000, height 100
|
||||
static constexpr double kTotal = 4.0;
|
||||
|
||||
static EnvClampBounds bounds() {
|
||||
EnvClampBounds b;
|
||||
b.maxAttackSeconds = 2.0;
|
||||
b.maxHoldSeconds = 2.0;
|
||||
b.maxDecaySeconds = 2.0;
|
||||
b.maxReleaseSeconds = 2.0;
|
||||
return b;
|
||||
}
|
||||
|
||||
static StageEnvelope ahdsrEnv() {
|
||||
StageEnvelope e;
|
||||
e.kind = EnvKind::Ahdsr;
|
||||
e.attackSeconds = 0.3;
|
||||
e.holdSeconds = 0.2;
|
||||
e.decaySeconds = 0.4;
|
||||
e.sustainLevel = 0.6;
|
||||
e.releaseSeconds = 0.5;
|
||||
return e;
|
||||
}
|
||||
|
||||
static StageEnvelope ahdEnv() {
|
||||
StageEnvelope e;
|
||||
e.kind = EnvKind::Ahd;
|
||||
e.attackSeconds = 0.4;
|
||||
e.decaySeconds = 0.6;
|
||||
e.holdFraction = 0.5;
|
||||
e.originSeconds = 0.0;
|
||||
e.spanSeconds = 3.0;
|
||||
return e;
|
||||
}
|
||||
|
||||
// Find the first vertex with a given node in a polyline; asserts presence via the returned bool.
|
||||
static bool findNode(const std::vector<EnvVertex>& poly, EnvNode node, EnvVertex& out) {
|
||||
for (const EnvVertex& v : poly) {
|
||||
if (v.node == node) { out = v; return true; }
|
||||
@@ -38,348 +65,242 @@ static bool findNode(const std::vector<EnvVertex>& poly, EnvNode node, EnvVertex
|
||||
return false;
|
||||
}
|
||||
|
||||
// 1000px wide, 100px tall, offset origin. Trigger scale: 2.0s over 1000px => 0.002 s/px. Gate
|
||||
// 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::ltrb(20, 10, 1020, 110); }
|
||||
static constexpr double kTotal = 2.0;
|
||||
|
||||
static OverlayArea overlayOf(const Rect& r) { return OverlayArea{r}; }
|
||||
static const double kGateSecPerPx = 1.0 / gatePxPerSecond(wideArea());
|
||||
|
||||
static AmpEnvelope gateEnv() {
|
||||
AmpEnvelope e;
|
||||
e.mode = EnvMode::Gate;
|
||||
e.attackSeconds = 0.2;
|
||||
e.holdSeconds = 0.1;
|
||||
e.decaySeconds = 0.3;
|
||||
e.sustainLevel = 0.5;
|
||||
e.releaseSeconds = 0.4;
|
||||
return e;
|
||||
}
|
||||
|
||||
static AmpEnvelope triggerEnv() {
|
||||
AmpEnvelope e;
|
||||
e.mode = EnvMode::Trigger;
|
||||
e.lengthFraction = 0.5; // played span 1.0s -> 500px
|
||||
e.fadeInFraction = 0.2;
|
||||
e.fadeOutFraction = 0.2;
|
||||
return e;
|
||||
}
|
||||
|
||||
// --- nodeAtPoint --------------------------------------------------------------
|
||||
|
||||
static void testHitGrabsDrawnHandle() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
// Grab exactly where the forward map drew the node.
|
||||
static NodeHit grabAt(const StageEnvelope& e, EnvNode node) {
|
||||
const Rect a = wideArea();
|
||||
// AttackEnd draws at x = left+28 (8px base + 0.2s * 102.125 px/s), y = top (level 1).
|
||||
NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 28, a.y);
|
||||
CHECK(h.hit && h.node == EnvNode::AttackEnd);
|
||||
// The sustain node (DecayEnd) at left+85, level 0.5 -> ~top+50.
|
||||
NodeHit s = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 85, a.y + 50);
|
||||
CHECK(s.hit && s.node == EnvNode::DecayEnd);
|
||||
EnvVertex v;
|
||||
if (!findNode(buildEnvelopePolyline(e, overlayOf(a), kTotal), node, v)) return NodeHit{};
|
||||
return nodeAtPoint(e, overlayOf(a), kTotal, v.x, v.y);
|
||||
}
|
||||
|
||||
static void testHitMissesOffEveryNode() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
const Rect a = wideArea();
|
||||
// A point far from any drawn handle (right of the release ramp, well away from a node).
|
||||
NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 700, a.y + 5);
|
||||
CHECK(!h.hit);
|
||||
// --- hit-test ------------------------------------------------------------------
|
||||
|
||||
static void testEveryDrawnHandleIsGrabbable() {
|
||||
const StageEnvelope e = ahdsrEnv();
|
||||
const EnvNode want[] = {EnvNode::AttackEnd, EnvNode::HoldEnd, EnvNode::DecayEnd,
|
||||
EnvNode::ReleaseStart, EnvNode::AttackCurve, EnvNode::DecayCurve,
|
||||
EnvNode::ReleaseCurve};
|
||||
for (EnvNode n : want) {
|
||||
const NodeHit h = grabAt(e, n);
|
||||
CHECK(h.hit);
|
||||
CHECK(h.node == n);
|
||||
}
|
||||
}
|
||||
|
||||
static void testHitSkipsNonDraggableAnchors() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
const Rect a = wideArea();
|
||||
// Origin draws at (left, bottom-1). Even a pixel-perfect grab there is NOT a draggable node.
|
||||
NodeHit o = nodeAtPoint(e, overlayOf(a), kTotal, a.x, a.bottom() - 1);
|
||||
CHECK(!o.hit);
|
||||
// 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, overlayOf(a), kTotal, a.x + 235, a.y + 50);
|
||||
CHECK(!rs.hit);
|
||||
}
|
||||
|
||||
static void testHitNearestNodeWinsOverDrawOrder() {
|
||||
// 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;
|
||||
const Rect a = wideArea();
|
||||
NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 33, a.y);
|
||||
CHECK(h.hit && h.node == EnvNode::HoldEnd);
|
||||
}
|
||||
|
||||
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
|
||||
static void testAnchoredEndAndOriginAreNotGrabbable() {
|
||||
const StageEnvelope e = ahdsrEnv();
|
||||
const Rect a = wideArea();
|
||||
const std::vector<EnvVertex> poly = buildEnvelopePolyline(e, overlayOf(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, overlayOf(a), kTotal, v.x, v.y);
|
||||
CHECK(h.hit && h.node == v.node);
|
||||
}
|
||||
EnvVertex end;
|
||||
CHECK(findNode(poly, EnvNode::ReleaseEnd, end));
|
||||
// The bottom-right corner is fixed: a grab there either misses or resolves to a NEIGHBOUR,
|
||||
// never to ReleaseEnd itself.
|
||||
const NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, end.x, end.y);
|
||||
CHECK(!h.hit || h.node != EnvNode::ReleaseEnd);
|
||||
EnvVertex origin;
|
||||
CHECK(findNode(poly, EnvNode::Origin, origin));
|
||||
const NodeHit o = nodeAtPoint(e, overlayOf(a), kTotal, origin.x, origin.y);
|
||||
CHECK(!o.hit || o.node != EnvNode::Origin);
|
||||
}
|
||||
|
||||
// --- resolveNodeDrag Gate -----------------------------------------------------
|
||||
static void testAhdHasNoSustainNodes() {
|
||||
const StageEnvelope e = ahdEnv();
|
||||
CHECK(grabAt(e, EnvNode::AttackEnd).hit);
|
||||
CHECK(grabAt(e, EnvNode::HoldEnd).hit);
|
||||
CHECK(grabAt(e, EnvNode::DecayEnd).hit);
|
||||
// ReleaseStart is not drawn on an AHD at all, so there is nothing to grab.
|
||||
CHECK(!grabAt(e, EnvNode::ReleaseStart).hit);
|
||||
// And an explicit resolve of an other-kind node is a no-op rather than a stray write.
|
||||
const StageEnvelope out = resolveNodeDrag(e, EnvNode::ReleaseStart, overlayOf(wideArea()),
|
||||
kTotal, bounds(), 40, 0);
|
||||
CHECK(out.releaseSeconds == e.releaseSeconds);
|
||||
CHECK(out.attackSeconds == e.attackSeconds);
|
||||
}
|
||||
|
||||
static void testGateAttackDragMovesOnlyAttack() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
static void testMissOutsideTheRadius() {
|
||||
const StageEnvelope e = ahdsrEnv();
|
||||
const Rect a = wideArea();
|
||||
EnvClampBounds b; // default maxima 4.0s
|
||||
// +50px at the GATE param-domain scale (~0.0098 s/px) on attack. Nothing else moves.
|
||||
AmpEnvelope out = resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, b, 50, 0);
|
||||
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));
|
||||
CHECK(near(out.releaseSeconds, e.releaseSeconds));
|
||||
}
|
||||
|
||||
static void testGateTimeLowerClampAtZero() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
const Rect a = wideArea();
|
||||
EnvClampBounds b;
|
||||
// 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, overlayOf(a), kTotal, b, -500, 0);
|
||||
CHECK(near(out.attackSeconds, 0.0));
|
||||
}
|
||||
|
||||
static void testGateTimeUpperClampAtSliderMax() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
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 ~= +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, overlayOf(a), kTotal, b, 2000, 0);
|
||||
CHECK(near(out.decaySeconds, 1.0));
|
||||
}
|
||||
|
||||
static void testGateSustainNodeBothAxes() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
const Rect a = wideArea();
|
||||
EnvClampBounds b;
|
||||
// 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, overlayOf(a), kTotal, b, 100, 10);
|
||||
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));
|
||||
}
|
||||
|
||||
static void testGateSustainLevelClamps01() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
const Rect a = wideArea();
|
||||
EnvClampBounds b;
|
||||
// Drag sustain UP hard (dy very negative): clamps to 1.0.
|
||||
AmpEnvelope up = resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, b, 0, -10000);
|
||||
CHECK(near(up.sustainLevel, 1.0));
|
||||
// Drag sustain DOWN hard (dy very positive): clamps to 0.0.
|
||||
AmpEnvelope dn = resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, b, 0, 10000);
|
||||
CHECK(near(dn.sustainLevel, 0.0));
|
||||
}
|
||||
|
||||
static void testGateTimeOnlyNodeIgnoresY() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
const Rect a = wideArea();
|
||||
EnvClampBounds b;
|
||||
// HoldEnd is time-only: a big Y delta must NOT change any level (there is no level to change).
|
||||
AmpEnvelope out = resolveNodeDrag(e, EnvNode::HoldEnd, overlayOf(a), kTotal, b, 0, 500);
|
||||
CHECK(near(out.holdSeconds, e.holdSeconds)); // dx 0 -> no time change either
|
||||
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@284, level 0 (bottom row).
|
||||
const AmpEnvelope e = gateEnv();
|
||||
const Rect a = wideArea();
|
||||
EnvClampBounds b;
|
||||
NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 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, overlayOf(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, overlayOf(a), kTotal, b, -2000, 0);
|
||||
CHECK(near(lo.releaseSeconds, 0.0));
|
||||
AmpEnvelope hi = resolveNodeDrag(e, EnvNode::ReleaseEnd, overlayOf(a), kTotal, b, 5000, 0);
|
||||
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, overlayOf(a), kTotal), n, before));
|
||||
const AmpEnvelope edited = resolveNodeDrag(e, n, overlayOf(a), kTotal, b, dx, 0);
|
||||
CHECK(findNode(buildEnvelopePolyline(edited, overlayOf(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, overlayOf(a), kTotal), EnvNode::DecayEnd, before));
|
||||
const AmpEnvelope edited = resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, b, 0, 10);
|
||||
CHECK(findNode(buildEnvelopePolyline(edited, overlayOf(a), kTotal), EnvNode::DecayEnd, after));
|
||||
CHECK(std::abs((after.y - before.y) - 10) <= 1);
|
||||
}
|
||||
|
||||
// --- resolveNodeDrag Trigger --------------------------------------------------
|
||||
|
||||
static void testTriggerFadeInIsFractionOfPlaySpan() {
|
||||
const AmpEnvelope e = triggerEnv(); // played span 1.0s -> 500px
|
||||
const Rect a = wideArea();
|
||||
EnvClampBounds b;
|
||||
// +50px = +0.1s on the play timeline = +0.1/1.0 = +0.1 fraction. fadeIn 0.2 -> 0.3.
|
||||
AmpEnvelope out = resolveNodeDrag(e, EnvNode::FadeInEnd, overlayOf(a), kTotal, b, 50, 0);
|
||||
CHECK(near(out.fadeInFraction, 0.3));
|
||||
CHECK(near(out.fadeOutFraction, e.fadeOutFraction)); // unchanged
|
||||
}
|
||||
|
||||
static void testTriggerFadesCannotCross() {
|
||||
AmpEnvelope e = triggerEnv();
|
||||
e.fadeInFraction = 0.5;
|
||||
e.fadeOutFraction = 0.3; // sum 0.8, room 0.2 before they'd cross
|
||||
const Rect a = wideArea();
|
||||
EnvClampBounds b;
|
||||
// Drag fade-in far RIGHT (+2000px): would push fadeIn well past 1-fadeOut=0.7, but the mutual
|
||||
// clamp caps it at 0.7 so the fade nodes never cross (monotonic on the play timeline).
|
||||
AmpEnvelope out = resolveNodeDrag(e, EnvNode::FadeInEnd, overlayOf(a), kTotal, b, 2000, 0);
|
||||
CHECK(near(out.fadeInFraction, 0.7));
|
||||
CHECK(near(out.fadeOutFraction, 0.3));
|
||||
}
|
||||
|
||||
static void testTriggerFadeOutMovesOppositePixelDelta() {
|
||||
const AmpEnvelope e = triggerEnv(); // fadeOut 0.2, play span 1.0s -> 500px
|
||||
const Rect a = wideArea();
|
||||
EnvClampBounds b;
|
||||
// FadeOutStart sits at (1-fadeOut) of the span; dragging it LEFT (-50px) LENGTHENS the fade-out.
|
||||
// -50px = -0.1s = -0.1 fraction on the span, applied OPPOSITE -> fadeOut 0.2 -> 0.3.
|
||||
AmpEnvelope out = resolveNodeDrag(e, EnvNode::FadeOutStart, overlayOf(a), kTotal, b, -50, 0);
|
||||
CHECK(near(out.fadeOutFraction, 0.3));
|
||||
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, overlayOf(a), kTotal, a.right() - 1, a.y);
|
||||
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, overlayOf(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, overlayOf(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();
|
||||
EnvClampBounds b; // maxLengthFraction 1.0
|
||||
// LengthEnd maps to a fraction of the WHOLE sample: +2000px = +4.0s = +2.0 fraction, clamps 1.0.
|
||||
AmpEnvelope out = resolveNodeDrag(e, EnvNode::LengthEnd, overlayOf(a), kTotal, b, 2000, 0);
|
||||
CHECK(near(out.lengthFraction, 1.0));
|
||||
// Drag far LEFT clamps to 0.
|
||||
AmpEnvelope lo = resolveNodeDrag(e, EnvNode::LengthEnd, overlayOf(a), kTotal, b, -2000, 0);
|
||||
CHECK(near(lo.lengthFraction, 0.0));
|
||||
}
|
||||
|
||||
// --- No-motion guards ---------------------------------------------------------
|
||||
|
||||
static void testNonDraggableNodeNoMotion() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
const Rect a = wideArea();
|
||||
EnvClampBounds b;
|
||||
AmpEnvelope o = resolveNodeDrag(e, EnvNode::Origin, overlayOf(a), kTotal, b, 500, 500);
|
||||
CHECK(near(o.attackSeconds, e.attackSeconds) && near(o.sustainLevel, e.sustainLevel));
|
||||
AmpEnvelope rs = resolveNodeDrag(e, EnvNode::ReleaseStart, overlayOf(a), kTotal, b, 500, 500);
|
||||
CHECK(near(rs.releaseSeconds, e.releaseSeconds));
|
||||
}
|
||||
|
||||
static void testDegenerateAreaNoMotion() {
|
||||
const AmpEnvelope e = gateEnv();
|
||||
EnvClampBounds b;
|
||||
const Rect zeroW = Rect::ltrb(0, 0, 0, 100);
|
||||
AmpEnvelope o1 = resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(zeroW), kTotal, b, 500, 0);
|
||||
CHECK(near(o1.attackSeconds, e.attackSeconds));
|
||||
AmpEnvelope o2 = resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(wideArea()), 0.0, b, 500, 0); // no time
|
||||
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, overlayOf(wideArea()), kTotal, b, 50, 0);
|
||||
CHECK(near(out.releaseSeconds, t.releaseSeconds));
|
||||
const AmpEnvelope g = gateEnv();
|
||||
out = resolveNodeDrag(g, EnvNode::FadeInEnd, overlayOf(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::ltrb(0, 0, 100, 0);
|
||||
const NodeHit h = nodeAtPoint(t, overlayOf(flat), kTotal, 99, 0);
|
||||
// Far from every handle in both axes.
|
||||
const NodeHit h = nodeAtPoint(e, overlayOf(a), kTotal, a.x + 3, a.bottom() - 40);
|
||||
CHECK(!h.hit);
|
||||
}
|
||||
|
||||
// --- AHDSR drags ---------------------------------------------------------------
|
||||
|
||||
static void testAhdsrStageTimesTrackTheSchematicScale() {
|
||||
const Rect a = wideArea();
|
||||
const StageEnvelope e = ahdsrEnv();
|
||||
const double secPerPx = 1.0 / gatePxPerSecond(a);
|
||||
|
||||
const StageEnvelope attack =
|
||||
resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), 50, 0);
|
||||
CHECK(std::fabs(attack.attackSeconds - (e.attackSeconds + 50 * secPerPx)) < 1e-9);
|
||||
CHECK(attack.holdSeconds == e.holdSeconds); // only the dragged param moves
|
||||
|
||||
const StageEnvelope hold =
|
||||
resolveNodeDrag(e, EnvNode::HoldEnd, overlayOf(a), kTotal, bounds(), -20, 0);
|
||||
CHECK(std::fabs(hold.holdSeconds - (e.holdSeconds - 20 * secPerPx)) < 1e-9);
|
||||
|
||||
const StageEnvelope decay =
|
||||
resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 30, 0);
|
||||
CHECK(std::fabs(decay.decaySeconds - (e.decaySeconds + 30 * secPerPx)) < 1e-9);
|
||||
}
|
||||
|
||||
// The release is dragged from its TOP node and its end is anchored to the canvas edge, so
|
||||
// pulling that node LEFT lengthens the release — the sign is inverted relative to every other
|
||||
// stage.
|
||||
static void testReleaseDragsFromItsStartWithInvertedSign() {
|
||||
const Rect a = wideArea();
|
||||
const StageEnvelope e = ahdsrEnv();
|
||||
const double secPerPx = 1.0 / gatePxPerSecond(a);
|
||||
const StageEnvelope longer =
|
||||
resolveNodeDrag(e, EnvNode::ReleaseStart, overlayOf(a), kTotal, bounds(), -40, 0);
|
||||
CHECK(std::fabs(longer.releaseSeconds - (e.releaseSeconds + 40 * secPerPx)) < 1e-9);
|
||||
const StageEnvelope shorter =
|
||||
resolveNodeDrag(e, EnvNode::ReleaseStart, overlayOf(a), kTotal, bounds(), 40, 0);
|
||||
CHECK(shorter.releaseSeconds < e.releaseSeconds);
|
||||
}
|
||||
|
||||
static void testSustainLevelOnTheDecayNodesYAxis() {
|
||||
const Rect a = wideArea();
|
||||
const StageEnvelope e = ahdsrEnv();
|
||||
const double lvlPerPx = 1.0 / (a.height - 1);
|
||||
const StageEnvelope up =
|
||||
resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 0, -10);
|
||||
CHECK(std::fabs(up.sustainLevel - (e.sustainLevel + 10 * lvlPerPx)) < 1e-9);
|
||||
// Clamped to [0,1] at both ends.
|
||||
CHECK(resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 0, -10000)
|
||||
.sustainLevel == 1.0);
|
||||
CHECK(resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 0, 10000)
|
||||
.sustainLevel == 0.0);
|
||||
}
|
||||
|
||||
static void testStageTimesClampToTheKnobDomain() {
|
||||
const Rect a = wideArea();
|
||||
const StageEnvelope e = ahdsrEnv();
|
||||
CHECK(resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), 100000, 0)
|
||||
.attackSeconds == bounds().maxAttackSeconds);
|
||||
CHECK(resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), -100000, 0)
|
||||
.attackSeconds == 0.0);
|
||||
}
|
||||
|
||||
// --- AHD drags -----------------------------------------------------------------
|
||||
|
||||
static void testAhdStageTimesTrackTheWallClockScale() {
|
||||
const Rect a = wideArea();
|
||||
const StageEnvelope e = ahdEnv();
|
||||
const double secPerPx = kTotal / a.width;
|
||||
const StageEnvelope attack =
|
||||
resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), 100, 0);
|
||||
CHECK(std::fabs(attack.attackSeconds - (e.attackSeconds + 100 * secPerPx)) < 1e-9);
|
||||
const StageEnvelope decay =
|
||||
resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 100, 0);
|
||||
CHECK(std::fabs(decay.decaySeconds - (e.decaySeconds + 100 * secPerPx)) < 1e-9);
|
||||
}
|
||||
|
||||
// Hold is a fraction of what attack and decay left, so the node's pixel motion converts through
|
||||
// that remainder — and the fraction can never leave [0,1], which is what keeps the sum bounded.
|
||||
static void testAhdHoldNodeEditsTheFraction() {
|
||||
const Rect a = wideArea();
|
||||
const StageEnvelope e = ahdEnv();
|
||||
const double secPerPx = kTotal / a.width;
|
||||
const AhdSplit s = splitAhdSeconds(e);
|
||||
const double rem = e.spanSeconds - s.attack - s.decay;
|
||||
const StageEnvelope moved =
|
||||
resolveNodeDrag(e, EnvNode::HoldEnd, overlayOf(a), kTotal, bounds(), 100, 0);
|
||||
CHECK(std::fabs(moved.holdFraction - ((s.hold + 100 * secPerPx) / rem)) < 1e-9);
|
||||
CHECK(resolveNodeDrag(e, EnvNode::HoldEnd, overlayOf(a), kTotal, bounds(), 100000, 0)
|
||||
.holdFraction == 1.0);
|
||||
CHECK(resolveNodeDrag(e, EnvNode::HoldEnd, overlayOf(a), kTotal, bounds(), -100000, 0)
|
||||
.holdFraction == 0.0);
|
||||
}
|
||||
|
||||
// --- curve knots ---------------------------------------------------------------
|
||||
|
||||
static void testKnotDragMovesTheExponentWithinItsDomain() {
|
||||
const Rect a = wideArea();
|
||||
StageEnvelope e = ahdsrEnv();
|
||||
e.attackCurve = util::kCurveNeutral;
|
||||
const StageEnvelope up =
|
||||
resolveNodeDrag(e, EnvNode::AttackCurve, overlayOf(a), kTotal, bounds(), 0, -12);
|
||||
const StageEnvelope down =
|
||||
resolveNodeDrag(e, EnvNode::AttackCurve, overlayOf(a), kTotal, bounds(), 0, 12);
|
||||
// Dragging the attack knot UP (toward the ceiling) is a faster-rising, SMALLER exponent.
|
||||
CHECK(up.attackCurve < util::kCurveNeutral);
|
||||
CHECK(down.attackCurve > util::kCurveNeutral);
|
||||
CHECK(up.attackCurve >= util::kCurveMin && up.attackCurve <= util::kCurveMax);
|
||||
CHECK(down.attackCurve >= util::kCurveMin && down.attackCurve <= util::kCurveMax);
|
||||
// Extreme drags saturate at the domain endpoints rather than escaping them.
|
||||
CHECK(resolveNodeDrag(e, EnvNode::AttackCurve, overlayOf(a), kTotal, bounds(), 0, -100000)
|
||||
.attackCurve == util::kCurveMin);
|
||||
CHECK(resolveNodeDrag(e, EnvNode::AttackCurve, overlayOf(a), kTotal, bounds(), 0, 100000)
|
||||
.attackCurve == util::kCurveMax);
|
||||
// Only the dragged segment's exponent moves.
|
||||
CHECK(up.decayCurve == e.decayCurve && up.releaseCurve == e.releaseCurve);
|
||||
CHECK(up.attackSeconds == e.attackSeconds);
|
||||
}
|
||||
|
||||
// The one-model rule, asserted structurally: the drawn knot's height IS the shared law's
|
||||
// reading of the stored exponent, and a zero-delta drag from that grab reproduces the exponent
|
||||
// exactly — so the overlay and the inner dial cannot express different values for one field.
|
||||
static void testKnotAndModelCannotDiverge() {
|
||||
const Rect a = wideArea();
|
||||
for (double exp : {0.2, 0.5, 1.0, 2.0, 7.0}) {
|
||||
StageEnvelope e = ahdsrEnv();
|
||||
e.attackCurve = exp;
|
||||
EnvVertex knot;
|
||||
CHECK(findNode(buildEnvelopePolyline(e, overlayOf(a), kTotal), EnvNode::AttackCurve,
|
||||
knot));
|
||||
CHECK(std::fabs(knot.level - util::curveMidLevel(exp)) < 1e-12);
|
||||
const StageEnvelope same =
|
||||
resolveNodeDrag(e, EnvNode::AttackCurve, overlayOf(a), kTotal, bounds(), 0, 0);
|
||||
CHECK(std::fabs(same.attackCurve - exp) < 1e-9);
|
||||
}
|
||||
}
|
||||
|
||||
// A decay into a sustain of exactly 1.0 is a LEVEL segment: there is no curve to express, so
|
||||
// the drag must leave the exponent alone rather than divide by a zero level span.
|
||||
static void testKnotOnALevelSegmentIsANoOp() {
|
||||
const Rect a = wideArea();
|
||||
StageEnvelope e = ahdsrEnv();
|
||||
e.sustainLevel = 1.0;
|
||||
e.decayCurve = 2.5;
|
||||
const StageEnvelope out =
|
||||
resolveNodeDrag(e, EnvNode::DecayCurve, overlayOf(a), kTotal, bounds(), 0, -30);
|
||||
CHECK(out.decayCurve == 2.5);
|
||||
}
|
||||
|
||||
// --- degenerate ----------------------------------------------------------------
|
||||
|
||||
static void testDegenerateInputsAreNoOps() {
|
||||
const StageEnvelope e = ahdsrEnv();
|
||||
const StageEnvelope zeroArea =
|
||||
resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(Rect{}), kTotal, bounds(), 50, 0);
|
||||
CHECK(zeroArea.attackSeconds == e.attackSeconds);
|
||||
const StageEnvelope zeroDur =
|
||||
resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(wideArea()), 0.0, bounds(), 50, 0);
|
||||
CHECK(zeroDur.attackSeconds == e.attackSeconds);
|
||||
}
|
||||
|
||||
int main() {
|
||||
testHitGrabsDrawnHandle();
|
||||
testHitMissesOffEveryNode();
|
||||
testHitSkipsNonDraggableAnchors();
|
||||
testHitNearestNodeWinsOverDrawOrder();
|
||||
testGateDefaultsEveryNodeGrabbable();
|
||||
testEveryDrawnHandleIsGrabbable();
|
||||
testAnchoredEndAndOriginAreNotGrabbable();
|
||||
testAhdHasNoSustainNodes();
|
||||
testMissOutsideTheRadius();
|
||||
|
||||
testGateAttackDragMovesOnlyAttack();
|
||||
testGateTimeLowerClampAtZero();
|
||||
testGateTimeUpperClampAtSliderMax();
|
||||
testGateSustainNodeBothAxes();
|
||||
testGateSustainLevelClamps01();
|
||||
testGateTimeOnlyNodeIgnoresY();
|
||||
testGateReleaseEndGrabAndDrag();
|
||||
testGateDragRoundTripTracksPixels();
|
||||
testAhdsrStageTimesTrackTheSchematicScale();
|
||||
testReleaseDragsFromItsStartWithInvertedSign();
|
||||
testSustainLevelOnTheDecayNodesYAxis();
|
||||
testStageTimesClampToTheKnobDomain();
|
||||
|
||||
testTriggerFadeInIsFractionOfPlaySpan();
|
||||
testTriggerFadesCannotCross();
|
||||
testTriggerFadeOutMovesOppositePixelDelta();
|
||||
testTriggerZeroFadeOutGrabbableAtRightEdge();
|
||||
testTriggerLengthClampsAtMax();
|
||||
testAhdStageTimesTrackTheWallClockScale();
|
||||
testAhdHoldNodeEditsTheFraction();
|
||||
|
||||
testNonDraggableNodeNoMotion();
|
||||
testDegenerateAreaNoMotion();
|
||||
testCrossModeNodeNoMotion();
|
||||
testKnotDragMovesTheExponentWithinItsDomain();
|
||||
testKnotAndModelCannotDiverge();
|
||||
testKnotOnALevelSegmentIsANoOp();
|
||||
|
||||
testDegenerateInputsAreNoOps();
|
||||
|
||||
if (g_fail == 0) std::printf("envelope_edit: all tests passed\n");
|
||||
else std::printf("envelope_edit: %d FAILED\n", g_fail);
|
||||
|
||||
Reference in New Issue
Block a user