@flighthq/physics3d 0.4.0-next.1694.598ef6f

package/src/islands.test.ts

@@ -0,0 +1,357 @@
+import type { Physics3DContact, Physics3DWorld, RigidBody3D } from '@flighthq/types/contract';
+import { describe, expect, it } from 'vitest';
+
+import { refreshRigidBody3DWorldInertia } from './integrate';
+import { buildPhysics3DSolveIslands, isRigidBody3DPairAwake, updatePhysics3DSleep } from './islands';
+import { computePhysics3DBoxMassData, createPhysics3DMassData, setRigidBody3DMassData } from './massProperties';
+import { addPhysics3DBody, createPhysics3DWorld, createRigidBody3D, setPhysics3DBodyType } from './world';
+
+describe('buildPhysics3DSolveIslands', () => {
+  it('admits every awake dynamic body', () => {
+    const world = createPhysics3DWorld();
+    createBox(world);
+    createBox(world);
+    updatePhysics3DSleep(world, 0);
+    buildPhysics3DSolveIslands(world);
+
+    expect(world.solveIslandBodyIndices).toHaveLength(2);
+  });
+
+  it('separates unconnected bodies into distinct islands', () => {
+    const world = createPhysics3DWorld();
+    createBox(world);
+    createBox(world);
+    updatePhysics3DSleep(world, 0);
+    buildPhysics3DSolveIslands(world);
+
+    expect(world.solveIslandRoots).toHaveLength(2);
+    expect(world.solveIslandBodyCounts).toEqual([1, 1]);
+  });
+
+  it('merges bodies joined by a contact into one island', () => {
+    const world = createPhysics3DWorld();
+    const a = createBox(world);
+    const b = createBox(world);
+    world.contacts.push(createContact(a.index, b.index));
+    updatePhysics3DSleep(world, 0);
+    buildPhysics3DSolveIslands(world);
+
+    expect(world.solveIslandRoots).toHaveLength(1);
+    expect(world.solveIslandBodyCounts).toEqual([2]);
+    expect(world.solveIslandContactCounts).toEqual([1]);
+  });
+
+  it('does not bridge two stacks through shared static ground', () => {
+    // The failure this guards: static bodies joining islands would merge every stack resting on the
+    // same floor into one world-sized island that can only sleep when the whole level stops.
+    const world = createPhysics3DWorld();
+    const ground = createBox(world);
+    setPhysics3DBodyType(ground, 'static');
+    const left = createBox(world);
+    const right = createBox(world);
+    world.contacts.push(createContact(ground.index, left.index));
+    world.contacts.push(createContact(ground.index, right.index));
+    updatePhysics3DSleep(world, 0);
+    buildPhysics3DSolveIslands(world);
+
+    expect(world.solveIslandRoots).toHaveLength(2);
+  });
+
+  it('excludes static and sleeping bodies from the workspace', () => {
+    const world = createPhysics3DWorld();
+    const dynamic = createBox(world);
+    const ground = createBox(world);
+    setPhysics3DBodyType(ground, 'static');
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+    buildPhysics3DSolveIslands(world);
+
+    expect(dynamic.sleeping).toBe(true);
+    expect(world.solveIslandBodyIndices).toHaveLength(0);
+    expect(world.solveIslandRoots).toHaveLength(0);
+  });
+
+  it('gives each island a contiguous, non-overlapping slice', () => {
+    const world = createPhysics3DWorld();
+    const a = createBox(world);
+    const b = createBox(world);
+    createBox(world);
+    world.contacts.push(createContact(a.index, b.index));
+    updatePhysics3DSleep(world, 0);
+    buildPhysics3DSolveIslands(world);
+
+    const seen = new Set<number>();
+    for (let island = 0; island < world.solveIslandRoots.length; island += 1) {
+      const start = world.solveIslandBodyStarts[island];
+      for (let i = 0; i < world.solveIslandBodyCounts[island]; i += 1) {
+        const value = world.solveIslandBodyIndices[start + i];
+        expect(seen.has(value)).toBe(false);
+        seen.add(value);
+      }
+    }
+    expect(seen.size).toBe(3);
+  });
+
+  it('skips a contact whose bodies are all asleep or static', () => {
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    const ground = createBox(world);
+    setPhysics3DBodyType(ground, 'static');
+    world.contacts.push(createContact(body.index, ground.index));
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+    buildPhysics3DSolveIslands(world);
+
+    expect(world.solveIslandContactIndices).toHaveLength(0);
+  });
+
+  it('refills in place rather than growing across rebuilds', () => {
+    const world = createPhysics3DWorld();
+    createBox(world);
+    createBox(world);
+    updatePhysics3DSleep(world, 0);
+    buildPhysics3DSolveIslands(world);
+    const first = world.solveIslandBodyIndices.length;
+    buildPhysics3DSolveIslands(world);
+
+    expect(world.solveIslandBodyIndices).toHaveLength(first);
+  });
+});
+
+describe('isRigidBody3DPairAwake', () => {
+  it('is true while either end can still move', () => {
+    const world = createPhysics3DWorld();
+    const awake = createBox(world);
+    const asleep = createBox(world);
+    asleep.sleeping = true;
+
+    expect(isRigidBody3DPairAwake(awake, asleep)).toBe(true);
+    expect(isRigidBody3DPairAwake(asleep, awake)).toBe(true);
+  });
+
+  it('is false for two sleeping bodies', () => {
+    const world = createPhysics3DWorld();
+    const a = createBox(world);
+    const b = createBox(world);
+    a.sleeping = true;
+    b.sleeping = true;
+
+    expect(isRigidBody3DPairAwake(a, b)).toBe(false);
+  });
+
+  it('is false for a sleeper resting on static scenery', () => {
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    const ground = createBox(world);
+    setPhysics3DBodyType(ground, 'static');
+    body.sleeping = true;
+
+    expect(isRigidBody3DPairAwake(body, ground)).toBe(false);
+  });
+});
+
+describe('updatePhysics3DSleep', () => {
+  it('sleeps a still body once it has been settled for timeToSleep', () => {
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    updatePhysics3DSleep(world, world.config.timeToSleep + 0.001);
+
+    expect(body.sleeping).toBe(true);
+  });
+
+  it('zeroes velocity on sleeping so a woken body does not resume stale motion', () => {
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+    body.velocityX = 0; // already zeroed; assert the angular axes too
+    updatePhysics3DSleep(world, 0);
+
+    expect(body.velocityX).toBe(0);
+    expect(body.velocityY).toBe(0);
+    expect(body.velocityZ).toBe(0);
+    expect(body.angularVelocityX).toBe(0);
+    expect(body.angularVelocityY).toBe(0);
+    expect(body.angularVelocityZ).toBe(0);
+  });
+
+  it('keeps a moving body awake', () => {
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    body.velocityX = 10;
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+
+    expect(body.sleeping).toBe(false);
+    expect(body.sleepTimer).toBe(0);
+  });
+
+  it('treats angular velocity as a magnitude, not per axis', () => {
+    // Three axes each just under the threshold is a body tumbling at sqrt(3) times it.
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    const perAxis = world.config.sleepAngularThreshold * 0.9;
+    body.angularVelocityX = perAxis;
+    body.angularVelocityY = perAxis;
+    body.angularVelocityZ = perAxis;
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+
+    expect(body.sleeping).toBe(false);
+  });
+
+  it('treats an applied force as motion even before it becomes velocity', () => {
+    // A sleeper skips the integration that would turn force into velocity, and the step clears forces
+    // at the end — so a body under continuous load would silently swallow every push.
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    body.forceY = 100;
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+
+    expect(body.sleeping).toBe(false);
+  });
+
+  it('treats an applied torque as motion', () => {
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    body.torqueZ = 100;
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+
+    expect(body.sleeping).toBe(false);
+  });
+
+  it('keeps a whole island awake while any one member still moves', () => {
+    // The failure this guards: a settled crate sleeping while the crate it rests on slides out.
+    const world = createPhysics3DWorld();
+    const settled = createBox(world);
+    const moving = createBox(world);
+    moving.velocityX = 10;
+    world.contacts.push(createContact(settled.index, moving.index));
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+
+    expect(settled.sleeping).toBe(false);
+    expect(moving.sleeping).toBe(false);
+  });
+
+  it('sleeps an island only once every member has settled', () => {
+    const world = createPhysics3DWorld();
+    const a = createBox(world);
+    const b = createBox(world);
+    b.velocityX = 10;
+    world.contacts.push(createContact(a.index, b.index));
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+    expect(a.sleeping).toBe(false);
+
+    b.velocityX = 0;
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+    expect(a.sleeping).toBe(true);
+    expect(b.sleeping).toBe(true);
+  });
+
+  it('keeps a rider awake on a moving kinematic platform', () => {
+    // Kinematic bodies deliberately join islands. Excluding them the way static bodies are excluded
+    // would let this crate sleep while the lift is still travelling.
+    const world = createPhysics3DWorld();
+    const crate = createBox(world);
+    const lift = createBox(world);
+    setPhysics3DBodyType(lift, 'kinematic');
+    lift.velocityY = 5;
+    world.contacts.push(createContact(crate.index, lift.index));
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+
+    expect(crate.sleeping).toBe(false);
+  });
+
+  it('wakes everything when sleeping is switched off', () => {
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+    expect(body.sleeping).toBe(true);
+
+    world.config.allowSleeping = false;
+    updatePhysics3DSleep(world, 0);
+    expect(body.sleeping).toBe(false);
+    expect(body.sleepTimer).toBe(0);
+  });
+
+  it('builds the island graph even when sleeping is switched off', () => {
+    // Returning early without the union-find would split every awake body into a singleton, and a
+    // two-body constraint would then be assigned to only one of those artificial components.
+    const world = createPhysics3DWorld();
+    const a = createBox(world);
+    const b = createBox(world);
+    world.contacts.push(createContact(a.index, b.index));
+    world.config.allowSleeping = false;
+    updatePhysics3DSleep(world, 0);
+    buildPhysics3DSolveIslands(world);
+
+    expect(world.solveIslandRoots).toHaveLength(1);
+    expect(world.solveIslandBodyCounts).toEqual([2]);
+  });
+
+  it('never sleeps a body whose sleepEnabled is false', () => {
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    body.sleepEnabled = false;
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+
+    expect(body.sleeping).toBe(false);
+  });
+
+  it('makes a woken island earn its rest from zero', () => {
+    const world = createPhysics3DWorld();
+    const body = createBox(world);
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+    expect(body.sleeping).toBe(true);
+
+    body.velocityX = 10;
+    updatePhysics3DSleep(world, 0.001);
+    expect(body.sleeping).toBe(false);
+    expect(body.sleepTimer).toBe(0);
+  });
+
+  it('leaves static bodies neither awake nor asleep', () => {
+    const world = createPhysics3DWorld();
+    const ground = createBox(world);
+    setPhysics3DBodyType(ground, 'static');
+    updatePhysics3DSleep(world, world.config.timeToSleep + 1);
+
+    expect(ground.sleeping).toBe(false);
+  });
+});
+
+function createBox(world: Physics3DWorld): RigidBody3D {
+  const body = createRigidBody3D();
+  const mass = createPhysics3DMassData();
+  computePhysics3DBoxMassData(0.5, 0.5, 0.5, 1, mass);
+  setRigidBody3DMassData(body, mass);
+  refreshRigidBody3DWorldInertia(body);
+  addPhysics3DBody(world, body);
+  return body;
+}
+
+function createContact(bodyA: number, bodyB: number): Physics3DContact {
+  return {
+    bodyA,
+    bodyB,
+    enabled: true,
+    friction: 0,
+    normalX: 0,
+    normalY: 1,
+    normalZ: 0,
+    pointCount: 1,
+    points: [
+      {
+        depth: 0.01,
+        featureId: 1,
+        rAX: 0,
+        rAY: -0.5,
+        rAZ: 0,
+        rBX: 0,
+        rBY: 0.5,
+        rBZ: 0,
+        x: 0,
+        y: 0,
+        z: 0,
+      },
+    ],
+    restitution: 0,
+    sensor: false,
+    touching: true,
+  };
+}

