@series-inc/rundot-syncplay 5.26.0-beta.2 → 5.26.0-beta.4

package/core/native/fixed_math.hpp

@@ -0,0 +1,111 @@
+// C++ twin of src/math.ts (DeterministicMath). A WebView peer runs the TS; a
+// native peer runs this; both must agree bit-for-bit or the match desyncs.
+// Values are `double`, not int64: the reference computes every intermediate as
+// an IEEE double, and past 2^53 the two disagree (see mul).
+// Parity is gated by core/tests/fixed-parity.test.mjs.
+#ifndef RUNDOT_FIXED_MATH_HPP
+#define RUNDOT_FIXED_MATH_HPP
+
+namespace rundot::fixedmath {
+
+struct Config {
+  double fixedScale;
+  double minFixed;
+  double maxFixed;
+};
+
+struct Vec2 {
+  double x;
+  double y;
+};
+
+struct Vec3 {
+  double x;
+  double y;
+  double z;
+};
+
+struct Quat {
+  double x;
+  double y;
+  double z;
+  double w;
+};
+
+Config defaultConfig();
+
+// `ok` is set false where the TypeScript reference throws. Callers must check it
+// before using the return value; a false `ok` never carries a meaningful number.
+double toFixed(const Config& c, double value, bool& ok);
+double fromFixed(const Config& c, double value, bool& ok);
+double add(const Config& c, double a, double b, bool& ok);
+double sub(const Config& c, double a, double b, bool& ok);
+double mul(const Config& c, double a, double b, bool& ok);
+double div(const Config& c, double a, double b, bool& ok);
+double saturatingAdd(const Config& c, double a, double b, bool& ok);
+double saturatingSub(const Config& c, double a, double b, bool& ok);
+double quantize(const Config& c, double value, double engine, bool& ok);
+double sqrtFixed(const Config& c, double value, bool& ok);
+double integerSqrt(const Config& c, double value, bool& ok);
+double absFixed(const Config& c, double value, bool& ok);
+double sign(const Config& c, double value, bool& ok);
+double minFixed(const Config& c, double a, double b, bool& ok);
+double maxFixed(const Config& c, double a, double b, bool& ok);
+double lerp(const Config& c, double a, double b, double t, bool& ok);
+double mod(const Config& c, double a, double b, bool& ok);
+double inverseLerp(const Config& c, double a, double b, double v, bool& ok);
+double remap(const Config& c, double inMin, double inMax, double outMin, double outMax, double v, bool& ok);
+double smoothstep(const Config& c, double edge0, double edge1, double x, bool& ok);
+double log2Fixed(const Config& c, double value, bool& ok);
+double expFixed(const Config& c, double value, bool& ok);
+double logFixed(const Config& c, double value, bool& ok);
+double sinTurns(const Config& c, double turns, bool& ok);
+double cosTurns(const Config& c, double turns, bool& ok);
+double tanTurns(const Config& c, double turns, bool& ok);
+double atan2Turns(const Config& c, double y, double x, bool& ok);
+double atan2Signed(const Config& c, double y, double x, bool& ok);
+double wrapTurns(const Config& c, double t, bool& ok);
+double angleDeltaTurns(const Config& c, double a, double b, bool& ok);
+double turnsToRadians(const Config& c, double t, bool& ok);
+double radiansToTurns(const Config& c, double r, bool& ok);
+double hypot(const Config& c, double x, double y, bool& ok);
+
+Vec2 vec2(const Config& c, double x, double y, bool& ok);
+Vec2 vec2Add(const Config& c, Vec2 a, Vec2 b, bool& ok);
+Vec2 vec2Sub(const Config& c, Vec2 a, Vec2 b, bool& ok);
+Vec2 vec2Scale(const Config& c, Vec2 v, double s, bool& ok);
+double vec2Dot(const Config& c, Vec2 a, Vec2 b, bool& ok);
+double vec2Cross(const Config& c, Vec2 a, Vec2 b, bool& ok);
+double vec2LengthSq(const Config& c, Vec2 v, bool& ok);
+double vec2Length(const Config& c, Vec2 v, bool& ok);
+double vec2DistanceSq(const Config& c, Vec2 a, Vec2 b, bool& ok);
+double vec2Distance(const Config& c, Vec2 a, Vec2 b, bool& ok);
+Vec2 vec2Normalize(const Config& c, Vec2 v, bool& ok);
+Vec2 vec2Perp(const Config& c, Vec2 v, bool& ok);
+Vec2 vec2Negate(const Config& c, Vec2 v, bool& ok);
+Vec2 vec2Rotate(const Config& c, Vec2 v, double turns, bool& ok);
+Vec2 vec2FromAngleTurns(const Config& c, double turns, double length, bool& ok);
+double vec2AngleTurns(const Config& c, Vec2 v, bool& ok);
+Vec2 vec2Lerp(const Config& c, Vec2 a, Vec2 b, double t, bool& ok);
+
+Vec3 vec3(const Config& c, double x, double y, double z, bool& ok);
+Vec3 vec3Add(const Config& c, Vec3 a, Vec3 b, bool& ok);
+Vec3 vec3Sub(const Config& c, Vec3 a, Vec3 b, bool& ok);
+Vec3 vec3Scale(const Config& c, Vec3 v, double s, bool& ok);
+double vec3Dot(const Config& c, Vec3 a, Vec3 b, bool& ok);
+Vec3 vec3Cross(const Config& c, Vec3 a, Vec3 b, bool& ok);
+double vec3LengthSq(const Config& c, Vec3 v, bool& ok);
+double vec3Length(const Config& c, Vec3 v, bool& ok);
+double vec3Distance(const Config& c, Vec3 a, Vec3 b, bool& ok);
+Vec3 vec3Normalize(const Config& c, Vec3 v, bool& ok);
+Vec3 vec3Lerp(const Config& c, Vec3 a, Vec3 b, double t, bool& ok);
+Vec3 vec3Negate(const Config& c, Vec3 v, bool& ok);
+
+Quat quatFromYawTurns(const Config& c, double turns, bool& ok);
+Quat quatLerp(const Config& c, Quat a, Quat b, double t, bool& ok);
+
+double clamp(const Config& c, double value, double lo, double hi, bool& ok);
+
+}  // namespace rundot::fixedmath
+
+#endif  // RUNDOT_FIXED_MATH_HPP

