Math

Keeps value between min and max: below min it gives min, above max it gives max, and in between the value itself. It is what keeps a player inside the screen or a volume between 0 and 1, and it replaces Math.min(max, Math.max(min, value)), which is easy to write with the two the wrong way round.

Converts deg (degrees) to radians: the unit every rotation in the engine uses (sprite transform.rotation, a camera's rotation, a 3D object's rotationX and rotationY). Lets you author angles the way you think about them: transform.rotation = degToRad(45).

Linear interpolation between numbers a and b: t = 0 returns a, t = 1 returns b. Not clamped. The scalar building block under fades, manual tweens, and lerpColor / vec2Lerp. GLSL calls this mix.

Interpolates from angle a toward b (both radians) along the shortest arc, so going from 350° to 10° turns 20° forward instead of 340° back. Ideal for smoothly steering a sprite toward a target heading. t=0 returns a, t=1 returns an angle equivalent to b. Not clamped.

Builds a quaternion that rotates by angle radians about the axis (ax, ay, az). The natural way to author "spin this much around this direction": a barrel roll is a rotation about the ship's forward axis, a turn is one about its up axis.

Builds a quaternion from yaw/pitch/roll Euler angles (radians), using the exact same axis order the renderer applies to Euler transforms: yaw (Y), then pitch (X), then roll (Z). That equivalence is the point: a mesh authored with rotation/rotationX/rotationY can be switched to a quaternion built here and face the identical direction, so you only pay the Euler→quat conversion once, up front, and evolve the quaternion from then on.

Composes two rotations: the result applies b first, then a (same convention as matrix multiplication). This is how you accumulate orientation incrementally: orientation = multiply(deltaSpin, orientation) each frame rolls a ship a little further without ever touching Euler angles or risking gimbal lock.

Re-normalizes a quaternion back onto the unit sphere. Repeated multiplications accumulate floating-point error that slowly scales the rotation; call this periodically on a long-lived accumulated orientation to keep it a pure rotation.

Rotates a vector by a quaternion: q · v · q⁻¹, in its expanded (branch-free) form.

The scene graph's composition is expressed in position/rotation/scale rather than in matrices (see composeWorldTransforms), and this is the one operation that needs: a child's local offset, turned by its parent's orientation, is where the child actually sits.

Converts rad (radians) to degrees: handy for showing an engine angle in a debug overlay or editor field, where degrees read more naturally than radians.

A full turn in radians (2π): the period of the trig functions. Useful for expressing whole rotations and for wrapping angles back into range.

The random numbers of this game.

Use it instead of Math.random() whenever a result should be repeatable: give createGame a seed and every run of the game draws exactly the same numbers in the same order, which is what makes a level layout, a replay or a bug report reproducible. Without a seed each run is different.

seed(n) starts the sequence again from n at any moment.

a + b, component by component: a position moved by an offset.

The angle a direction points at, in radians: 0 is right and it turns towards +y, which is down on screen. It is what a sprite's transform.rotation wants, so ship.transform.rotation = vec2Angle(velocity) turns a ship to face where it is going.

How far apart two points are. With transforms, vec2Distance(player.transform, coin.transform) < 12 is a pickup check.

Returns the dot product. Result is 0 if vectors are perpendicular, positive if same direction, negative if opposite.

Whether every component is exactly equal. Exact, so two results of arithmetic that should agree can differ in the last decimal: compare a distance with a small number for those.

How long the vector is: the speed of a velocity, the reach of an offset.

Linearly interpolates between a and b. t=0 returns a, t=1 returns b. Not clamped.

The same vector pointing the opposite way.

Returns a unit vector in the same direction. Returns (0, 0) if the input is a zero vector.

Every component multiplied by s: the same direction, s times as long.

a - b, component by component. sub(target, from) is the arrow from from to target.

a + b, component by component: a position moved by an offset.

Returns a vector perpendicular to both a and b. The result magnitude equals the area of the parallelogram they form.

How far apart two points are. With transforms, vec3Distance(player.transform, coin.transform) < 12 is a pickup check.

Returns the dot product. Result is 0 if vectors are perpendicular, positive if same direction, negative if opposite.

Whether every component is exactly equal. Exact, so two results of arithmetic that should agree can differ in the last decimal: compare a distance with a small number for those.

How long the vector is: the speed of a velocity, the reach of an offset.

Linearly interpolates between a and b. t=0 returns a, t=1 returns b. Not clamped.

The same vector pointing the opposite way.

Returns a unit vector in the same direction. Returns (0, 0, 0) if the input is a zero vector.

Every component multiplied by s: the same direction, s times as long.

a - b, component by component. sub(target, from) is the arrow from from to target.

Wraps rad into the range [-π, π). Rotations accumulated frame by frame (transform.rotation += spin * dt) drift far outside that range over time; wrapping keeps angle comparisons and interpolation well-behaved: call it before lerpAngle, or whenever you need a canonical heading.

A unit quaternion [x, y, z, w]: the engine's storage form for a full 3D orientation. Chosen over Euler angles for anything that rotates freely in 3D (a flying ship, a physics body): it never gimbal-locks, composes with a single multiply, and interpolates smoothly with slerp. It is a plain number tuple on purpose: four JSON-serializable numbers, so a TransformRecord.quaternion round- trips through the editor/save with no special casing (a Float32Array would stringify as {"0":...}, not an array). The matrix is only ever the derived render form (toMat4); the quaternion is the state you keep and evolve.

A per-game random handle, returned by useRandom. Every method draws from this game's own seeded generator: two games on the same page never share a stream, and seed only affects the game it belongs to. Seeding makes a sequence reproducible (same seed → same numbers), which is what the editor/metadata model needs to rebuild a procedural scene from a single saved seed.

A point or a direction in 2D: x, y.

Every vec2* function takes anything with those fields, so a transform works as it is: vec2Distance(player.transform, coin.transform) needs no vector built first. They never change what they are given: a vector that comes back is always a new object.

A point or a direction in 3D: x, y, z.

Every vec3* function takes anything with those fields, so a 3D transform works as it is: vec3Distance(player.transform, coin.transform) needs no vector built first. They never change what they are given: a vector that comes back is always a new object.