package/src/jointCollisionSuppression.test.ts

@@ -0,0 +1,94 @@
+import type { Physics3DWorld } from '@flighthq/types/contract';
+import { describe, expect, it } from 'vitest';
+
+import {
+  isPhysics3DPairJointSuppressed,
+  rebuildPhysics3DJointCollisionSuppressions,
+} from './jointCollisionSuppression';
+import { createPhysics3DBallAndSocketJoint } from './jointFactories';
+import { addPhysics3DJoint, registerPhysics3DJointSolver, removePhysics3DJoint } from './jointRegistry';
+import { physics3DBallAndSocketJointSolver, Physics3DBallAndSocketJointKind } from './joints';
+import { addPhysics3DBody, createPhysics3DWorld, createRigidBody3D } from './world';
+
+describe('isPhysics3DPairJointSuppressed', () => {
+  it('reports a pair held by a joint that does not collide', () => {
+    const world = createTestWorld();
+    addPhysics3DJoint(world, createPhysics3DBallAndSocketJoint({ bodyA: 0, bodyB: 1 }));
+
+    expect(isPhysics3DPairJointSuppressed(world, 0, 1)).toBe(true);
+  });
+
+  it('answers the same whichever way round the pair is given', () => {
+    const world = createTestWorld();
+    addPhysics3DJoint(world, createPhysics3DBallAndSocketJoint({ bodyA: 0, bodyB: 1 }));
+
+    expect(isPhysics3DPairJointSuppressed(world, 1, 0)).toBe(true);
+  });
+
+  it('leaves a pair alone when the joint opts into colliding', () => {
+    const world = createTestWorld();
+    addPhysics3DJoint(world, createPhysics3DBallAndSocketJoint({ bodyA: 0, bodyB: 1, collideConnected: true }));
+
+    expect(isPhysics3DPairJointSuppressed(world, 0, 1)).toBe(false);
+  });
+
+  it('leaves a pair alone while the joint kind has no solver', () => {
+    const world = createPhysics3DWorld();
+    addPhysics3DBody(world, createRigidBody3D('dynamic'));
+    addPhysics3DBody(world, createRigidBody3D('dynamic'));
+    addPhysics3DJoint(world, createPhysics3DBallAndSocketJoint({ bodyA: 0, bodyB: 1 }));
+
+    // An unregistered joint holds nothing together, so hiding the pair's contact would hide a real collision.
+    expect(isPhysics3DPairJointSuppressed(world, 0, 1)).toBe(false);
+  });
+
+  it('reports false for an unrelated pair', () => {
+    const world = createTestWorld();
+    addPhysics3DJoint(world, createPhysics3DBallAndSocketJoint({ bodyA: 0, bodyB: 1 }));
+
+    expect(isPhysics3DPairJointSuppressed(world, 0, 2)).toBe(false);
+  });
+
+  it('keeps a pair suppressed while a second joint still holds it', () => {
+    const world = createTestWorld();
+    addPhysics3DJoint(world, createPhysics3DBallAndSocketJoint({ bodyA: 0, bodyB: 1 }));
+    const second = addPhysics3DJoint(world, createPhysics3DBallAndSocketJoint({ bodyA: 0, bodyB: 1 }));
+
+    removePhysics3DJoint(world, second);
+
+    // The index counts rather than flags, so removing one of two suppressing joints cannot re-enable the pair.
+    expect(isPhysics3DPairJointSuppressed(world, 0, 1)).toBe(true);
+  });
+});
+
+describe('rebuildPhysics3DJointCollisionSuppressions', () => {
+  it('picks up an endpoint edited in place', () => {
+    const world = createTestWorld();
+    const joint = addPhysics3DJoint(world, createPhysics3DBallAndSocketJoint({ bodyA: 0, bodyB: 1 }));
+    joint.bodyB = 2;
+
+    rebuildPhysics3DJointCollisionSuppressions(world);
+
+    expect(isPhysics3DPairJointSuppressed(world, 0, 1)).toBe(false);
+    expect(isPhysics3DPairJointSuppressed(world, 0, 2)).toBe(true);
+  });
+
+  it('drops every suppression when the joint list empties', () => {
+    const world = createTestWorld();
+    const joint = addPhysics3DJoint(world, createPhysics3DBallAndSocketJoint({ bodyA: 0, bodyB: 1 }));
+    world.joints.splice(world.joints.indexOf(joint), 1);
+
+    rebuildPhysics3DJointCollisionSuppressions(world);
+
+    expect(isPhysics3DPairJointSuppressed(world, 0, 1)).toBe(false);
+  });
+});
+
+function createTestWorld(): Physics3DWorld {
+  const world = createPhysics3DWorld();
+  registerPhysics3DJointSolver(world, Physics3DBallAndSocketJointKind, physics3DBallAndSocketJointSolver);
+  addPhysics3DBody(world, createRigidBody3D('dynamic'));
+  addPhysics3DBody(world, createRigidBody3D('dynamic'));
+  addPhysics3DBody(world, createRigidBody3D('dynamic'));
+  return world;
+}

