daniel
a1b42ed1a8
Generalize curveMidLevel/curveFromMidLevel to curveLevelAt/curveFromLevelAt at arbitrary phi; knotVtx and its drag inverse now read the phi a knot's truncated x actually implies, not always 0.5.
521 lines
25 KiB
C++
521 lines
25 KiB
C++
// 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 (every drawn handle grabbable, the anchored ReleaseEnd and the Origin
|
|
// never grabbed, other-kind nodes rejected, misses outside the radius, a dead coincident AHD
|
|
// DecayEnd excluded while a functional one stays grabbable); resolveNodeDrag (AHDSR stage nodes
|
|
// tracking the cursor across the TAPERED schematic and being its exact inverse, 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);
|
|
// the interaction law (Ctrl's rate on every axis, Shift's per-category snap); degenerate no-ops.
|
|
|
|
#include "../src/core/instrument/ui/envelope_edit.h"
|
|
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <vector>
|
|
|
|
using namespace reasampler;
|
|
using namespace reasampler::instrument::ui;
|
|
|
|
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 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;
|
|
|
|
// The shell's own domain (editor_controls' envClampBounds), so a drag here is clamped exactly
|
|
// where a knob is.
|
|
static EnvClampBounds bounds() {
|
|
EnvClampBounds b;
|
|
b.maxAttackSeconds = kGateStageMaxSeconds;
|
|
b.maxHoldSeconds = kGateStageMaxSeconds;
|
|
b.maxDecaySeconds = kGateStageMaxSeconds;
|
|
b.maxReleaseSeconds = kGateStageMaxSeconds;
|
|
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;
|
|
}
|
|
|
|
// F1's coincidence cases need attack/decay/fraction/span combinations ahdEnv() doesn't cover.
|
|
static StageEnvelope ahd(double a, double d, double frac, double origin, double span) {
|
|
StageEnvelope e;
|
|
e.kind = EnvKind::Ahd;
|
|
e.attackSeconds = a;
|
|
e.decaySeconds = d;
|
|
e.holdFraction = frac;
|
|
e.originSeconds = origin;
|
|
e.spanSeconds = span;
|
|
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;
|
|
}
|
|
|
|
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; }
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Grab exactly where the forward map drew the node.
|
|
static NodeHit grabAt(const StageEnvelope& e, EnvNode node) {
|
|
const Rect a = wideArea();
|
|
EnvVertex v;
|
|
if (!findNode(buildEnvelopePolyline(e, overlayOf(a), kTotal), node, v)) return NodeHit{};
|
|
return nodeAtPoint(e, overlayOf(a), kTotal, v.x, v.y);
|
|
}
|
|
|
|
// --- 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 testAnchoredEndAndOriginAreNotGrabbable() {
|
|
const StageEnvelope e = ahdsrEnv();
|
|
const Rect a = wideArea();
|
|
const std::vector<EnvVertex> poly = buildEnvelopePolyline(e, overlayOf(a), kTotal);
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
// F1: at the Trigger default (decay 0, holdFraction 1.0) DecayEnd sits on HoldEnd's own instant
|
|
// AND cannot move there (resolveNodeDrag's decay branch has derivative 0 — see the denom guard).
|
|
// A grab at its true (now un-nudged) position must miss rather than resolve to a dead handle;
|
|
// HoldEnd, the live node underneath, stays fully grabbable.
|
|
static void testDeadCoincidentDecayEndIsNotGrabbable() {
|
|
const StageEnvelope e = ahd(0.5, 0.0, 1.0, 0.0, 3.0);
|
|
CHECK(!grabAt(e, EnvNode::DecayEnd).hit);
|
|
CHECK(grabAt(e, EnvNode::HoldEnd).hit);
|
|
CHECK(grabAt(e, EnvNode::HoldEnd).node == EnvNode::HoldEnd);
|
|
}
|
|
|
|
// Coincidence alone does not drop DecayEnd — only holdFraction == 1.0 makes it truly dead. With
|
|
// holdFraction < 1 the X-drag still moves decaySeconds (denom > 0), so it stays grabbable even
|
|
// when decay is 0 and it starts out coincident with HoldEnd.
|
|
static void testFunctionalCoincidentDecayEndStaysGrabbable() {
|
|
const StageEnvelope e = ahd(0.5, 0.0, 0.5, 0.0, 3.0);
|
|
CHECK(grabAt(e, EnvNode::DecayEnd).hit);
|
|
CHECK(grabAt(e, EnvNode::DecayEnd).node == EnvNode::DecayEnd);
|
|
}
|
|
|
|
static void testMissOutsideTheRadius() {
|
|
const StageEnvelope e = ahdsrEnv();
|
|
const Rect a = wideArea();
|
|
// 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 ---------------------------------------------------------------
|
|
|
|
// The x position of node `n` as the FORWARD map draws it — the only thing a tapered-axis drag can
|
|
// be measured against, since there is no longer a fixed seconds-per-pixel rate to restate.
|
|
static int drawnX(const StageEnvelope& e, EnvNode n) {
|
|
EnvVertex v;
|
|
return findNode(buildEnvelopePolyline(e, overlayOf(wideArea()), kTotal), n, v) ? v.x : -1;
|
|
}
|
|
|
|
// The schematic axis IS the knob's taper, so what a stage node tracks is the CURSOR — at both
|
|
// ends of the range, which a fixed-rate inverse could not manage once the axis stopped being
|
|
// linear in seconds. Swept across four decades of stage time for exactly that reason.
|
|
static void testAhdsrStageNodesTrackTheCursorAcrossTheWholeRange() {
|
|
const Rect a = wideArea();
|
|
const double startTimes[] = {0.0, 0.003, 0.25, 2.0};
|
|
for (double t : startTimes) {
|
|
StageEnvelope e = ahdsrEnv();
|
|
e.attackSeconds = t;
|
|
const StageEnvelope moved =
|
|
resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), 40, 0);
|
|
CHECK(std::abs((drawnX(moved, EnvNode::AttackEnd) - drawnX(e, EnvNode::AttackEnd)) - 40)
|
|
<= 1);
|
|
CHECK(moved.attackSeconds > t);
|
|
CHECK(moved.holdSeconds == e.holdSeconds); // only the dragged param moves
|
|
}
|
|
// Hold and decay ride the same axis, in both directions.
|
|
const StageEnvelope e = ahdsrEnv();
|
|
const StageEnvelope hold =
|
|
resolveNodeDrag(e, EnvNode::HoldEnd, overlayOf(a), kTotal, bounds(), -20, 0);
|
|
CHECK(std::abs((drawnX(hold, EnvNode::HoldEnd) - drawnX(e, EnvNode::HoldEnd)) + 20) <= 1);
|
|
CHECK(hold.holdSeconds < e.holdSeconds);
|
|
const StageEnvelope decay =
|
|
resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 30, 0);
|
|
CHECK(std::abs((drawnX(decay, EnvNode::DecayEnd) - drawnX(e, EnvNode::DecayEnd)) - 30) <= 1);
|
|
CHECK(decay.decaySeconds > e.decaySeconds);
|
|
}
|
|
|
|
// The one-model rule, at the tapered axis: a node dragged to a pixel and the knob's value at that
|
|
// pixel are ONE number, so the inverse has to be EXACT and not merely close. A zero-delta drag
|
|
// reproduces the grab value bit for bit, and a drag out and straight back lands where it started.
|
|
static void testDrawAndDragAreExactInverses() {
|
|
const Rect a = wideArea();
|
|
// Four decades of stage time, stopping short of the clamp: a drag that saturates at the
|
|
// domain end deliberately does NOT come back (testStageTimesClampToTheKnobDomain owns that).
|
|
const double startTimes[] = {0.0, 0.003, 0.060, 1.0};
|
|
for (double t : startTimes) {
|
|
StageEnvelope e = ahdsrEnv();
|
|
e.attackSeconds = t;
|
|
CHECK(resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), 0, 0)
|
|
.attackSeconds == t);
|
|
const StageEnvelope out =
|
|
resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), 30, 0);
|
|
const StageEnvelope back =
|
|
resolveNodeDrag(out, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), -30, 0);
|
|
// The DRAWN node returns to the exact pixel it left, which is the property the one-model
|
|
// rule actually needs; the underlying seconds return to within the taper's own quantum
|
|
// read back through the map, which is proportional to the value.
|
|
CHECK(drawnX(back, EnvNode::AttackEnd) == drawnX(e, EnvNode::AttackEnd));
|
|
CHECK(std::fabs(back.attackSeconds - t) < 1e-6 * (t + 0.01));
|
|
}
|
|
}
|
|
|
|
// 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 StageEnvelope longer =
|
|
resolveNodeDrag(e, EnvNode::ReleaseStart, overlayOf(a), kTotal, bounds(), -40, 0);
|
|
CHECK(longer.releaseSeconds > e.releaseSeconds);
|
|
const StageEnvelope shorter =
|
|
resolveNodeDrag(e, EnvNode::ReleaseStart, overlayOf(a), kTotal, bounds(), 40, 0);
|
|
CHECK(shorter.releaseSeconds < e.releaseSeconds);
|
|
// The node still tracks the cursor, inverted sign notwithstanding.
|
|
CHECK(std::abs((drawnX(longer, EnvNode::ReleaseStart) -
|
|
drawnX(e, EnvNode::ReleaseStart)) + 40) <= 1);
|
|
}
|
|
|
|
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);
|
|
|
|
// DecayEnd's underlying param (decaySeconds) does NOT move 1:1 with the cursor: the drawn
|
|
// endpoint is t0 + total, and Hold eats a holdFraction share of whatever decay gives up
|
|
// (d(total)/d(decay) = 1 - holdFraction), so decaySeconds itself has to move faster than
|
|
// the cursor to make the DRAWN node track it. Assert on the RENDERED position, not the
|
|
// raw param — that is the property a drag actually has to deliver, and asserting the old
|
|
// 1:1 param delta here is exactly what let the node-tracking defect through undetected.
|
|
EnvVertex before;
|
|
CHECK(findNode(buildEnvelopePolyline(e, overlayOf(a), kTotal), EnvNode::DecayEnd, before));
|
|
const StageEnvelope decay =
|
|
resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 100, 0);
|
|
EnvVertex after;
|
|
CHECK(findNode(buildEnvelopePolyline(decay, overlayOf(a), kTotal), EnvNode::DecayEnd, after));
|
|
CHECK(std::abs((after.x - before.x) - 100) <= 1); // 1:1 with the cursor, to rounding
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
|
|
// A NEAR-level segment (sustain 0.99) is not caught by the exact-equality guard above, but its
|
|
// tiny divisor turns a one-pixel drag into a saturating swing of the exponent — the drag must
|
|
// still be a no-op rather than slam to a domain endpoint.
|
|
static void testKnotOnANearLevelSegmentIsANoOp() {
|
|
const Rect a = wideArea();
|
|
StageEnvelope e = ahdsrEnv();
|
|
e.sustainLevel = 0.99;
|
|
e.decayCurve = 2.5;
|
|
const StageEnvelope out =
|
|
resolveNodeDrag(e, EnvNode::DecayCurve, overlayOf(a), kTotal, bounds(), 0, -1);
|
|
CHECK(out.decayCurve == 2.5);
|
|
}
|
|
|
|
// The knot drag must read the SAME phi the draw used even off the segment midpoint (an odd
|
|
// pixel span), not the fixed phi = 0.5 wideArea()'s AttackCurve span happens to land on above.
|
|
// Checked two ways: a zero-delta grab reproduces the stored exponent, and a real one-pixel drag
|
|
// moves the knot's own drawn y by the same one pixel every other node axis tracks 1:1.
|
|
static void testKnotDragTracksTheDrawOnAnOddPixelSpan() {
|
|
bool found = false;
|
|
for (int width = 24; width <= 260 && !found; ++width) {
|
|
const Rect a = Rect::ltrb(0, 0, width, 100);
|
|
StageEnvelope e = ahdsrEnv();
|
|
e.attackCurve = 3.0;
|
|
EnvVertex origin, attackEnd, knot;
|
|
const std::vector<EnvVertex> poly = buildEnvelopePolyline(e, overlayOf(a), kTotal);
|
|
if (!findNode(poly, EnvNode::Origin, origin)) continue;
|
|
if (!findNode(poly, EnvNode::AttackEnd, attackEnd)) continue;
|
|
if (!findNode(poly, EnvNode::AttackCurve, knot)) continue;
|
|
const int span = attackEnd.x - origin.x;
|
|
if (span <= 0 || span % 2 == 0) continue;
|
|
found = true;
|
|
|
|
const StageEnvelope same =
|
|
resolveNodeDrag(e, EnvNode::AttackCurve, overlayOf(a), kTotal, bounds(), 0, 0);
|
|
CHECK(std::fabs(same.attackCurve - e.attackCurve) < 1e-9);
|
|
|
|
const StageEnvelope dragged =
|
|
resolveNodeDrag(e, EnvNode::AttackCurve, overlayOf(a), kTotal, bounds(), 0, 1);
|
|
EnvVertex knotAfter;
|
|
CHECK(findNode(buildEnvelopePolyline(dragged, overlayOf(a), kTotal), EnvNode::AttackCurve,
|
|
knotAfter));
|
|
CHECK(knotAfter.x == knot.x); // a curve drag never moves the knot's x
|
|
CHECK(std::abs(knotAfter.y - (knot.y + 1)) <= 1);
|
|
}
|
|
CHECK(found); // the sweep must actually land on an odd span
|
|
}
|
|
|
|
// --- the interaction law on the overlay ----------------------------------------
|
|
|
|
// Ctrl scales the PIXEL delta, so it composes with every axis — the tapered schematic, the 1:1
|
|
// wall clock, the level and the exponent — instead of each getting its own rule.
|
|
static void testCtrlScalesEveryAxisOfANodeDrag() {
|
|
const Rect a = wideArea();
|
|
const StageEnvelope e = ahdsrEnv();
|
|
const DragModifiers fine{false, true};
|
|
const int coarse = 10;
|
|
const int equivalent = static_cast<int>(coarse / kFineDragScale); // 200 fine px == 10 coarse
|
|
CHECK(std::fabs(
|
|
resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), equivalent,
|
|
0, fine).attackSeconds -
|
|
resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), coarse, 0)
|
|
.attackSeconds) < 1e-9);
|
|
CHECK(std::fabs(
|
|
resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 0,
|
|
equivalent, fine).sustainLevel -
|
|
resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 0, coarse)
|
|
.sustainLevel) < 1e-9);
|
|
// A zero delta is identical under either rate — the state the shell's re-anchor establishes
|
|
// at every modifier transition, and why the value cannot jump across one.
|
|
CHECK(resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), 0, 0, fine)
|
|
.attackSeconds == e.attackSeconds);
|
|
}
|
|
|
|
// Shift reaches the overlay because node, knot and knob are surfaces onto ONE model: a snap
|
|
// available on the knob and not on the node would be exactly the divergence that rule forbids.
|
|
// Each axis is asserted against the snap of ITS OWN category applied to the free drag's result —
|
|
// a node that routed a level through the millisecond snap, or snapped before the axis map rather
|
|
// than after it, fails here. The snaps themselves are param_taper's own tests.
|
|
static void testShiftSnapsEachAxisToItsOwnWholeUnit() {
|
|
const Rect a = wideArea();
|
|
const StageEnvelope e = ahdsrEnv();
|
|
const DragModifiers shift{true, false};
|
|
|
|
const StageEnvelope freeMs =
|
|
resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), 37, 0);
|
|
const StageEnvelope snapMs =
|
|
resolveNodeDrag(e, EnvNode::AttackEnd, overlayOf(a), kTotal, bounds(), 37, 0, shift);
|
|
CHECK(snapMs.attackSeconds == snapSecondsToWholeMs(freeMs.attackSeconds));
|
|
CHECK(snapMs.attackSeconds != freeMs.attackSeconds); // the drag really did move to the grid
|
|
CHECK(std::fabs(snapMs.attackSeconds - freeMs.attackSeconds) <= 0.0005 + 1e-12);
|
|
|
|
const StageEnvelope freeLevel =
|
|
resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 0, -13);
|
|
const StageEnvelope snapLevel =
|
|
resolveNodeDrag(e, EnvNode::DecayEnd, overlayOf(a), kTotal, bounds(), 0, -13, shift);
|
|
CHECK(snapLevel.sustainLevel == snapFractionToWholePercent(freeLevel.sustainLevel));
|
|
CHECK(std::fabs(snapLevel.sustainLevel - freeLevel.sustainLevel) <= 0.005 + 1e-12);
|
|
|
|
const StageEnvelope freeKnot =
|
|
resolveNodeDrag(e, EnvNode::AttackCurve, overlayOf(a), kTotal, bounds(), 0, 9);
|
|
const StageEnvelope snapKnot =
|
|
resolveNodeDrag(e, EnvNode::AttackCurve, overlayOf(a), kTotal, bounds(), 0, 9, shift);
|
|
CHECK(snapKnot.attackCurve == snapExponentToWhole(freeKnot.attackCurve));
|
|
CHECK(snapKnot.attackCurve != freeKnot.attackCurve);
|
|
|
|
// An AHD's Hold node edits a FRACTION, so its whole unit is a percent, not a millisecond.
|
|
const StageEnvelope freeFrac =
|
|
resolveNodeDrag(ahdEnv(), EnvNode::HoldEnd, overlayOf(a), kTotal, bounds(), 37, 0);
|
|
const StageEnvelope snapFrac = resolveNodeDrag(ahdEnv(), EnvNode::HoldEnd, overlayOf(a),
|
|
kTotal, bounds(), 37, 0, shift);
|
|
CHECK(snapFrac.holdFraction == snapFractionToWholePercent(freeFrac.holdFraction));
|
|
CHECK(snapFrac.holdFraction != freeFrac.holdFraction);
|
|
}
|
|
|
|
// --- 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() {
|
|
testEveryDrawnHandleIsGrabbable();
|
|
testAnchoredEndAndOriginAreNotGrabbable();
|
|
testAhdHasNoSustainNodes();
|
|
testDeadCoincidentDecayEndIsNotGrabbable();
|
|
testFunctionalCoincidentDecayEndStaysGrabbable();
|
|
testMissOutsideTheRadius();
|
|
|
|
testAhdsrStageNodesTrackTheCursorAcrossTheWholeRange();
|
|
testDrawAndDragAreExactInverses();
|
|
testReleaseDragsFromItsStartWithInvertedSign();
|
|
testSustainLevelOnTheDecayNodesYAxis();
|
|
testStageTimesClampToTheKnobDomain();
|
|
|
|
testAhdStageTimesTrackTheWallClockScale();
|
|
testAhdHoldNodeEditsTheFraction();
|
|
|
|
testCtrlScalesEveryAxisOfANodeDrag();
|
|
testShiftSnapsEachAxisToItsOwnWholeUnit();
|
|
|
|
testKnotDragMovesTheExponentWithinItsDomain();
|
|
testKnotAndModelCannotDiverge();
|
|
testKnotOnALevelSegmentIsANoOp();
|
|
testKnotOnANearLevelSegmentIsANoOp();
|
|
testKnotDragTracksTheDrawOnAnOddPixelSpan();
|
|
|
|
testDegenerateInputsAreNoOps();
|
|
|
|
if (g_fail == 0) std::printf("envelope_edit: all tests passed\n");
|
|
else std::printf("envelope_edit: %d FAILED\n", g_fail);
|
|
return g_fail == 0 ? 0 : 1;
|
|
}
|