405 lines
18 KiB
C++
405 lines
18 KiB
C++
// Standalone tests for reasampler::instrument::ui::envelope_overlay — no VST3, no REAPER, no
|
|
// framework. Same fast assert loop as the sibling pure tests. Assert the staged-envelope ->
|
|
// polyline FORWARD map for BOTH layout policies: the AHDSR bounded schematic with its
|
|
// RIGHT-ANCHORED release, and the sustain-less AHD laid 1:1 over the waveform's time axis.
|
|
//
|
|
// Covers: timeToX / levelToY (linear maps, edge clamps, past-end clamped to right-1, no 32-bit
|
|
// overflow on huge times, degenerate area/duration); gatePxPerSecond; the AHDSR polyline (node
|
|
// order, levels, release anchored at the right edge, the sustain plateau reaching the edge at
|
|
// zero release, per-segment separation at the tier-0 defaults, overrun compression, every
|
|
// vertex in-bounds); splitAhdSeconds (A+H+D never exceeds the span, hold at 0% and 100%); the
|
|
// AHD polyline (1:1 with the time axis, origin offset); curve knots (present only on sloped
|
|
// non-zero segments, height following the exponent); the degenerate flat baseline.
|
|
|
|
#include "../src/core/instrument/ui/envelope_overlay.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}; }
|
|
|
|
// A comfortable overlay area: 1000px wide, 100px tall, offset so left/top != 0 (catches origin
|
|
// bugs). Under levelToY the level span is height-1 = 99 rows.
|
|
static Rect wideArea() { return Rect::ltrb(20, 10, 1020, 110); } // width 1000, height 100
|
|
|
|
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;
|
|
}
|
|
static bool hasNode(const std::vector<EnvVertex>& poly, EnvNode node) {
|
|
EnvVertex v;
|
|
return findNode(poly, node, v);
|
|
}
|
|
|
|
static StageEnvelope ahdsr(double a, double h, double d, double sus, double r) {
|
|
StageEnvelope e;
|
|
e.kind = EnvKind::Ahdsr;
|
|
e.attackSeconds = a;
|
|
e.holdSeconds = h;
|
|
e.decaySeconds = d;
|
|
e.sustainLevel = sus;
|
|
e.releaseSeconds = r;
|
|
return e;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
// --- timeToX / levelToY -------------------------------------------------------
|
|
|
|
static void testTimeToXEndpoints() {
|
|
const Rect a = wideArea();
|
|
CHECK(timeToX(a, 2.0, 0.0) == a.x); // 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.x + 500); // midpoint
|
|
}
|
|
|
|
static void testTimeToXClampsBothEnds() {
|
|
const Rect a = wideArea();
|
|
CHECK(timeToX(a, 2.0, -0.5) == a.x);
|
|
CHECK(timeToX(a, 2.0, 3.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 testLevelToY() {
|
|
const Rect a = wideArea();
|
|
CHECK(levelToY(a, 1.0) == a.y); // level 1 -> top row
|
|
CHECK(levelToY(a, 0.0) == a.bottom() - 1); // level 0 -> bottom row
|
|
CHECK(levelToY(a, 0.5) == a.y + 50); // 99-row span, rounded
|
|
CHECK(levelToY(a, 5.0) == a.y); // clamps
|
|
CHECK(levelToY(a, -5.0) == a.bottom() - 1);
|
|
}
|
|
|
|
static void testDegenerateAreaAndDuration() {
|
|
CHECK(timeToX(Rect{}, 2.0, 1.0) == 0);
|
|
CHECK(timeToX(wideArea(), 0.0, 1.0) == wideArea().x);
|
|
CHECK(levelToY(Rect{}, 0.5) == 0);
|
|
CHECK(gatePxPerSecond(Rect{}) == 0.0);
|
|
}
|
|
|
|
// The literal PARAM-DOMAIN scale, independent of any sample duration: usable px = canvas width
|
|
// minus the last column minus 4 node-separation bases, spread over 4 x kGateStageMaxSeconds.
|
|
// This is what makes a dragged handle track the cursor 1:1 (envelope_edit's own inverse reads
|
|
// this same function) — a scale regression here is exactly what a relational-only check misses.
|
|
static void testGatePxPerSecond() {
|
|
const double expected =
|
|
(1000.0 - 1.0 - 4.0 * kGateNodeSepPx) / (4.0 * kGateStageMaxSeconds); // 967/8 px/s
|
|
CHECK(gatePxPerSecond(wideArea()) == expected);
|
|
CHECK(gatePxPerSecond(Rect::ltrb(5, 5, 5, 45)) == 0.0); // zero-width area -> 0
|
|
CHECK(gatePxPerSecond(Rect::ltrb(0, 0, 10, 10)) > 0.0); // tiny area: usable floors at 1px, > 0
|
|
}
|
|
|
|
// --- the AHDSR schematic ------------------------------------------------------
|
|
|
|
static void testAhdsrNodeOrderAndLevels() {
|
|
const Rect a = wideArea();
|
|
const std::vector<EnvVertex> poly =
|
|
buildEnvelopePolyline(ahdsr(0.2, 0.1, 0.3, 0.5, 0.4), overlayOf(a), 4.0);
|
|
EnvVertex v;
|
|
CHECK(poly.size() >= 6);
|
|
CHECK(poly[0].node == EnvNode::Origin && poly[0].level == 0.0);
|
|
CHECK(poly[1].node == EnvNode::AttackEnd && poly[1].level == 1.0);
|
|
CHECK(poly[2].node == EnvNode::HoldEnd && poly[2].level == 1.0);
|
|
CHECK(poly[3].node == EnvNode::DecayEnd && poly[3].level == 0.5);
|
|
CHECK(poly[4].node == EnvNode::ReleaseStart && poly[4].level == 0.5);
|
|
CHECK(poly[5].node == EnvNode::ReleaseEnd && poly[5].level == 0.0);
|
|
// Monotone in x across the traced line.
|
|
for (std::size_t i = 1; i < 6; ++i) CHECK(poly[i].x >= poly[i - 1].x);
|
|
// Every vertex in-bounds.
|
|
for (const EnvVertex& p : poly) {
|
|
CHECK(p.x >= a.x && p.x <= a.right() - 1);
|
|
CHECK(p.y >= a.y && p.y <= a.bottom() - 1);
|
|
}
|
|
CHECK(findNode(poly, EnvNode::ReleaseEnd, v));
|
|
CHECK(v.x == a.right() - 1); // ANCHORED, whatever the release is
|
|
}
|
|
|
|
// The literal per-node x placement, hand-derived from the documented formula (pps = 120.875
|
|
// px/s per testGatePxPerSecond; each timed stage is prefixed by the kGateNodeSepPx=8 base):
|
|
// attack .2s -> raw 8+24.175=32.175 -> px 32; hold .1s -> raw 32.175+8+12.0875=52.2625 -> px 52;
|
|
// decay .3s -> raw 52.2625+8+36.2625=96.525 -> px 97; plateau -> raw 999-8-48.35=942.65 -> px
|
|
// 943; release end pinned at the last column, 999. A literal regression pin — no relational or
|
|
// bounds-only check catches a formula-shape change the way an exact pixel count does.
|
|
static void testAhdsrSchematicPlacement() {
|
|
const Rect a = wideArea();
|
|
const std::vector<EnvVertex> poly =
|
|
buildEnvelopePolyline(ahdsr(0.2, 0.1, 0.3, 0.5, 0.4), overlayOf(a), 4.0);
|
|
EnvVertex v;
|
|
CHECK(findNode(poly, EnvNode::AttackEnd, v) && v.x == a.x + 32);
|
|
CHECK(findNode(poly, EnvNode::HoldEnd, v) && v.x == a.x + 52);
|
|
CHECK(findNode(poly, EnvNode::DecayEnd, v) && v.x == a.x + 97);
|
|
CHECK(findNode(poly, EnvNode::ReleaseStart, v) && v.x == a.x + 943);
|
|
CHECK(findNode(poly, EnvNode::ReleaseEnd, v) && v.x == a.x + 999);
|
|
}
|
|
|
|
// The AHDSR schematic is scaled by the PARAM domain, NOT the capture length: the same params
|
|
// produce the SAME polyline whether totalSeconds is 0.3 or 10 (gatePolyline doesn't even take
|
|
// totalSeconds — only the sustain-less AHD's x-axis is wall-clock/PCM-aligned).
|
|
static void testGateLayoutIndependentOfSampleDuration() {
|
|
const Rect a = wideArea();
|
|
const StageEnvelope e = ahdsr(0.2, 0.1, 0.3, 0.5, 0.06);
|
|
CHECK(buildEnvelopePolyline(e, overlayOf(a), 0.3) == buildEnvelopePolyline(e, overlayOf(a), 10.0));
|
|
}
|
|
|
|
// The layout failure this policy exists to fix: at zero release the sustain plateau must run to
|
|
// (near) the right edge instead of the figure bunching left.
|
|
static void testZeroReleasePutsTheSustainPlateauAtTheRightEdge() {
|
|
const Rect a = wideArea();
|
|
const std::vector<EnvVertex> poly =
|
|
buildEnvelopePolyline(ahdsr(0.05, 0.0, 0.05, 0.7, 0.0), overlayOf(a), 4.0);
|
|
EnvVertex plateau, end;
|
|
CHECK(findNode(poly, EnvNode::ReleaseStart, plateau));
|
|
CHECK(findNode(poly, EnvNode::ReleaseEnd, end));
|
|
CHECK(end.x == a.right() - 1);
|
|
// One node separation short of the edge — the plateau spans essentially the whole canvas.
|
|
CHECK(plateau.x == a.right() - 1 - kGateNodeSepPx);
|
|
EnvVertex decay;
|
|
CHECK(findNode(poly, EnvNode::DecayEnd, decay));
|
|
CHECK(plateau.x - decay.x > a.width / 2);
|
|
}
|
|
|
|
// The release END never moves; the release START is what a longer release pushes left.
|
|
static void testReleaseGrowsLeftwardFromTheAnchor() {
|
|
const Rect a = wideArea();
|
|
EnvVertex shortStart, longStart, shortEnd, longEnd;
|
|
const std::vector<EnvVertex> shortR =
|
|
buildEnvelopePolyline(ahdsr(0.1, 0.0, 0.1, 0.5, 0.1), overlayOf(a), 4.0);
|
|
const std::vector<EnvVertex> longR =
|
|
buildEnvelopePolyline(ahdsr(0.1, 0.0, 0.1, 0.5, 1.5), overlayOf(a), 4.0);
|
|
CHECK(findNode(shortR, EnvNode::ReleaseStart, shortStart));
|
|
CHECK(findNode(longR, EnvNode::ReleaseStart, longStart));
|
|
CHECK(findNode(shortR, EnvNode::ReleaseEnd, shortEnd));
|
|
CHECK(findNode(longR, EnvNode::ReleaseEnd, longEnd));
|
|
CHECK(longStart.x < shortStart.x);
|
|
CHECK(shortEnd.x == longEnd.x);
|
|
}
|
|
|
|
// Tier-0 defaults are zero hold and zero decay; every node still has to be independently
|
|
// grabbable, which is what the per-segment separation base buys.
|
|
static void testTierZeroDefaultsKeepEveryNodeDistinct() {
|
|
const Rect a = wideArea();
|
|
const std::vector<EnvVertex> poly =
|
|
buildEnvelopePolyline(ahdsr(0.003, 0.0, 0.0, 1.0, 0.060), overlayOf(a), 4.0);
|
|
for (std::size_t i = 1; i < 6; ++i) {
|
|
CHECK(poly[i].x - poly[i - 1].x >= kGateNodeSepPx - 1);
|
|
}
|
|
}
|
|
|
|
// Every stage maxed: the schematic exactly fills the canvas, the plateau collapses to its
|
|
// minimum gap, and nothing escapes the rect.
|
|
static void testMaxedStagesCompressWithoutOverrunning() {
|
|
const Rect a = wideArea();
|
|
const double m = kGateStageMaxSeconds;
|
|
const std::vector<EnvVertex> poly =
|
|
buildEnvelopePolyline(ahdsr(m, m, m, 0.5, m), overlayOf(a), 4.0);
|
|
for (std::size_t i = 1; i < 6; ++i) {
|
|
CHECK(poly[i].x >= poly[i - 1].x);
|
|
CHECK(poly[i].x <= a.right() - 1);
|
|
// The compression exists to preserve MINIMUM gaps under overrun, not merely
|
|
// non-strict monotonicity — a compression that let two nodes collapse onto one
|
|
// pixel would still pass a `>=` check but defeat the whole point of kGateNodeSepPx.
|
|
CHECK(poly[i].x - poly[i - 1].x >= kGateNodeSepPx - 1);
|
|
}
|
|
EnvVertex end;
|
|
CHECK(findNode(poly, EnvNode::ReleaseEnd, end));
|
|
CHECK(end.x == a.right() - 1);
|
|
}
|
|
|
|
// 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) — a regression named for the bug
|
|
// it once was. gateVtx's own double-space clamp is what this exercises.
|
|
static void testAbsurdReleaseValueStaysInBounds() {
|
|
const Rect a = wideArea();
|
|
StageEnvelope huge = ahdsr(0.1, 0.1, 0.1, 0.5, 0.1);
|
|
huge.releaseSeconds = 1e12;
|
|
for (const EnvVertex& v : buildEnvelopePolyline(huge, overlayOf(a), 4.0)) {
|
|
CHECK(v.x >= a.x && v.x < a.right());
|
|
CHECK(v.y >= a.y && v.y < a.bottom());
|
|
}
|
|
}
|
|
|
|
// --- the AHD split ------------------------------------------------------------
|
|
|
|
// The combined-time bound, asserted structurally across the full domains: no (attack, decay,
|
|
// fraction) triple can exceed the span, and no clamp on the SUM exists to be exercised.
|
|
static void testAhdSplitNeverExceedsTheSpan() {
|
|
const double span = 3.0;
|
|
for (int ai = 0; ai <= 20; ++ai) {
|
|
for (int di = 0; di <= 20; ++di) {
|
|
for (int fi = 0; fi <= 10; ++fi) {
|
|
const StageEnvelope e =
|
|
ahd(ai * 0.25, di * 0.25, fi * 0.1, 0.0, span);
|
|
const AhdSplit s = splitAhdSeconds(e);
|
|
CHECK(s.attack >= 0.0 && s.hold >= 0.0 && s.decay >= 0.0);
|
|
CHECK(s.total <= span + 1e-9);
|
|
CHECK(std::fabs(s.total - (s.attack + s.hold + s.decay)) < 1e-12);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void testHoldFractionEndpoints() {
|
|
const StageEnvelope none = ahd(0.5, 0.5, 0.0, 0.0, 4.0);
|
|
const AhdSplit s0 = splitAhdSeconds(none);
|
|
CHECK(s0.hold == 0.0);
|
|
CHECK(std::fabs(s0.total - 1.0) < 1e-12);
|
|
|
|
const StageEnvelope full = ahd(0.5, 0.5, 1.0, 0.0, 4.0);
|
|
const AhdSplit s1 = splitAhdSeconds(full);
|
|
// 100% of what attack and decay left: 4 - 0.5 - 0.5 = 3.
|
|
CHECK(std::fabs(s1.hold - 3.0) < 1e-12);
|
|
CHECK(std::fabs(s1.total - 4.0) < 1e-12);
|
|
|
|
// Attack + decay alone longer than the span: they fit by their own per-stage bounds and the
|
|
// remainder — and therefore hold — is zero. Still no clamp on the sum.
|
|
const AhdSplit s2 = splitAhdSeconds(ahd(3.0, 3.0, 1.0, 0.0, 4.0));
|
|
CHECK(std::fabs(s2.attack - 3.0) < 1e-12);
|
|
CHECK(std::fabs(s2.decay - 1.0) < 1e-12);
|
|
CHECK(s2.hold == 0.0);
|
|
CHECK(std::fabs(s2.total - 4.0) < 1e-12);
|
|
}
|
|
|
|
// --- the AHD polyline ---------------------------------------------------------
|
|
|
|
// The 1:1 property: a stage boundary at N seconds sits over the waveform at N seconds.
|
|
static void testAhdIsOneToOneWithTheTimeAxis() {
|
|
const Rect a = wideArea();
|
|
const double total = 8.0;
|
|
const StageEnvelope e = ahd(1.0, 2.0, 0.5, 1.0, 6.0);
|
|
const std::vector<EnvVertex> poly = buildEnvelopePolyline(e, overlayOf(a), total);
|
|
const AhdSplit s = splitAhdSeconds(e);
|
|
EnvVertex origin, attack, hold, decay;
|
|
CHECK(findNode(poly, EnvNode::Origin, origin));
|
|
CHECK(findNode(poly, EnvNode::AttackEnd, attack));
|
|
CHECK(findNode(poly, EnvNode::HoldEnd, hold));
|
|
CHECK(findNode(poly, EnvNode::DecayEnd, decay));
|
|
CHECK(origin.x == timeToX(a, total, 1.0));
|
|
CHECK(attack.x == timeToX(a, total, 1.0 + s.attack));
|
|
CHECK(hold.x == timeToX(a, total, 1.0 + s.attack + s.hold));
|
|
CHECK(decay.x == timeToX(a, total, 1.0 + s.total));
|
|
// Levels: rises to unity, holds, falls to zero. No sustain-only nodes exist.
|
|
CHECK(origin.level == 0.0 && attack.level == 1.0 && hold.level == 1.0 && decay.level == 0.0);
|
|
CHECK(!hasNode(poly, EnvNode::ReleaseStart));
|
|
CHECK(!hasNode(poly, EnvNode::ReleaseEnd));
|
|
CHECK(!hasNode(poly, EnvNode::ReleaseCurve));
|
|
}
|
|
|
|
// --- curve knots --------------------------------------------------------------
|
|
|
|
// A knot rides every sloped stage that has a duration, and none that does not — a zero-length
|
|
// stage has no interior to put a handle in.
|
|
static void testKnotsRideOnlySlopedNonZeroSegments() {
|
|
const Rect a = wideArea();
|
|
const std::vector<EnvVertex> full =
|
|
buildEnvelopePolyline(ahdsr(0.2, 0.2, 0.2, 0.5, 0.2), overlayOf(a), 4.0);
|
|
CHECK(hasNode(full, EnvNode::AttackCurve));
|
|
CHECK(hasNode(full, EnvNode::DecayCurve));
|
|
CHECK(hasNode(full, EnvNode::ReleaseCurve));
|
|
|
|
const std::vector<EnvVertex> flat =
|
|
buildEnvelopePolyline(ahdsr(0.0, 0.2, 0.0, 0.5, 0.0), overlayOf(a), 4.0);
|
|
CHECK(!hasNode(flat, EnvNode::AttackCurve));
|
|
CHECK(!hasNode(flat, EnvNode::DecayCurve));
|
|
CHECK(!hasNode(flat, EnvNode::ReleaseCurve));
|
|
|
|
const std::vector<EnvVertex> ahdPoly =
|
|
buildEnvelopePolyline(ahd(0.5, 0.5, 0.5, 0.0, 4.0), overlayOf(a), 4.0);
|
|
CHECK(hasNode(ahdPoly, EnvNode::AttackCurve));
|
|
CHECK(hasNode(ahdPoly, EnvNode::DecayCurve));
|
|
// Every knot is flagged as one and every stage node is not.
|
|
for (const EnvVertex& v : ahdPoly) {
|
|
const bool isKnot = v.node == EnvNode::AttackCurve || v.node == EnvNode::DecayCurve;
|
|
CHECK(v.knot == isKnot);
|
|
}
|
|
}
|
|
|
|
// The knot's HEIGHT is the exponent, read through the shared law: neutral sits at the segment
|
|
// midpoint level, a larger exponent pulls the attack knot toward the floor, a smaller one
|
|
// toward the ceiling. This is the visible half of the one-model rule.
|
|
static void testKnotHeightTracksTheExponent() {
|
|
const Rect a = wideArea();
|
|
StageEnvelope e = ahdsr(0.4, 0.0, 0.0, 1.0, 0.0);
|
|
EnvVertex neutral, steep, shallow;
|
|
|
|
e.attackCurve = 1.0;
|
|
CHECK(findNode(buildEnvelopePolyline(e, overlayOf(a), 4.0), EnvNode::AttackCurve, neutral));
|
|
CHECK(std::fabs(neutral.level - 0.5) < 1e-12); // linear: half way up at half way across
|
|
CHECK(neutral.y == levelToY(a, 0.5));
|
|
|
|
e.attackCurve = 4.0;
|
|
CHECK(findNode(buildEnvelopePolyline(e, overlayOf(a), 4.0), EnvNode::AttackCurve, steep));
|
|
CHECK(steep.level < neutral.level);
|
|
CHECK(steep.y > neutral.y); // lower on screen
|
|
|
|
e.attackCurve = 0.25;
|
|
CHECK(findNode(buildEnvelopePolyline(e, overlayOf(a), 4.0), EnvNode::AttackCurve, shallow));
|
|
CHECK(shallow.level > neutral.level);
|
|
CHECK(shallow.y < neutral.y);
|
|
|
|
// The knot sits between its segment's endpoints in x, and inside the canvas in y.
|
|
CHECK(steep.x > a.x && steep.x < a.right() - 1);
|
|
CHECK(steep.y >= a.y && steep.y <= a.bottom() - 1);
|
|
}
|
|
|
|
// --- degenerate ---------------------------------------------------------------
|
|
|
|
static void testDegenerateSurfaceYieldsFlatBaseline() {
|
|
const std::vector<EnvVertex> zeroArea =
|
|
buildEnvelopePolyline(ahdsr(0.1, 0.1, 0.1, 0.5, 0.1), overlayOf(Rect{}), 4.0);
|
|
CHECK(zeroArea.size() == 2);
|
|
CHECK(zeroArea[0].level == 0.0 && zeroArea[1].level == 0.0);
|
|
const std::vector<EnvVertex> zeroDur =
|
|
buildEnvelopePolyline(ahd(0.1, 0.1, 0.5, 0.0, 1.0), overlayOf(wideArea()), 0.0);
|
|
CHECK(zeroDur.size() == 2);
|
|
}
|
|
|
|
int main() {
|
|
testTimeToXEndpoints();
|
|
testTimeToXClampsBothEnds();
|
|
testLevelToY();
|
|
testDegenerateAreaAndDuration();
|
|
testGatePxPerSecond();
|
|
|
|
testAhdsrNodeOrderAndLevels();
|
|
testAhdsrSchematicPlacement();
|
|
testGateLayoutIndependentOfSampleDuration();
|
|
testZeroReleasePutsTheSustainPlateauAtTheRightEdge();
|
|
testReleaseGrowsLeftwardFromTheAnchor();
|
|
testTierZeroDefaultsKeepEveryNodeDistinct();
|
|
testMaxedStagesCompressWithoutOverrunning();
|
|
testAbsurdReleaseValueStaysInBounds();
|
|
|
|
testAhdSplitNeverExceedsTheSpan();
|
|
testHoldFractionEndpoints();
|
|
testAhdIsOneToOneWithTheTimeAxis();
|
|
|
|
testKnotsRideOnlySlopedNonZeroSegments();
|
|
testKnotHeightTracksTheExponent();
|
|
|
|
testDegenerateSurfaceYieldsFlatBaseline();
|
|
|
|
if (g_fail == 0) std::printf("envelope_overlay: all tests passed\n");
|
|
else std::printf("envelope_overlay: %d FAILED\n", g_fail);
|
|
return g_fail == 0 ? 0 : 1;
|
|
}
|