package/core/native/kinetix-native-main.cpp

@@ -2,6 +2,7 @@
 #include <algorithm>
 #include <bit>
 #include <chrono>
+#include <cmath>
 #include <cstdint>
 #include <fstream>
 #include <iomanip>
@@ -12,6 +13,8 @@
 #include <vector>
 
 #include "deterministic_math.hpp"
+#include "fixed_math.hpp"
+#include "mobile/box3d_probe_scenario.hpp"
 #include "physics/physics.hpp"
 #include "kinetix-render-projection.hpp"
 #include "kinetix-native-runtime.hpp"
@@ -542,76 +545,13 @@ int runPhysicsQuerySession() {
   return 0;
 }
 
-std::uint64_t benchmarkHash(const std::vector<double>& bodyData, std::uint32_t bodyCount) {
-  std::uint64_t hash = 1469598103934665603ULL;
-  constexpr std::uint64_t prime = 1099511628211ULL;
-  const auto hashFloat = [&](double value) {
-    const float narrowed = static_cast<float>(value);
-    hash ^= std::bit_cast<std::uint32_t>(narrowed);
-    hash *= prime;
-  };
-  // Match the pinned Box3D harness: dynamic bodies only, using the common
-  // public state available from both engines and float32 serialization.
-  for (std::uint32_t bodyIndex = 1; bodyIndex < bodyCount; bodyIndex += 1) {
-    const std::size_t offset = static_cast<std::size_t>(bodyIndex) * rundot::kinetix::physics::kBodyStride;
-    for (const std::uint32_t field : {0, 1, 2, 3, 4, 5, 19, 20, 21, 22, 23, 24, 25}) {
-      hashFloat(bodyData[offset + field]);
-    }
-  }
-  return hash;
-}
-
 int runPhysicsBenchmark(std::uint32_t bodyCount, std::uint32_t frameCount, bool useDynamicTree) {
-  constexpr std::uint32_t stride = rundot::kinetix::physics::kBodyStride;
   if (bodyCount < 2 || bodyCount > 100000 || frameCount == 0) {
     std::cerr << "KINETIX_PHYSICS_BENCHMARK_ARGUMENTS_INVALID\n";
     return 2;
   }
-  std::vector<double> bodyData(static_cast<std::size_t>(bodyCount) * stride, 0.0);
-  auto setCommon = [&](std::size_t offset, std::uint32_t motion) {
-    bodyData[offset + 9] = motion;
-    bodyData[offset + 10] = 0.0;
-    bodyData[offset + 11] = 1.0;
-    bodyData[offset + 12] = 1.0;
-    bodyData[offset + 13] = 1.0;
-    bodyData[offset + 14] = 1.0;
-    bodyData[offset + 18] = 1.0;
-    bodyData[offset + 25] = 1.0;
-    bodyData[offset + 26] = 1.0;
-    bodyData[offset + 27] = 0.6;
-    bodyData[offset + 31] = 1.0;
-    bodyData[offset + 32] = 1.0;
-    bodyData[offset + 33] = 1.0;
-  };
-  setCommon(0, 0);
-  bodyData[0] = 0.0;
-  bodyData[1] = -32.5;
-  bodyData[10] = 1.0;
-  bodyData[6] = 32.5;
-  for (std::uint32_t index = 1; index < bodyCount; index += 1) {
-    const std::size_t offset = static_cast<std::size_t>(index) * stride;
-    setCommon(offset, 1);
-    bodyData[offset + 10] = 1.0;
-    const std::uint32_t column = (index - 1) % 16;
-    const std::uint32_t row = (index - 1) / 16;
-    bodyData[offset + 0] = static_cast<double>(column) * 1.05 - 7.875;
-    bodyData[offset + 1] = 0.5 + static_cast<double>(row) * 1.05;
-    bodyData[offset + 2] = 0.0;
-    bodyData[offset + 3] = (column % 2 == 0) ? 0.1 : -0.1;
-    bodyData[offset + 6] = 0.5;
-    // Match the Box3D harness, which builds these spheres from density=1.0 and
-    // lets the engine derive mass/inertia. For a solid sphere of radius 0.5:
-    //   mass    = (4/3)*pi*r^3 = pi/6
-    //   inertia = (2/5)*mass*r^2 = 0.1*mass  (isotropic)
-    // Without this, Kinetix would run mass=1/inertia=1 spheres and the same-scene
-    // native-vs-Box3D proof-gate ratio would compare different simulations.
-    constexpr double kSphereMass = 3.14159265358979311599796346854 / 6.0;
-    bodyData[offset + 18] = kSphereMass;
-    bodyData[offset + 31] = 0.1 * kSphereMass;
-    bodyData[offset + 32] = 0.1 * kSphereMass;
-    bodyData[offset + 33] = 0.1 * kSphereMass;
-  }
-  rundot::kinetix::physics::setGeometryData(nullptr, 0);
+  std::vector<double> bodyData = rundot::kinetix::mobile_probe::makeBox3dBodies(bodyCount);
+  rundot::kinetix::mobile_probe::clearPhysicsGlobalState();
   rundot::kinetix::physics::setDynamicTreeEnabled(useDynamicTree);
   const auto start = std::chrono::steady_clock::now();
   for (std::uint32_t frame = 0; frame < frameCount; frame += 1) {
@@ -633,7 +573,221 @@ int runPhysicsBenchmark(std::uint32_t bodyCount, std::uint32_t frameCount, bool
             // directly, so an unpadded hash with a leading-zero nibble would look
             // mismatched even when native and wasm-core state are bit-identical.
             << " checksum=" << std::hex << std::setw(16) << std::setfill('0')
-            << benchmarkHash(bodyData, bodyCount) << std::dec << std::setfill(' ') << '\n';
+            << rundot::kinetix::mobile_probe::hashBox3dBodies(bodyData.data(), bodyCount)
+            << std::dec << std::setfill(' ') << '\n';
+  return 0;
+}
+
+// Wire encoding for both parity gates; mirrors core/tests/helpers/f64-bits.mjs.
+// Results canonicalise NaN (payload is architecture-defined); args do not, since
+// they must round-trip back to the same double.
+std::string vectorBits(double value) {
+  if (std::isnan(value)) return "nan";
+  std::ostringstream out;
+  out << std::hex << std::setfill('0') << std::setw(16) << std::bit_cast<std::uint64_t>(value);
+  return out.str();
+}
+
+double vectorValue(const std::string& hex) {
+  return std::bit_cast<double>(static_cast<std::uint64_t>(std::stoull(hex, nullptr, 16)));
+}
+
+// stdin corpus, one line out per line in: "u <hex>" -> sin cos atan exp log;
+// "b <hexY> <hexX>" -> atan2 hypot2. Results are 16-digit hex bit patterns.
+// NaN prints as `nan` because its payload is architecture-defined (x86-64 SSE
+// and ARM64 disagree) and IEEE-754 does not pin it; the JS side matches.
+// Bench kernel for the cross-lane harness. Prints through vectorBits for the
+// same reason the parity emitters do: a decimal digest would drag ECMAScript
+// number formatting into a cross-lane comparison.
+int runBenchFixedKernel(int iterations) {
+  namespace fx = rundot::fixedmath;
+  const fx::Config cfg = fx::defaultConfig();
+  bool ok = true;
+  fx::Vec3 p{0, 0, 0};
+  fx::Vec3 v{1000, 2000, -500};
+  double acc = 0;
+  // Timed inside the process so the ~10ms spawn stays out of the measurement.
+  const auto started = std::chrono::steady_clock::now();
+  for (int i = 0; i < iterations; i += 1) {
+    p = fx::vec3Add(cfg, p, fx::vec3Scale(cfg, v, 990, ok), ok);
+    acc += fx::vec3Length(cfg, p, ok);
+    v = fx::vec3Scale(cfg, v, 999, ok);
+    if (p.x > 2000000000.0) p = fx::Vec3{0, 0, 0};
+  }
+  const auto elapsed = std::chrono::steady_clock::now() - started;
+  std::cout << vectorBits(acc) << ' '
+            << std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed).count() << '\n';
+  return ok ? 0 : 1;
+}
+
+int runMathVectors() {
+  std::string line;
+  while (std::getline(std::cin, line)) {
+    if (line.empty()) continue;
+    std::istringstream fields(line);
+    std::string kind;
+    fields >> kind;
+    if (kind == "u") {
+      std::string bits;
+      fields >> bits;
+      const double value = vectorValue(bits);
+      std::cout << vectorBits(rundot::detmath::det_sin(value)) << ' '
+                << vectorBits(rundot::detmath::det_cos(value)) << ' '
+                << vectorBits(rundot::detmath::det_atan(value)) << ' '
+                << vectorBits(rundot::detmath::det_exp(value)) << ' '
+                << vectorBits(rundot::detmath::det_log(value)) << '\n';
+    } else if (kind == "b") {
+      std::string yBits;
+      std::string xBits;
+      fields >> yBits >> xBits;
+      const double y = vectorValue(yBits);
+      const double x = vectorValue(xBits);
+      std::cout << vectorBits(rundot::detmath::det_atan2(y, x)) << ' '
+                << vectorBits(rundot::detmath::det_hypot2(y, x)) << '\n';
+    } else {
+      std::cerr << "KINETIX_MATH_VECTORS_BAD_KIND " << kind << '\n';
+      return 1;
+    }
+  }
+  return 0;
+}
+
+// stdin corpus for the fixed-point twin, one line out per line in:
+// "<op> <arg>..." where vector args are flattened. Args and results are all
+// 16-digit hex f64 bit patterns — decimal would drag ECMAScript number
+// formatting into the gate and truncate clamp's non-integer results. Output is
+// one pattern, a comma-separated list for vectors/quaternions, `nan`, or ERR
+// where the TypeScript reference throws.
+int runFixedVectors() {
+  namespace fx = rundot::fixedmath;
+  const fx::Config cfg = fx::defaultConfig();
+  // Widened bounds so an over-2^53 mul result is not saturated, which is the
+  // only way the double-rounding semantic is observable. See fixed_math.cpp.
+  const fx::Config wide{1000.0, -4611686018427387904.0, 4611686018427387904.0};
+
+  std::string line;
+  while (std::getline(std::cin, line)) {
+    if (line.empty()) continue;
+    std::istringstream fields(line);
+    std::string op;
+    fields >> op;
+
+    std::vector<double> a;
+    std::string token;
+    while (fields >> token) {
+      a.push_back(vectorValue(token));
+    }
+
+    // Guards the a[0]..a[8] indexing below. A short line is a harness bug, not
+    // a parity result: fail loudly rather than read past the end.
+    const auto arity = [&](std::size_t n) {
+      if (a.size() >= n) return true;
+      std::cerr << "KINETIX_FIXED_VECTORS_BAD_ARITY op=" << op
+                << " want=" << n << " got=" << a.size() << '\n';
+      return false;
+    };
+    std::size_t want = 0;
+    if (op == "remap") want = 5;
+    else if (op == "quatLerp") want = 9;
+    else if (op == "vec3Lerp") want = 7;
+    else if (op == "vec3Add" || op == "vec3Sub" || op == "vec3Dot" || op == "vec3Cross" ||
+             op == "vec3Distance") want = 6;
+    else if (op == "vec2Lerp") want = 5;
+    else if (op == "vec3Scale" || op == "vec2Add" || op == "vec2Sub" || op == "vec2Dot" ||
+             op == "vec2Cross" || op == "vec2DistanceSq" || op == "vec2Distance") want = 4;
+    else if (op == "lerp" || op == "inverseLerp" || op == "smoothstep" || op == "clamp" ||
+             op == "vec3" || op == "vec2Rotate" || op == "vec2Scale" || op == "vec3LengthSq" ||
+             op == "vec3Length" || op == "vec3Normalize" || op == "vec3Negate") want = 3;
+    else if (op == "fromFixed" || op == "toFixed" || op == "sqrt" || op == "integerSqrt" ||
+             op == "abs" || op == "sign" || op == "log2Fixed" || op == "exp" || op == "log" ||
+             op == "sinTurns" || op == "cosTurns" || op == "tanTurns" || op == "wrapTurns" ||
+             op == "turnsToRadians" || op == "radiansToTurns" || op == "quatFromYawTurns") want = 1;
+    else want = 2;
+    if (!arity(want)) return 1;
+
+    bool ok = true;
+    std::string out;
+    const auto scalar = [&](double v) { out = vectorBits(v); };
+    const auto v2 = [&](fx::Vec2 v) { out = vectorBits(v.x) + "," + vectorBits(v.y); };
+    const auto v3 = [&](fx::Vec3 v) { out = vectorBits(v.x) + "," + vectorBits(v.y) + "," + vectorBits(v.z); };
+
+    if (op == "toFixed") scalar(fx::toFixed(cfg, a[0], ok));
+    else if (op == "fromFixed") scalar(fx::fromFixed(cfg, a[0], ok));
+    else if (op == "add") scalar(fx::add(cfg, a[0], a[1], ok));
+    else if (op == "sub") scalar(fx::sub(cfg, a[0], a[1], ok));
+    else if (op == "mul") scalar(fx::mul(cfg, a[0], a[1], ok));
+    else if (op == "mulWide") scalar(fx::mul(wide, a[0], a[1], ok));
+    else if (op == "div") scalar(fx::div(cfg, a[0], a[1], ok));
+    else if (op == "saturatingAdd") scalar(fx::saturatingAdd(cfg, a[0], a[1], ok));
+    else if (op == "saturatingSub") scalar(fx::saturatingSub(cfg, a[0], a[1], ok));
+    else if (op == "quantize") scalar(fx::quantize(cfg, a[0], a[1], ok));
+    else if (op == "sqrt") scalar(fx::sqrtFixed(cfg, a[0], ok));
+    else if (op == "integerSqrt") scalar(fx::integerSqrt(cfg, a[0], ok));
+    else if (op == "abs") scalar(fx::absFixed(cfg, a[0], ok));
+    else if (op == "sign") scalar(fx::sign(cfg, a[0], ok));
+    else if (op == "min") scalar(fx::minFixed(cfg, a[0], a[1], ok));
+    else if (op == "max") scalar(fx::maxFixed(cfg, a[0], a[1], ok));
+    else if (op == "lerp") scalar(fx::lerp(cfg, a[0], a[1], a[2], ok));
+    else if (op == "mod") scalar(fx::mod(cfg, a[0], a[1], ok));
+    else if (op == "inverseLerp") scalar(fx::inverseLerp(cfg, a[0], a[1], a[2], ok));
+    else if (op == "remap") scalar(fx::remap(cfg, a[0], a[1], a[2], a[3], a[4], ok));
+    else if (op == "smoothstep") scalar(fx::smoothstep(cfg, a[0], a[1], a[2], ok));
+    else if (op == "clamp") scalar(fx::clamp(cfg, a[0], a[1], a[2], ok));
+    else if (op == "log2Fixed") scalar(fx::log2Fixed(cfg, a[0], ok));
+    else if (op == "exp") scalar(fx::expFixed(cfg, a[0], ok));
+    else if (op == "log") scalar(fx::logFixed(cfg, a[0], ok));
+    else if (op == "sinTurns") scalar(fx::sinTurns(cfg, a[0], ok));
+    else if (op == "cosTurns") scalar(fx::cosTurns(cfg, a[0], ok));
+    else if (op == "tanTurns") scalar(fx::tanTurns(cfg, a[0], ok));
+    else if (op == "atan2") scalar(fx::atan2Turns(cfg, a[0], a[1], ok));
+    else if (op == "atan2Signed") scalar(fx::atan2Signed(cfg, a[0], a[1], ok));
+    else if (op == "wrapTurns") scalar(fx::wrapTurns(cfg, a[0], ok));
+    else if (op == "angleDeltaTurns") scalar(fx::angleDeltaTurns(cfg, a[0], a[1], ok));
+    else if (op == "turnsToRadians") scalar(fx::turnsToRadians(cfg, a[0], ok));
+    else if (op == "radiansToTurns") scalar(fx::radiansToTurns(cfg, a[0], ok));
+    else if (op == "hypot") scalar(fx::hypot(cfg, a[0], a[1], ok));
+    else if (op == "vec2") v2(fx::vec2(cfg, a[0], a[1], ok));
+    else if (op == "vec2Add") v2(fx::vec2Add(cfg, {a[0], a[1]}, {a[2], a[3]}, ok));
+    else if (op == "vec2Sub") v2(fx::vec2Sub(cfg, {a[0], a[1]}, {a[2], a[3]}, ok));
+    else if (op == "vec2Scale") v2(fx::vec2Scale(cfg, {a[0], a[1]}, a[2], ok));
+    else if (op == "vec2Dot") scalar(fx::vec2Dot(cfg, {a[0], a[1]}, {a[2], a[3]}, ok));
+    else if (op == "vec2Cross") scalar(fx::vec2Cross(cfg, {a[0], a[1]}, {a[2], a[3]}, ok));
+    else if (op == "vec2LengthSq") scalar(fx::vec2LengthSq(cfg, {a[0], a[1]}, ok));
+    else if (op == "vec2Length") scalar(fx::vec2Length(cfg, {a[0], a[1]}, ok));
+    else if (op == "vec2DistanceSq") scalar(fx::vec2DistanceSq(cfg, {a[0], a[1]}, {a[2], a[3]}, ok));
+    else if (op == "vec2Distance") scalar(fx::vec2Distance(cfg, {a[0], a[1]}, {a[2], a[3]}, ok));
+    else if (op == "vec2Normalize") v2(fx::vec2Normalize(cfg, {a[0], a[1]}, ok));
+    else if (op == "vec2Perp") v2(fx::vec2Perp(cfg, {a[0], a[1]}, ok));
+    else if (op == "vec2Negate") v2(fx::vec2Negate(cfg, {a[0], a[1]}, ok));
+    else if (op == "vec2Rotate") v2(fx::vec2Rotate(cfg, {a[0], a[1]}, a[2], ok));
+    else if (op == "vec2FromAngleTurns") v2(fx::vec2FromAngleTurns(cfg, a[0], a[1], ok));
+    else if (op == "vec2AngleTurns") scalar(fx::vec2AngleTurns(cfg, {a[0], a[1]}, ok));
+    else if (op == "vec2Lerp") v2(fx::vec2Lerp(cfg, {a[0], a[1]}, {a[2], a[3]}, a[4], ok));
+    else if (op == "vec3") v3(fx::vec3(cfg, a[0], a[1], a[2], ok));
+    else if (op == "vec3Add") v3(fx::vec3Add(cfg, {a[0], a[1], a[2]}, {a[3], a[4], a[5]}, ok));
+    else if (op == "vec3Sub") v3(fx::vec3Sub(cfg, {a[0], a[1], a[2]}, {a[3], a[4], a[5]}, ok));
+    else if (op == "vec3Scale") v3(fx::vec3Scale(cfg, {a[0], a[1], a[2]}, a[3], ok));
+    else if (op == "vec3Dot") scalar(fx::vec3Dot(cfg, {a[0], a[1], a[2]}, {a[3], a[4], a[5]}, ok));
+    else if (op == "vec3Cross") v3(fx::vec3Cross(cfg, {a[0], a[1], a[2]}, {a[3], a[4], a[5]}, ok));
+    else if (op == "vec3LengthSq") scalar(fx::vec3LengthSq(cfg, {a[0], a[1], a[2]}, ok));
+    else if (op == "vec3Length") scalar(fx::vec3Length(cfg, {a[0], a[1], a[2]}, ok));
+    else if (op == "vec3Distance") scalar(fx::vec3Distance(cfg, {a[0], a[1], a[2]}, {a[3], a[4], a[5]}, ok));
+    else if (op == "vec3Normalize") v3(fx::vec3Normalize(cfg, {a[0], a[1], a[2]}, ok));
+    else if (op == "vec3Lerp") v3(fx::vec3Lerp(cfg, {a[0], a[1], a[2]}, {a[3], a[4], a[5]}, a[6], ok));
+    else if (op == "vec3Negate") v3(fx::vec3Negate(cfg, {a[0], a[1], a[2]}, ok));
+    else if (op == "quatFromYawTurns") {
+      const fx::Quat q = fx::quatFromYawTurns(cfg, a[0], ok);
+      out = vectorBits(q.x) + "," + vectorBits(q.y) + "," + vectorBits(q.z) + "," + vectorBits(q.w);
+    } else if (op == "quatLerp") {
+      const fx::Quat q = fx::quatLerp(cfg, {a[0], a[1], a[2], a[3]}, {a[4], a[5], a[6], a[7]}, a[8], ok);
+      out = vectorBits(q.x) + "," + vectorBits(q.y) + "," + vectorBits(q.z) + "," + vectorBits(q.w);
+    } else {
+      std::cerr << "KINETIX_FIXED_VECTORS_UNKNOWN_OP " << op << '\n';
+      return 1;
+    }
+
+    std::cout << (ok ? out : std::string("ERR")) << '\n';
+  }
   return 0;
 }
 
@@ -641,28 +795,13 @@ int runPhysicsBenchmark(std::uint32_t bodyCount, std::uint32_t frameCount, bool
 
 int main(int argc, char** argv) {
   if (argc == 2 && std::string(argv[1]) == "--math-vectors") {
-    constexpr std::array<std::uint64_t, 16> inputs = {
-      0x0000000000000000ULL, 0x0000000000000001ULL,
-      0x3d719799812dea11ULL, 0x3fb999999999999aULL,
-      0x3fc0000000000000ULL, 0x3fd0000000000000ULL,
-      0x3fe0000000000000ULL, 0x3fe8000000000000ULL,
-      0x3ff0000000000000ULL, 0x3ff8000000000000ULL,
-      0x4000000000000000ULL, 0x4005bf0a8b145769ULL,
-      0x400921fb54442d18ULL, 0x4010000000000000ULL,
-      0x4014000000000000ULL, 0x4024000000000000ULL,
-    };
-    for (const std::uint64_t input_bits : inputs) {
-      const double value = std::bit_cast<double>(input_bits);
-      const auto bits = [](double result) { return std::bit_cast<std::uint64_t>(result); };
-      std::cout << std::hex << std::setfill('0')
-                << std::setw(16) << input_bits << ' '
-                << std::setw(16) << bits(rundot::detmath::det_sin(value)) << ' '
-                << std::setw(16) << bits(rundot::detmath::det_cos(value)) << ' '
-                << std::setw(16) << bits(rundot::detmath::det_atan2(value, value + 0.25)) << ' '
-                << std::setw(16) << bits(rundot::detmath::det_exp(value)) << ' '
-                << std::setw(16) << bits(rundot::detmath::det_log(value)) << '\n';
-    }
-    return 0;
+    return runMathVectors();
+  }
+  if (argc == 2 && std::string(argv[1]) == "--fixed-vectors") {
+    return runFixedVectors();
+  }
+  if (argc == 3 && std::string(argv[1]) == "--bench-fixed-kernel") {
+    return runBenchFixedKernel(std::stoi(argv[2]));
   }
   if (argc == 3 && std::string(argv[1]) == "--physics-vectors") {
     return runPhysicsVectors(argv[2]);

package/core/native/mobile/box3d_probe_scenario.cpp

@@ -0,0 +1,101 @@
+#include "box3d_probe_scenario.hpp"
+
+#include "../physics/physics.hpp"
+
+#include <bit>
+#include <limits>
+#include <stdexcept>
+
+namespace rundot::kinetix::mobile_probe {
+
+namespace {
+
+static_assert(sizeof(float) == sizeof(std::uint32_t));
+static_assert(std::numeric_limits<float>::is_iec559);
+
+constexpr double kSphereMass = 3.14159265358979311599796346854 / 6.0;
+
+void setCommonFields(std::vector<double>& bodyData, std::size_t offset, std::uint32_t motion) {
+  bodyData[offset + 9] = static_cast<double>(motion);
+  bodyData[offset + 10] = 0.0;
+  bodyData[offset + 11] = 1.0;
+  bodyData[offset + 12] = 1.0;
+  bodyData[offset + 13] = 1.0;
+  bodyData[offset + 14] = 1.0;
+  bodyData[offset + 18] = 1.0;
+  bodyData[offset + 25] = 1.0;
+  bodyData[offset + 26] = 1.0;
+  bodyData[offset + 27] = 0.6;
+  bodyData[offset + 31] = 1.0;
+  bodyData[offset + 32] = 1.0;
+  bodyData[offset + 33] = 1.0;
+}
+
+void hashFloat32(std::uint64_t& hash, double value) {
+  constexpr std::uint64_t prime = 1099511628211ULL;
+  const float narrowed = static_cast<float>(value);
+  hash ^= static_cast<std::uint64_t>(std::bit_cast<std::uint32_t>(narrowed));
+  hash *= prime;
+}
+
+}  // namespace
+
+std::vector<double> makeBox3dBodies(std::uint32_t bodyCount) {
+  if (bodyCount < 2 || bodyCount > 100000) {
+    throw std::invalid_argument("SYNCPLAY_BOX3D_BODY_COUNT_INVALID");
+  }
+
+  std::vector<double> bodyData(static_cast<std::size_t>(bodyCount) * kBodyStride, 0.0);
+  setCommonFields(bodyData, 0, 0);
+  bodyData[0] = 0.0;
+  bodyData[1] = -32.5;
+  bodyData[10] = 1.0;
+  bodyData[6] = 32.5;
+
+  for (std::uint32_t index = 1; index < bodyCount; index += 1) {
+    const std::size_t offset = static_cast<std::size_t>(index) * kBodyStride;
+    setCommonFields(bodyData, offset, 1);
+    bodyData[offset + 10] = 1.0;
+    const std::uint32_t column = (index - 1) % 16;
+    const std::uint32_t row = (index - 1) / 16;
+    bodyData[offset + 0] = static_cast<double>(column) * 1.05 - 7.875;
+    bodyData[offset + 1] = 0.5 + static_cast<double>(row) * 1.05;
+    bodyData[offset + 2] = 0.0;
+    bodyData[offset + 3] = (column % 2 == 0) ? 0.1 : -0.1;
+    bodyData[offset + 6] = 0.5;
+    bodyData[offset + 18] = kSphereMass;
+    bodyData[offset + 31] = 0.1 * kSphereMass;
+    bodyData[offset + 32] = 0.1 * kSphereMass;
+    bodyData[offset + 33] = 0.1 * kSphereMass;
+  }
+
+  return bodyData;
+}
+
+std::uint64_t hashBox3dBodies(const double* bodyData, std::uint32_t bodyCount) {
+  if (bodyData == nullptr || bodyCount < 2) return 0;
+  constexpr std::uint64_t offsetBasis = 1469598103934665603ULL;
+  std::uint64_t hash = offsetBasis;
+  for (std::uint32_t bodyIndex = 1; bodyIndex < bodyCount; bodyIndex += 1) {
+    const std::size_t offset = static_cast<std::size_t>(bodyIndex) * kBodyStride;
+    // x/y/z, linear velocity, angular velocity, and quaternion orientation.
+    for (const std::uint32_t field : {0U, 1U, 2U, 3U, 4U, 5U, 19U, 20U, 21U,
+                                      22U, 23U, 24U, 25U}) {
+      hashFloat32(hash, bodyData[offset + field]);
+    }
+  }
+  return hash;
+}
+
+void clearPhysicsGlobalState() {
+  using rundot::kinetix::physics::setContactCacheData;
+  using rundot::kinetix::physics::setDynamicTreeEnabled;
+  using rundot::kinetix::physics::setExternalForceData;
+  using rundot::kinetix::physics::setGeometryData;
+  setGeometryData(nullptr, 0);
+  setContactCacheData(nullptr, 0);
+  setExternalForceData(nullptr, 0);
+  setDynamicTreeEnabled(true);
+}
+
+}  // namespace rundot::kinetix::mobile_probe

package/core/native/mobile/box3d_probe_scenario.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+namespace rundot::kinetix::mobile_probe {
+
+constexpr std::uint32_t kScenarioBox3dV1 = 1;
+constexpr std::uint32_t kBodyCount = 128;
+constexpr std::uint32_t kSmokeFrames = 120;
+constexpr std::uint32_t kPerfFrames = 1200;
+constexpr std::uint32_t kBodyStride = 44;
+
+// The probe intentionally uses the same SoA record as the existing Kinetix
+// physics ABI. The returned vector owns all state and is safe to hand to the
+// physics stepper for the duration of one serialized probe call.
+std::vector<double> makeBox3dBodies(std::uint32_t bodyCount = kBodyCount);
+
+// Hash dynamic bodies in canonical body order. Every value is narrowed to an
+// IEEE-754 binary32 before its little-endian bit pattern is mixed into FNV-1a.
+std::uint64_t hashBox3dBodies(const double* bodyData, std::uint32_t bodyCount);
+
+void clearPhysicsGlobalState();
+
+}  // namespace rundot::kinetix::mobile_probe