daniel/reasampler
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Daniel Harvey
2026-07-27 18:25:03 -04:00
parent e2bd4f4351
commit d5d1902ea4
6 changed files with 392 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_envelope_overlay.cpp
+139 -33
View File
@@ -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<EnvVertex>& 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<EnvVertex> 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<EnvVertex> 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<EnvVertex> 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<EnvVertex> 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<EnvVertex> 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();