feat: data-oriented input sources

.oxlintrc.json

@@ -33,7 +33,8 @@
                   "camera-controls",
                   "**/three/**",
                   "**/react/**",
-                  "**/dom/**"
+                  "**/dom/**",
+                  "**/input-sources/**"
                 ],
                 "message": "core imports only math."
               }
@@ -50,14 +51,38 @@
           {
             "patterns": [
               {
-                "group": ["react", "react/*", "react-dom", "@react-three/*", "**/react/**", "**/dom/**"],
+                "group": [
+                  "react",
+                  "react/*",
+                  "react-dom",
+                  "@react-three/*",
+                  "**/react/**",
+                  "**/dom/**",
+                  "**/input-sources/**"
+                ],
                 "message": "three must not depend on React or the DOM layer."
               }
             ]
           }
         ]
       }
     },
+    {
+      "files": ["src/react/**"],
+      "rules": {
+        "no-restricted-imports": [
+          "error",
+          {
+            "patterns": [
+              {
+                "group": ["**/input-sources/**"],
+                "message": "React reads input through the dom layer."
+              }
+            ]
+          }
+        ]
+      }
+    },
     {
       "files": ["src/dom/**"],
       "rules": {
@@ -83,6 +108,31 @@
         ]
       }
     },
+    {
+      "files": ["src/input-sources/**"],
+      "rules": {
+        "no-restricted-imports": [
+          "error",
+          {
+            "patterns": [
+              {
+                "group": [
+                  "../**",
+                  "three",
+                  "three/*",
+                  "react",
+                  "react/*",
+                  "react-dom",
+                  "@react-three/*",
+                  "camera-controls"
+                ],
+                "message": "input-sources import only each other and math."
+              }
+            ]
+          }
+        ]
+      }
+    },
     {
       "files": ["test/**"],
       "rules": {

benches/README.md

@@ -20,7 +20,8 @@ The folders follow `src`:
 
 - `core/`: one piece or core step at a time (`@body`, `@aim`, `@noise`, `@impulse`, `@controller`, `@core`, `@blend`)
 - `three/`: target reads through the registry (`@targets`)
-- `dom/`: input event handlers (`@input`)
+- `input-sources/`: one input source at a time, an event and the frame after it (`@input`)
+- `dom/`: a whole `InputControllerDom` frame, from events to axes (`@input`)
 - `scenes/`: whole frames of `KlippThree` with 1 to 50 cameras and a blend (`@scene`)
 
 The scene benches take long enough per iteration to stay above the noise of a busy machine. Use them to spot a regression, then the smaller benches to find where it comes from.
@@ -33,4 +34,6 @@ Results are saved to `.labs/` (gitignored). A comparison only reports a change w
 
 ## Writing a bench
 
-Code before `yield` is setup, and the yielded function is measured. Return a value from the measured function that depends on the work, so it isn't optimized away. Shared moving targets live in `targets.ts`.
+Code before `yield` is setup, and the yielded function is measured. Return a value from the measured function that depends on the work, so it isn't optimized away. Shared moving targets live in `targets.ts`, and a fake DOM for input benches in `fakeDom.ts`.
+
+labs times the first calls to decide whether to batch. When they run through a lot of cold code, it times every call alone and mostly measures its own timer, which shows up as microseconds and kilobytes for sub-microsecond work. Wrap such a function in `warm` from `warm.ts` before yielding it.

benches/core/aim.bench.ts

@@ -8,18 +8,19 @@ import { HardLookAtAimThree } from '../../src/three/aim/HardLookAtAimThree';
 import { RotationComposerAimThree } from '../../src/three/aim/RotationComposerAimThree';
 
 import { makeMovingTarget } from '../targets';
+import { warm } from '../warm';
 
 group('Aim.update @aim', () => {
   bench('HardLookAt', function* () {
     const { object, step } = makeMovingTarget();
     const aim = new HardLookAtAimThree(object);
     const out = cameraState.create();
     vec3.set(out.position, 0, 2, 15);
-    yield () => {
+    yield warm(() => {
       step();
       aim.update(out);
       return out.quaternion[0];
-    };
+    });
   });
 
   bench('RotationComposer (deadZone + hardLimit)', function* () {
@@ -33,11 +34,11 @@ group('Aim.update @aim', () => {
     });
     const out = cameraState.create();
     vec3.set(out.position, 0, 2, 15);
-    yield () => {
+    yield warm(() => {
       step();
       aim.update(out, 0.016, false);
       return out.quaternion[0];
-    };
+    });
   });
 
   bench('RotationComposer (deadZone + hardLimit + lookahead)', function* () {
@@ -54,11 +55,11 @@ group('Aim.update @aim', () => {
     });
     const out = cameraState.create();
     vec3.set(out.position, 0, 2, 15);
-    yield () => {
+    yield warm(() => {
       step();
       aim.update(out, 0.016, false);
       return out.quaternion[0];
-    };
+    });
   });
 
   // Where a live camera spends most frames: both dampers return early.
@@ -72,9 +73,9 @@ group('Aim.update @aim', () => {
     const out = cameraState.create();
     vec3.set(out.position, 0, 2, 15);
     aim.update(out, 0.016, true);
-    yield () => {
+    yield warm(() => {
       aim.update(out, 0.016, false);
       return out.quaternion[0];
-    };
+    });
   });
 });

benches/core/blend.bench.ts

@@ -5,6 +5,8 @@ import { Matrix4, Quaternion, Vector3 } from 'three';
 import * as cameraState from '../../src/core/CameraState';
 import { BlendHints } from '../../src/core/blend/BlendHints';
 
+import { warm } from '../warm';
+
 /** Runs every frame of a blend, and never once it settles. */
 group('cameraState.lerp @blend', () => {
   function makeOrbitingState(position: Vector3, lookAtTarget: Vector3) {
@@ -27,20 +29,20 @@ group('cameraState.lerp @blend', () => {
     vec3.set(b.position, 0, 0, 5);
     new Quaternion().setFromAxisAngle(new Vector3(0, 1, 0), Math.PI / 2).toArray(b.quaternion);
     const out = cameraState.create();
-    yield () => cameraState.lerp(out, a, b, 0.5).position[0];
+    yield warm(() => cameraState.lerp(out, a, b, 0.5).position[0]);
   });
 
   bench('lookAtTarget-driven rotation', function* () {
     const a = makeOrbitingState(new Vector3(5, 5, 5), new Vector3(0, 0, 0));
     const b = makeOrbitingState(new Vector3(0, 0, 5), new Vector3(0, 0, 0));
     const out = cameraState.create();
-    yield () => cameraState.lerp(out, a, b, 0.5).position[0];
+    yield warm(() => cameraState.lerp(out, a, b, 0.5).position[0]);
   });
 
   bench('lookAtTarget-driven rotation + sphericalPosition hint', function* () {
     const a = makeOrbitingState(new Vector3(5, 5, 5), new Vector3(0, 0, 0));
     const b = makeOrbitingState(new Vector3(0, 0, 5), new Vector3(0, 0, 0));
     const out = cameraState.create();
-    yield () => cameraState.lerp(out, a, b, 0.5, BlendHints.sphericalPosition).position[0];
+    yield warm(() => cameraState.lerp(out, a, b, 0.5, BlendHints.sphericalPosition).position[0]);
   });
 });

benches/core/body.bench.ts

@@ -7,28 +7,29 @@ import { HardLockToTargetBodyThree } from '../../src/three/body/HardLockToTarget
 import { PositionComposerBodyThree } from '../../src/three/body/PositionComposerBodyThree';
 
 import { makeMovingMeshTarget, makeMovingTarget } from '../targets';
+import { warm } from '../warm';
 
 group('Body.update @body', () => {
   bench('HardLockToTarget', function* () {
     const { object, step } = makeMovingTarget();
     const body = new HardLockToTargetBodyThree(object, { damping: 0.5 });
     const out = cameraState.create();
-    yield () => {
+    yield warm(() => {
       step();
       body.update(out, 0.016, false);
       return out.position[0];
-    };
+    });
   });
 
   bench('Follow (lockToTarget binding)', function* () {
     const { object, step } = makeMovingTarget();
     const body = new FollowBodyThree(object, { offset: [0, 3, 8], damping: 0.5 });
     const out = cameraState.create();
-    yield () => {
+    yield warm(() => {
       step();
       body.update(out, 0.016, false);
       return out.position[0];
-    };
+    });
   });
 
   bench('PositionComposer (deadZone + hardLimit)', function* () {
@@ -42,11 +43,11 @@ group('Body.update @body', () => {
       hardLimit: [0.4, 0.4],
     });
     const out = cameraState.create();
-    yield () => {
+    yield warm(() => {
       step();
       body.update(out, 0.016, false);
       return out.position[0];
-    };
+    });
   });
 
   bench('PositionComposer (deadZone + hardLimit + lookahead)', function* () {
@@ -63,11 +64,11 @@ group('Body.update @body', () => {
       lookaheadSmoothing: 1,
     });
     const out = cameraState.create();
-    yield () => {
+    yield warm(() => {
       step();
       body.update(out, 0.016, false);
       return out.position[0];
-    };
+    });
   });
 
   bench('PositionComposer (radius extent)', function* () {
@@ -82,11 +83,11 @@ group('Body.update @body', () => {
       radius: 1.5,
     });
     const out = cameraState.create();
-    yield () => {
+    yield warm(() => {
       step();
       body.update(out, 0.016, false);
       return out.position[0];
-    };
+    });
   });
 
   bench('PositionComposer (explicit size extent, rotating box)', function* () {
@@ -101,11 +102,11 @@ group('Body.update @body', () => {
       size: [2, 2, 2],
     });
     const out = cameraState.create();
-    yield () => {
+    yield warm(() => {
       step();
       body.update(out, 0.016, false);
       return out.position[0];
-    };
+    });
   });
 
   bench('PositionComposer (auto-detected Mesh size extent, rotating box)', function* () {
@@ -119,10 +120,10 @@ group('Body.update @body', () => {
       hardLimit: [0.4, 0.4],
     });
     const out = cameraState.create();
-    yield () => {
+    yield warm(() => {
       step();
       body.update(out, 0.016, false);
       return out.position[0];
-    };
+    });
   });
 });

benches/core/impulse.bench.ts

@@ -6,6 +6,8 @@ import { ImpulseField } from '../../src/core/impulse/ImpulseField';
 import { ImpulseListenerNoise } from '../../src/core/impulse/ImpulseListenerNoise';
 import { BasicMultiChannelPerlinNoise } from '../../src/core/noise/BasicMultiChannelPerlinNoise';
 
+import { warm } from '../warm';
+
 const always = () => 1;
 
 group('ImpulseField.sampleAt @impulse', () => {
@@ -22,35 +24,35 @@ group('ImpulseField.sampleAt @impulse', () => {
     const out: Vec3 = [0, 0, 0];
     const samplePosition: Vec3 = [0, 0, 0];
     let now = 0;
-    yield () => {
+    yield warm(() => {
       now += 0.016;
       field.sampleAt(out, samplePosition, 1, 1, now);
       return out[0];
-    };
+    });
   });
 
   bench('10 concurrent events', function* () {
     const field = makeFieldWithEvents(10);
     const out: Vec3 = [0, 0, 0];
     const samplePosition: Vec3 = [0, 0, 0];
     let now = 0;
-    yield () => {
+    yield warm(() => {
       now += 0.016;
       field.sampleAt(out, samplePosition, 1, 1, now);
       return out[0];
-    };
+    });
   });
 
   bench('50 concurrent events', function* () {
     const field = makeFieldWithEvents(50);
     const out: Vec3 = [0, 0, 0];
     const samplePosition: Vec3 = [0, 0, 0];
     let now = 0;
-    yield () => {
+    yield warm(() => {
       now += 0.016;
       field.sampleAt(out, samplePosition, 1, 1, now);
       return out[0];
-    };
+    });
   });
 });
 
@@ -61,11 +63,11 @@ group('ImpulseListenerNoise.update @impulse', () => {
     const listener = new ImpulseListenerNoise({ field });
     const out = cameraState.create();
     let now = 0;
-    yield () => {
+    yield warm(() => {
       now += 0.016;
       listener.update(out, 0.016, false, now);
       return out.position[0];
-    };
+    });
   });
 
   bench('kick + shake', function* () {
@@ -78,11 +80,11 @@ group('ImpulseListenerNoise.update @impulse', () => {
     const listener = new ImpulseListenerNoise({ field, channelMask: 1, gain: 1, shake });
     const out = cameraState.create();
     let now = 0;
-    yield () => {
+    yield warm(() => {
       now += 0.016;
       listener.update(out, 0.016, false, now);
       return out.position[0];
-    };
+    });
   });
 
   bench('kick + cameraSpace', function* () {
@@ -91,10 +93,10 @@ group('ImpulseListenerNoise.update @impulse', () => {
     const listener = new ImpulseListenerNoise({ field, channelMask: 1, gain: 1, cameraSpace: true });
     const out = cameraState.create();
     let now = 0;
-    yield () => {
+    yield warm(() => {
       now += 0.016;
       listener.update(out, 0.016, false, now);
       return out.position[0];
-    };
+    });
   });
 });