"""The game's HD rumble goes to a controller's heavy and light motors by frequency, scaled by the menu's Rumble strength. host/nn_hid.c rumble_map: each band's strength (rumble_motor) is split between the heavy and light motors by its frequency (rumble_heavy_share: all heavy up to 160 Hz, all light from 200 Hz, a constant-power crossfade between, on a log scale). At the Switch's default frequencies and the ones OoT sends, every band lands on the motor it did before, at the same strength. host/pad_sdl.c rumble_strength: the Insert menu's Rumble strength, in percent, on the motors' 0..65535; above 100% (the row goes to 300%) both motors are scaled by the same factor when the stronger would pass the top. Run with: python -I -B tests/test_rumble_mapping.py """ import os from pathlib import Path import re import subprocess import tempfile import unittest ROOT = Path(__file__).resolve().parents[1] HID = ROOT / "host" / "nn_hid.c" PAD = ROOT / "host" / "pad_sdl.c" def function(path, name): text = path.read_text(encoding="utf-8") found = re.search(re.escape(name) + r"\([^;{]*\)\s*\{", text) # (the definition, not a declaration) if not found: raise RuntimeError("no definition of " + name) at = found.start() start = found.end() - 1 depth = 0 for i in range(start, len(text)): depth += text[i] == "{" depth -= text[i] == "}" if depth == 0: return text[at:i + 1] raise RuntimeError("no end for " + name) def defines(path, prefix): return "\n".join(re.findall(r"^#define %s\w* .*$" % prefix, path.read_text(encoding="utf-8"), re.M)) FIXTURE = r""" #include #include #include #define CHECK(x) do { if (!(x)) { fprintf(stderr, "FAIL %%d %%s\n", __LINE__, #x); return 1; } } while (0) %(defines)s %(motor)s %(share)s %(map)s %(strength)s /* (the documented split, worked out again: 1 at 160 Hz, 0 at 200 Hz, log-linear between) */ static float doc_share(float f) { return f <= 160.0f ? 1.0f : f >= 200.0f ? 0.0f : 1.0f - logf(f / 160.0f) / logf(200.0f / 160.0f); } static uint16_t strength1(unsigned heavy, unsigned light, int percent, int which) { uint16_t out[2]; rumble_strength(heavy, light, percent, out); return out[which]; } /* (the mapping before the frequency split: each band its own motor, (a + a^0.35) / 2 and less above a start frequency) */ static float old_band(float amp, float freq, float start, float width) { if (amp <= 0.0f) return 0.0f; const float scale = freq > start ? fmaxf(1.0f - (freq - start) / width, 0.3f) : 1.0f; return fminf((amp + powf(amp, 0.35f)) * 0.5f * scale, 1.0f); } static int near(float a, float b) { return fabsf(a - b) <= 1e-5f; } static int near_by(float a, float b, float e) { return fabsf(a - b) <= e; } int main(void) { /* 100%%, the defaults and what OoT sends (low about 100-130 Hz, high 250-300 Hz): the same as before, where the low band drove the heavy motor and the high band the light one, each with rumble_motor's falloff */ static const float amps[] = {0.0f, 0.005f, 0.01f, 0.02f, 0.06f, 0.3f, 1.0f}; static const float lows[] = {40.0f, 102.0f, 116.0f, 126.0f, 140.0f, 160.0f}; static const float highs[] = {200.0f, 220.0f, 240.0f, 252.0f, 287.0f, 300.0f, 320.0f, 600.0f, 1250.0f}; for (int a = 0; a < 7; a++) for (int b = 0; b < 7; b++) for (int l = 0; l < 6; l++) for (int h = 0; h < 9; h++) { const float v[4] = {amps[a], lows[l], amps[b], highs[h]}; float m[2]; rumble_map(v, m); CHECK(near(m[0], old_band(v[0], v[1], 140.0f, 400.0f))); CHECK(near(m[1], old_band(v[2], v[3], 200.0f, 700.0f))); const unsigned lo = (unsigned)(m[0] * 65535), hi = (unsigned)(m[1] * 65535); /* (hos_sdl_rumble) */ CHECK(strength1(lo, hi, 100, 0) == lo && strength1(lo, hi, 100, 1) == hi); } { /* the idle value (GetActualVibrationValue) is silence */ const float v[4] = {0.0f, 160.0f, 0.0f, 320.0f}; float m[2]; rumble_map(v, m); CHECK(m[0] == 0.0f && m[1] == 0.0f); } /* the share: all heavy up to 160 Hz, all light from 200 Hz, falling between, half at their geometric middle */ CHECK(rumble_heavy_share(40.0f) == 1.0f && rumble_heavy_share(160.0f) == 1.0f); CHECK(rumble_heavy_share(200.0f) == 0.0f && rumble_heavy_share(240.0f) == 0.0f && rumble_heavy_share(1250.0f) == 0.0f); CHECK(rumble_heavy_share(0.0f) == 1.0f && rumble_heavy_share(NAN) == 1.0f); CHECK(near(rumble_heavy_share(sqrtf(160.0f * 200.0f)), 0.5f)); for (float f = 150.0f; f <= 260.0f; f += 0.5f) CHECK(near(rumble_heavy_share(f), doc_share(f))); float last = 1.0f; for (float f = 160.0f; f <= 200.0f; f += 0.5f) { const float s = rumble_heavy_share(f); CHECK(s >= 0.0f && s <= 1.0f && s <= last); last = s; } { /* a high band played low reaches the heavy motor, at its full strength */ const float v[4] = {0.0f, 160.0f, 0.3f, 100.0f}; float m[2]; rumble_map(v, m); CHECK(m[0] == rumble_motor(0.3f, 100.0f, 200.0f, 700.0f) && m[0] > 0.0f && m[1] == 0.0f); } { /* a low band played high, the light one (with the low band's falloff) */ const float v[4] = {0.3f, 320.0f, 0.0f, 320.0f}; float m[2]; rumble_map(v, m); CHECK(m[0] == 0.0f && m[1] == rumble_motor(0.3f, 320.0f, 140.0f, 400.0f) && m[1] > 0.0f); } for (float f = 170.0f; f < 200.0f; f += 3.0f) { /* in the crossfade, both motors, at constant power, split as documented */ for (int band_is_high = 0; band_is_high < 2; band_is_high++) { const float v[4] = {band_is_high ? 0.0f : 0.3f, band_is_high ? 160.0f : f, band_is_high ? 0.3f : 0.0f, band_is_high ? f : 320.0f}; float m[2]; rumble_map(v, m); const float band = band_is_high ? rumble_motor(0.3f, f, 200.0f, 700.0f) : rumble_motor(0.3f, f, 140.0f, 400.0f); CHECK(m[0] > 0.0f && m[1] > 0.0f && m[0] <= band && m[1] <= band); CHECK(near(m[0] * m[0] + m[1] * m[1], band * band)); CHECK(near_by(m[0] * m[0] / (band * band), doc_share(f), 1e-4f)); CHECK(near_by(m[1] * m[1] / (band * band), 1.0f - doc_share(f), 1e-4f)); } } { /* OoT's high band (about 250-300 Hz) is clear of the crossfade, with room: all light */ for (float f = 200.0f; f <= 320.0f; f += 1.0f) { const float v[4] = {0.0f, 160.0f, 0.3f, f}; float m[2]; rumble_map(v, m); CHECK(m[0] == 0.0f && m[1] == rumble_motor(0.3f, f, 200.0f, 700.0f)); } } /* the strength: Off is silence, it grows with the percentage and the motor's value, and stops at the top */ static const int percents[] = {0, 25, 50, 75, 100, 125, 150, 175, 200, 250, 300}; /* (the row's: Off to 300%%) */ enum { PERCENTS = sizeof percents / sizeof *percents }; static const unsigned values[] = {0, 1, 300, 6880, 20000, 43690, 50000, 65535}; for (int i = 0; i < 8; i++) for (int j = 0; j < 8; j++) { const unsigned h = values[i], l = values[j]; CHECK(strength1(h, l, 0, 0) == 0 && strength1(h, l, 0, 1) == 0 && strength1(h, l, -5, 0) == 0); for (int p = 1; p < PERCENTS; p++) { CHECK(strength1(h, l, percents[p], 0) >= strength1(h, l, percents[p - 1], 0)); CHECK(strength1(h, l, percents[p], 1) >= strength1(h, l, percents[p - 1], 1)); } for (int p = 0; p < 5; p++) { /* up to 100%%: each motor on its own, as it was */ CHECK(strength1(h, l, percents[p], 0) == h * (unsigned)percents[p] / 100u); CHECK(strength1(h, l, percents[p], 1) == l * (unsigned)percents[p] / 100u); } for (int p = 5; p < PERCENTS; p++) { /* above: the balance kept; the stronger at most the top, at it when it would pass */ const unsigned long long sh = (unsigned long long)h * (unsigned)percents[p] / 100u; const unsigned long long sl = (unsigned long long)l * (unsigned)percents[p] / 100u; const unsigned oh = strength1(h, l, percents[p], 0), ol = strength1(h, l, percents[p], 1); const unsigned top = oh > ol ? oh : ol; if (sh > 0xFFFF || sl > 0xFFFF) CHECK(top == 0xFFFF); else CHECK(oh == sh && ol == sl); if (h && l) CHECK(fabs((double)oh / ol - (double)h / l) <= (double)h / l * 2.0 / (double)(ol < oh ? ol : oh) + 1e-9); } } CHECK(strength1(20000, 10000, 50, 0) == 10000 && strength1(20000, 10000, 150, 0) == 30000 && strength1(20000, 10000, 150, 1) == 15000); CHECK(strength1(50000, 30000, 150, 0) == 0xFFFF && strength1(50000, 30000, 150, 1) == 39321); /* 5:3, not 65535:45000 */ CHECK(strength1(30000, 50000, 150, 0) == 39321 && strength1(30000, 50000, 150, 1) == 0xFFFF); CHECK(strength1(65535, 65535, 150, 0) == 0xFFFF && strength1(65535, 65535, 150, 1) == 0xFFFF); CHECK(strength1(43690, 0, 150, 0) == 65535 && strength1(43690, 0, 150, 1) == 0); /* the row's top, 300%%: a third of the motor's strength and up is its top, the other motor in step */ CHECK(strength1(10000, 5000, 300, 0) == 30000 && strength1(10000, 5000, 300, 1) == 15000); CHECK(strength1(21845, 0, 300, 0) == 65535 && strength1(21846, 100, 300, 0) == 65535); CHECK(strength1(50000, 30000, 300, 0) == 0xFFFF && strength1(50000, 30000, 300, 1) == 39321); CHECK(strength1(65535, 65535, 300, 0) == 0xFFFF && strength1(65535, 65535, 300, 1) == 0xFFFF); return 0; } """ class RumbleMappingTests(unittest.TestCase): def test_the_poll_scales_both_motors_by_the_menu(self): poll = re.sub(r"\s+", " ", function(PAD, "static void pads_poll")) self.assertRegex(poll, r"\brx_option\(\s*9\s*,\s*100\s*\)") call = re.search(r"\brumble_strength\(([^;]*)\);", poll) self.assertIsNotNone(call, "the poll does not scale the rumble by the menu's strength") self.assertRegex(call.group(1), r"rumble_low\b.*rumble_high\b") # (heavy first, light second) self.assertLess(call.start(), poll.index("rumble_due(")) # (Off is a change: a stop is sent) self.assertRegex(re.sub(r"\s+", " ", function(HID, "static void vibration_send")), r"\brumble_map\( ?v ?, ?amp\[dev\] ?\)") def test_mapping_and_strength(self): fixture = FIXTURE % { "defines": defines(HID, "RUMBLE_"), "motor": function(HID, "static float rumble_motor"), "share": function(HID, "static float rumble_heavy_share"), "map": function(HID, "static void rumble_map"), "strength": function(PAD, "static void rumble_strength"), } with tempfile.TemporaryDirectory() as d: path = os.path.join(d, "rumble.c") with open(path, "w", encoding="utf-8") as f: f.write(fixture) exe = os.path.join(d, "rumble") cc = os.environ.get("CC", "cc") made = subprocess.run([cc, "-std=c11", "-Wall", "-Wextra", "-Werror", path, "-o", exe, "-lm"], capture_output=True, text=True) self.assertEqual(made.returncode, 0, made.stderr) ran = subprocess.run([exe], capture_output=True, text=True) self.assertEqual(ran.returncode, 0, ran.stderr) if __name__ == "__main__": unittest.main()