S-VIEW-9: velocity->amp transfer curve (pure velocity_curve module + zones-payload v7 + Voice::start apply)
Default flat y=1 (R10-F1 Option A) replaces the linear velocity/127 at note-on — a deliberate, non-back-compat behavior change; v1-v6 blobs lift to the flat default.
This commit is contained in:
@@ -0,0 +1,241 @@
|
||||
// Standalone tests for reasampler::vst::velocity_curve — no VST3, no REAPER, no framework. Same fast
|
||||
// assert loop as the sibling pure tests. Assert the S-VIEW-9 velocity->amp transfer curve HARD:
|
||||
//
|
||||
// * eval — flat y=1 default (R10-F1 Option A: EVERY velocity -> 1.0), linear ramp, curved shape
|
||||
// between points, box-clamp of an out-of-range velocity, monotonic-in-x over the whole domain.
|
||||
// * editing — addPoint keeps X-order + box-clamp; movePoint clamps an interior point between its
|
||||
// neighbours (can't cross) and box-clamps amp; endpoints are X-pinned (velocity 0 / 127) with
|
||||
// only amp mobile; deletePoint removes interior points but REFUSES the two endpoints.
|
||||
// * hit-test + inverse map — pointAtPixel grabs a drawn node; resolvePointDrag maps pixel delta to
|
||||
// a clamped point (endpoint X-pinned; interior clamped to neighbours); degenerate box -> no motion.
|
||||
// * fromPoints — the deserialization repair: sorts by X, box-clamps, forces endpoints, and falls
|
||||
// back to flat() for a sub-2-point list.
|
||||
|
||||
#include "../src/vst/velocity_curve.h"
|
||||
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
|
||||
using namespace reasampler::vst;
|
||||
|
||||
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; }
|
||||
|
||||
using Box = VelocityCurve::Box;
|
||||
|
||||
// --- eval ---------------------------------------------------------------------
|
||||
|
||||
static void testFlatIsUnityEverywhere() {
|
||||
const VelocityCurve c = VelocityCurve::flat();
|
||||
// R10-F1 Option A: every velocity plays at full level. Sweep the whole domain.
|
||||
for (int v = 0; v <= 127; ++v) CHECK(near(c.eval(v), 1.0));
|
||||
// Two endpoints only.
|
||||
CHECK(c.size() == 2);
|
||||
}
|
||||
|
||||
static void testLinearRamp() {
|
||||
const VelocityCurve c = VelocityCurve::linear();
|
||||
CHECK(near(c.eval(0), 0.0));
|
||||
CHECK(near(c.eval(127), 1.0));
|
||||
// linear() is an EXACT straight line y = velocity/127: at any velocity the amp equals v/127.
|
||||
CHECK(near(c.eval(63.5), 0.5)); // the exact midpoint
|
||||
CHECK(near(c.eval(64.0), 64.0 / 127.0));
|
||||
CHECK(near(c.eval(100.0), 100.0 / 127.0));
|
||||
}
|
||||
|
||||
static void testEvalBoxClampsOutOfRangeVelocity() {
|
||||
const VelocityCurve c = VelocityCurve::linear();
|
||||
CHECK(near(c.eval(-10.0), 0.0)); // below 0 -> reads velocity-0 endpoint amp
|
||||
CHECK(near(c.eval(200.0), 1.0)); // above 127 -> reads velocity-127 endpoint amp
|
||||
}
|
||||
|
||||
static void testEvalMonotonicInX() {
|
||||
// A curve that dips then rises must still be a well-defined FUNCTION (one amp per velocity) and
|
||||
// monotonic WITHIN each segment. Build (0,1)->(64,0)->(127,1): eval sweeps must be single-valued
|
||||
// and each half monotonic (down then up), never oscillating within a segment.
|
||||
VelocityCurve c = VelocityCurve::flat();
|
||||
c.movePoint(0, 0, 1.0);
|
||||
c.addPoint(64.0, 0.0);
|
||||
c.movePoint(2, 127, 1.0); // index 2 is the last endpoint after the insert
|
||||
CHECK(c.size() == 3);
|
||||
// Descending half [0,64]: non-increasing.
|
||||
double prev = c.eval(0);
|
||||
for (int v = 1; v <= 64; ++v) {
|
||||
const double cur = c.eval(v);
|
||||
CHECK(cur <= prev + 1e-9);
|
||||
prev = cur;
|
||||
}
|
||||
// Ascending half [64,127]: non-decreasing.
|
||||
prev = c.eval(64);
|
||||
for (int v = 65; v <= 127; ++v) {
|
||||
const double cur = c.eval(v);
|
||||
CHECK(cur >= prev - 1e-9);
|
||||
prev = cur;
|
||||
}
|
||||
CHECK(near(c.eval(64), 0.0)); // the trough sits exactly on the moved point
|
||||
}
|
||||
|
||||
// --- editing: addPoint --------------------------------------------------------
|
||||
|
||||
static void testAddPointKeepsXOrderAndClamps() {
|
||||
VelocityCurve c = VelocityCurve::linear(); // (0,0), (127,1)
|
||||
const std::size_t i = c.addPoint(60.0, 0.3);
|
||||
CHECK(i == 1); // inserted between the two endpoints
|
||||
CHECK(c.size() == 3);
|
||||
CHECK(near(c.points()[1].velocity, 60.0) && near(c.points()[1].amp, 0.3));
|
||||
// Out-of-box add clamps into [0,127] x [0,1].
|
||||
c.addPoint(500.0, 5.0);
|
||||
const VelocityPoint& last = c.points().back();
|
||||
CHECK(near(last.velocity, 127.0) && near(last.amp, 1.0));
|
||||
// Points remain X-ordered.
|
||||
for (std::size_t k = 1; k < c.size(); ++k)
|
||||
CHECK(c.points()[k - 1].velocity <= c.points()[k].velocity);
|
||||
}
|
||||
|
||||
// --- editing: movePoint -------------------------------------------------------
|
||||
|
||||
static void testMoveInteriorClampsToNeighbours() {
|
||||
VelocityCurve c = VelocityCurve::linear();
|
||||
c.addPoint(40.0, 0.4); // idx 1
|
||||
c.addPoint(80.0, 0.8); // idx 2
|
||||
CHECK(c.size() == 4); // (0,0)(40,.4)(80,.8)(127,1)
|
||||
// Try to drag idx 1 PAST idx 2 (velocity 200): clamps to idx 2's velocity (80), not beyond.
|
||||
const VelocityPoint r = c.movePoint(1, 200.0, 0.5);
|
||||
CHECK(near(r.velocity, 80.0));
|
||||
CHECK(near(r.amp, 0.5)); // amp is free (box-clamped only)
|
||||
// Try to drag idx 1 BELOW idx 0 (velocity -5): clamps to idx 0's velocity (0).
|
||||
const VelocityPoint r2 = c.movePoint(1, -5.0, 0.5);
|
||||
CHECK(near(r2.velocity, 0.0));
|
||||
}
|
||||
|
||||
static void testMoveEndpointsArePinnedInX() {
|
||||
VelocityCurve c = VelocityCurve::linear();
|
||||
// Move the first endpoint: velocity argument ignored (pinned at 0), amp moves.
|
||||
const VelocityPoint f = c.movePoint(0, 50.0, 0.25);
|
||||
CHECK(near(f.velocity, 0.0));
|
||||
CHECK(near(f.amp, 0.25));
|
||||
// Move the last endpoint: pinned at 127, amp moves, and amp box-clamps.
|
||||
const VelocityPoint l = c.movePoint(1, 10.0, 5.0);
|
||||
CHECK(near(l.velocity, 127.0));
|
||||
CHECK(near(l.amp, 1.0));
|
||||
}
|
||||
|
||||
static void testMoveOutOfRangeIndexIsNoOp() {
|
||||
VelocityCurve c = VelocityCurve::linear();
|
||||
c.movePoint(99, 50.0, 0.5);
|
||||
CHECK(c.size() == 2);
|
||||
CHECK(near(c.points()[0].amp, 0.0) && near(c.points()[1].amp, 1.0)); // unchanged
|
||||
}
|
||||
|
||||
// --- editing: deletePoint -----------------------------------------------------
|
||||
|
||||
static void testDeleteRemovesInteriorRefusesEndpoints() {
|
||||
VelocityCurve c = VelocityCurve::linear();
|
||||
c.addPoint(60.0, 0.5); // idx 1
|
||||
CHECK(c.size() == 3);
|
||||
// Endpoints refuse deletion.
|
||||
CHECK(!c.deletePoint(0));
|
||||
CHECK(!c.deletePoint(2));
|
||||
CHECK(c.size() == 3);
|
||||
// Interior deletes.
|
||||
CHECK(c.deletePoint(1));
|
||||
CHECK(c.size() == 2);
|
||||
// Out-of-range refuses.
|
||||
CHECK(!c.deletePoint(9));
|
||||
}
|
||||
|
||||
// --- hit-test + inverse map ---------------------------------------------------
|
||||
|
||||
// A 127px-wide, 101px-tall box at origin: velocity->x is 1px/unit, amp->y spans 100 rows (1 px per
|
||||
// 0.01 amp), amp 1 at top (y=0), amp 0 at bottom (y=100).
|
||||
static Box wideBox() { return Box{0, 0, 127, 101}; }
|
||||
|
||||
static void testPointAtPixelGrabsDrawnNode() {
|
||||
VelocityCurve c = VelocityCurve::linear(); // (0,0) at (0,100); (127,1) at (127,0)
|
||||
const Box b = wideBox();
|
||||
// Grab near the first endpoint's drawn point (x=0, y=100).
|
||||
CHECK(c.pointAtPixel(b, 0, 100) == 0);
|
||||
// Grab near the last endpoint (x=127, y=0).
|
||||
CHECK(c.pointAtPixel(b, 127, 0) == 1);
|
||||
// A point far from any node misses.
|
||||
CHECK(c.pointAtPixel(b, 63, 50) == -1);
|
||||
}
|
||||
|
||||
static void testResolveDragMovesAndClamps() {
|
||||
VelocityCurve grab = VelocityCurve::linear();
|
||||
grab.addPoint(60.0, 0.5); // idx 1, drawn at x=60, y=50
|
||||
const Box b = wideBox();
|
||||
// Drag idx 1 right 10px, up 10px: velocity +10 (->70), amp +0.10 (up = higher amp -> 0.60).
|
||||
const VelocityCurve moved = VelocityCurve::resolvePointDrag(grab, 1, b, 10, -10);
|
||||
CHECK(near(moved.points()[1].velocity, 70.0, 1e-6));
|
||||
CHECK(near(moved.points()[1].amp, 0.60, 1e-6));
|
||||
// Dragging the first endpoint horizontally does not move it in X (pinned), only amp.
|
||||
const VelocityCurve movedEnd = VelocityCurve::resolvePointDrag(grab, 0, b, 40, -20);
|
||||
CHECK(near(movedEnd.points()[0].velocity, 0.0));
|
||||
CHECK(near(movedEnd.points()[0].amp, 0.20, 1e-6)); // dragged up 20px = +0.20 from 0
|
||||
}
|
||||
|
||||
static void testResolveDragDegenerateBoxNoMotion() {
|
||||
const VelocityCurve grab = VelocityCurve::linear();
|
||||
const VelocityCurve r = VelocityCurve::resolvePointDrag(grab, 1, Box{0, 0, 0, 0}, 50, 50);
|
||||
CHECK(r.equals(grab)); // zero-size box -> unchanged
|
||||
}
|
||||
|
||||
// --- fromPoints (deserialization repair) --------------------------------------
|
||||
|
||||
static void testFromPointsSortsClampsAndForcesEndpoints() {
|
||||
// Unsorted, out-of-box, missing endpoints -> repaired to a valid curve.
|
||||
std::vector<VelocityPoint> raw = {{80.0, 0.9}, {20.0, -1.0}, {50.0, 2.0}};
|
||||
const VelocityCurve c = VelocityCurve::fromPoints(raw);
|
||||
// X-ordered.
|
||||
for (std::size_t k = 1; k < c.size(); ++k)
|
||||
CHECK(c.points()[k - 1].velocity <= c.points()[k].velocity);
|
||||
// Endpoints forced present at 0 and 127.
|
||||
CHECK(near(c.points().front().velocity, 0.0));
|
||||
CHECK(near(c.points().back().velocity, 127.0));
|
||||
// Interior amps box-clamped (the -1 became 0, the 2 became 1).
|
||||
for (const VelocityPoint& p : c.points()) {
|
||||
CHECK(p.amp >= 0.0 - 1e-12 && p.amp <= 1.0 + 1e-12);
|
||||
}
|
||||
}
|
||||
|
||||
static void testFromPointsSubTwoFallsBackToFlat() {
|
||||
const VelocityCurve c0 = VelocityCurve::fromPoints({});
|
||||
CHECK(c0.equals(VelocityCurve::flat()));
|
||||
const VelocityCurve c1 = VelocityCurve::fromPoints({{50.0, 0.3}});
|
||||
CHECK(c1.equals(VelocityCurve::flat()));
|
||||
}
|
||||
|
||||
static void testFromPointsRoundTripsAValidCurve() {
|
||||
VelocityCurve orig = VelocityCurve::linear();
|
||||
orig.addPoint(40.0, 0.2);
|
||||
orig.addPoint(90.0, 0.7);
|
||||
// fromPoints over its OWN points reproduces it exactly (already valid, sort is stable no-op).
|
||||
const VelocityCurve rebuilt = VelocityCurve::fromPoints(orig.points());
|
||||
CHECK(rebuilt.equals(orig));
|
||||
}
|
||||
|
||||
int main() {
|
||||
testFlatIsUnityEverywhere();
|
||||
testLinearRamp();
|
||||
testEvalBoxClampsOutOfRangeVelocity();
|
||||
testEvalMonotonicInX();
|
||||
testAddPointKeepsXOrderAndClamps();
|
||||
testMoveInteriorClampsToNeighbours();
|
||||
testMoveEndpointsArePinnedInX();
|
||||
testMoveOutOfRangeIndexIsNoOp();
|
||||
testDeleteRemovesInteriorRefusesEndpoints();
|
||||
testPointAtPixelGrabsDrawnNode();
|
||||
testResolveDragMovesAndClamps();
|
||||
testResolveDragDegenerateBoxNoMotion();
|
||||
testFromPointsSortsClampsAndForcesEndpoints();
|
||||
testFromPointsSubTwoFallsBackToFlat();
|
||||
testFromPointsRoundTripsAValidCurve();
|
||||
|
||||
if (g_fail == 0) std::printf("velocity_curve: all tests passed\n");
|
||||
else std::printf("velocity_curve: %d FAILURES\n", g_fail);
|
||||
return g_fail == 0 ? 0 : 1;
|
||||
}
|
||||
Reference in New Issue
Block a user