package/src/jointFactories.test.ts

@@ -0,0 +1,195 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  createPhysics3DBallAndSocketJoint,
+  createPhysics3DConeTwistJoint,
+  createPhysics3DFixedJoint,
+  createPhysics3DGeneric6DofJoint,
+  createPhysics3DHingeJoint,
+  createPhysics3DSliderJoint,
+} from './jointFactories';
+import {
+  Physics3DBallAndSocketJointKind,
+  Physics3DConeTwistJointKind,
+  Physics3DFixedJointKind,
+  Physics3DGeneric6DofJointKind,
+  Physics3DHingeJointKind,
+  Physics3DSliderJointKind,
+} from './joints';
+
+describe('createPhysics3DBallAndSocketJoint', () => {
+  it('stamps its kind and zeroes every accumulator', () => {
+    const joint = createPhysics3DBallAndSocketJoint({ bodyA: 3, bodyB: 7 });
+
+    expect(joint.kind).toBe(Physics3DBallAndSocketJointKind);
+    expect(joint.bodyA).toBe(3);
+    expect(joint.bodyB).toBe(7);
+    expect([joint.impulse0, joint.impulse1, joint.impulse2, joint.impulse3, joint.impulse4, joint.impulse5]).toEqual([
+      0, 0, 0, 0, 0, 0,
+    ]);
+  });
+
+  it('defaults both anchors to the body origin and the pair to non-colliding', () => {
+    const joint = createPhysics3DBallAndSocketJoint({ bodyA: 0, bodyB: 1 });
+
+    expect([joint.localAnchorAX, joint.localAnchorAY, joint.localAnchorAZ]).toEqual([0, 0, 0]);
+    expect(joint.collideConnected).toBe(false);
+  });
+
+  it('carries the anchors it was given', () => {
+    const joint = createPhysics3DBallAndSocketJoint({
+      bodyA: 0,
+      bodyB: 1,
+      localAnchorAX: 1,
+      localAnchorAY: 2,
+      localAnchorAZ: 3,
+      localAnchorBZ: -4,
+      collideConnected: true,
+    });
+
+    expect([joint.localAnchorAX, joint.localAnchorAY, joint.localAnchorAZ]).toEqual([1, 2, 3]);
+    expect(joint.localAnchorBZ).toBe(-4);
+    expect(joint.collideConnected).toBe(true);
+  });
+});
+
+describe('createPhysics3DConeTwistJoint', () => {
+  it('defaults to a 45 degree cone with the twist unbounded', () => {
+    const joint = createPhysics3DConeTwistJoint({ bodyA: 0, bodyB: 1 });
+
+    expect(joint.kind).toBe(Physics3DConeTwistJointKind);
+    expect(joint.enableSwingLimit).toBe(true);
+    expect(joint.swingLimitY).toBeCloseTo(Math.PI / 4, 12);
+    expect(joint.swingLimitZ).toBeCloseTo(Math.PI / 4, 12);
+    expect(joint.enableTwistLimit).toBe(false);
+  });
+
+  it('carries an elliptical cone and a twist interval', () => {
+    const joint = createPhysics3DConeTwistJoint({
+      bodyA: 0,
+      bodyB: 1,
+      swingLimitY: 0.3,
+      swingLimitZ: 1.1,
+      enableTwistLimit: true,
+      lowerTwistAngle: -0.2,
+      upperTwistAngle: 0.9,
+    });
+
+    expect(joint.swingLimitY).toBe(0.3);
+    expect(joint.swingLimitZ).toBe(1.1);
+    expect(joint.lowerTwistAngle).toBe(-0.2);
+    expect(joint.upperTwistAngle).toBe(0.9);
+  });
+});
+
+describe('createPhysics3DFixedJoint', () => {
+  it('defaults both frames to the identity', () => {
+    const joint = createPhysics3DFixedJoint({ bodyA: 0, bodyB: 1 });
+
+    expect(joint.kind).toBe(Physics3DFixedJointKind);
+    expect([joint.localRotationAX, joint.localRotationAY, joint.localRotationAZ, joint.localRotationAW]).toEqual([
+      0, 0, 0, 1,
+    ]);
+    expect([joint.localRotationBX, joint.localRotationBY, joint.localRotationBZ, joint.localRotationBW]).toEqual([
+      0, 0, 0, 1,
+    ]);
+  });
+
+  it('carries the frames it was given', () => {
+    const half = Math.SQRT1_2;
+    const joint = createPhysics3DFixedJoint({ bodyA: 0, bodyB: 1, localRotationAZ: half, localRotationAW: half });
+
+    expect(joint.localRotationAZ).toBeCloseTo(half, 12);
+    expect(joint.localRotationAW).toBeCloseTo(half, 12);
+  });
+});
+
+describe('createPhysics3DGeneric6DofJoint', () => {
+  it('defaults every axis to free', () => {
+    const joint = createPhysics3DGeneric6DofJoint({ bodyA: 0, bodyB: 1 });
+
+    expect(joint.kind).toBe(Physics3DGeneric6DofJointKind);
+    // `lower > upper` is the encoding for free, so a joint built with no bounds constrains nothing. Defaulting
+    // to locked would make a partially configured joint silently rigid, which is the harder failure to see.
+    expect(joint.lowerLinearX).toBeGreaterThan(joint.upperLinearX);
+    expect(joint.lowerLinearY).toBeGreaterThan(joint.upperLinearY);
+    expect(joint.lowerLinearZ).toBeGreaterThan(joint.upperLinearZ);
+    expect(joint.lowerAngularX).toBeGreaterThan(joint.upperAngularX);
+    expect(joint.lowerAngularY).toBeGreaterThan(joint.upperAngularY);
+    expect(joint.lowerAngularZ).toBeGreaterThan(joint.upperAngularZ);
+  });
+
+  it('carries the bounds it was given', () => {
+    const joint = createPhysics3DGeneric6DofJoint({
+      bodyA: 0,
+      bodyB: 1,
+      lowerLinearY: -2,
+      upperLinearY: 5,
+      lowerAngularZ: 0,
+      upperAngularZ: 0,
+    });
+
+    expect(joint.lowerLinearY).toBe(-2);
+    expect(joint.upperLinearY).toBe(5);
+    expect(joint.lowerAngularZ).toBe(0);
+    expect(joint.upperAngularZ).toBe(0);
+  });
+});
+
+describe('createPhysics3DHingeJoint', () => {
+  it('defaults to a free hinge with no motor', () => {
+    const joint = createPhysics3DHingeJoint({ bodyA: 0, bodyB: 1 });
+
+    expect(joint.kind).toBe(Physics3DHingeJointKind);
+    expect(joint.enableLimit).toBe(false);
+    expect(joint.enableMotor).toBe(false);
+    expect(joint.motorImpulse).toBe(0);
+  });
+
+  it('carries its limits and motor settings', () => {
+    const joint = createPhysics3DHingeJoint({
+      bodyA: 0,
+      bodyB: 1,
+      enableLimit: true,
+      lowerAngle: -1,
+      upperAngle: 2,
+      enableMotor: true,
+      motorSpeed: 3,
+      maxMotorTorque: 40,
+    });
+
+    expect(joint.lowerAngle).toBe(-1);
+    expect(joint.upperAngle).toBe(2);
+    expect(joint.motorSpeed).toBe(3);
+    expect(joint.maxMotorTorque).toBe(40);
+  });
+});
+
+describe('createPhysics3DSliderJoint', () => {
+  it('defaults to free travel with no motor', () => {
+    const joint = createPhysics3DSliderJoint({ bodyA: 0, bodyB: 1 });
+
+    expect(joint.kind).toBe(Physics3DSliderJointKind);
+    expect(joint.enableLimit).toBe(false);
+    expect(joint.enableMotor).toBe(false);
+    expect(joint.motorImpulse).toBe(0);
+  });
+
+  it('carries its travel interval and motor settings', () => {
+    const joint = createPhysics3DSliderJoint({
+      bodyA: 0,
+      bodyB: 1,
+      enableLimit: true,
+      lowerTranslation: -3,
+      upperTranslation: 3,
+      enableMotor: true,
+      motorSpeed: 2,
+      maxMotorForce: 15,
+    });
+
+    expect(joint.lowerTranslation).toBe(-3);
+    expect(joint.upperTranslation).toBe(3);
+    expect(joint.motorSpeed).toBe(2);
+    expect(joint.maxMotorForce).toBe(15);
+  });
+});