@woosh/meep-engine 3.0.0 → 3.0.1

package/editor/tools/v2/TransformControls.js

@@ -86,7 +86,7 @@ const _tempTransform = new Transform();
  *
  * The three version answered the first two questions by building meshes and raycasting them: an
  * invisible cone per arm, an invisible 100000-unit `PlaneGeometry` per drag. That is why it needed
- * `Camera.object`, which is three's camera and is `null` under Shade. It needs no camera object now:
+ * a three camera object on the component. It needs none now:
  * the ray through the middle of the viewport starts at the eye and points where the camera looks,
  * and the ray through the top edge gives the field of view the gizmo is sized against.
  *

package/package.json

@@ -1,96 +1,95 @@
-{
-  "name": "@woosh/meep-engine",
-  "license": "SEE LICENSE IN LICENSE",
-  "productName": "Meep",
-  "homepage": "https://meep.company-named.com/",
-  "description": "Pure JavaScript game engine. Fully featured and production ready.",
-  "type": "module",
-  "author": "Alexander Goldring",
-  "version": "3.0.0",
-  "exports": {
-    "./build/*": "./build/*",
-    "./src/*": "./src/*",
-    "./editor/*": "./editor/*",
-    "./*.md": "./*.md"
-  },
-  "sideEffects": [
-    "**/*.css",
-    "**/*.scss"
-  ],
-  "scripts": {
-    "test:ci": "vitest run --coverage --reporter=default --reporter=junit --outputFile=junit.xml",
-    "build-module": "rollup -c rollup.config.js",
-    "publish-npm": "npm publish",
-    "generate-types": "npx -p typescript tsc --project tsconfig.types.json || exit 0;",
-    "test": "vitest run"
-  },
-  "browserslist": [
-    "last 2 chrome version",
-    "last 2 firefox version",
-    "last 2 safari version"
-  ],
-  "files": [
-    "build",
-    "src",
-    "editor",
-    "samples",
-    "package.json",
-    "README.md",
-    "!src/**/*.spec.js",
-    "!editor/**/*.spec.js"
-  ],
-  "dependencies": {
-    "gl-matrix": "3.4.3",
-    "opentype.js": "1.3.3",
-    "pako": "2.0.3",
-    "robust-predicates": "3.0.2"
-  },
-  "peerDependencies": {
-    "dat.gui": ">=0.7.0",
-    "three": ">=0.135.0"
-  },
-  "peerDependenciesMeta": {
-    "three": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@rollup/plugin-commonjs": "25.0.2",
-    "@rollup/plugin-node-resolve": "15.1.0",
-    "@rollup/plugin-strip": "3.0.2",
-    "@rollup/plugin-terser": "0.4.3",
-    "@types/three": "^0.135.0",
-    "@vitest/coverage-v8": "^4.1.10",
-    "jsdom": "^30.0.1",
-    "rollup": "3.26.2",
-    "typescript": "5.2.2",
-    "vitest": "^4.1.10",
-    "web-tree-sitter": "^0.26.12"
-  },
-  "keywords": [
-    "game-engine",
-    "gamedev",
-    "ecs",
-    "entity-component-system",
-    "data-oriented",
-    "zero-allocation",
-    "modular",
-    "tree-shaking",
-    "3d",
-    "webgl",
-    "webgl2",
-    "webgpu",
-    "webaudio",
-    "particles",
-    "bvh",
-    "behavior-tree",
-    "inverse-kinematics",
-    "fabrik",
-    "clustered-lighting",
-    "color-management",
-    "typescript"
-  ],
-  "engines": {
-    "node": ">=24"
-  }
-}
+{
+  "name": "@woosh/meep-engine",
+  "license": "SEE LICENSE IN LICENSE",
+  "productName": "Meep",
+  "homepage": "https://meep.company-named.com/",
+  "description": "Pure JavaScript game engine. Fully featured and production ready.",
+  "type": "module",
+  "author": "Alexander Goldring",
+  "version": "3.0.1",
+  "exports": {
+    "./build/*": "./build/*",
+    "./src/*": "./src/*",
+    "./editor/*": "./editor/*",
+    "./*.md": "./*.md"
+  },
+  "sideEffects": [
+    "**/*.css",
+    "**/*.scss"
+  ],
+  "scripts": {
+    "test:ci": "vitest run --coverage --reporter=default --reporter=junit --outputFile=junit.xml",
+    "build-module": "rollup -c rollup.config.js",
+    "publish-npm": "npm publish",
+    "generate-types": "npx -p typescript tsc --project tsconfig.types.json || exit 0;",
+    "test": "vitest run"
+  },
+  "browserslist": [
+    "last 2 chrome version",
+    "last 2 firefox version",
+    "last 2 safari version"
+  ],
+  "files": [
+    "build",
+    "src",
+    "editor",
+    "samples",
+    "package.json",
+    "README.md",
+    "!src/**/*.spec.js",
+    "!editor/**/*.spec.js"
+  ],
+  "dependencies": {
+    "opentype.js": "1.3.3",
+    "pako": "2.0.3",
+    "robust-predicates": "3.0.2"
+  },
+  "peerDependencies": {
+    "dat.gui": ">=0.7.0",
+    "three": ">=0.135.0"
+  },
+  "peerDependenciesMeta": {
+    "three": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "25.0.2",
+    "@rollup/plugin-node-resolve": "15.1.0",
+    "@rollup/plugin-strip": "3.0.2",
+    "@rollup/plugin-terser": "0.4.3",
+    "@types/three": "^0.135.0",
+    "@vitest/coverage-v8": "^4.1.10",
+    "jsdom": "^30.0.1",
+    "rollup": "3.26.2",
+    "typescript": "5.2.2",
+    "vitest": "^4.1.10",
+    "web-tree-sitter": "^0.26.12"
+  },
+  "keywords": [
+    "game-engine",
+    "gamedev",
+    "ecs",
+    "entity-component-system",
+    "data-oriented",
+    "zero-allocation",
+    "modular",
+    "tree-shaking",
+    "3d",
+    "webgl",
+    "webgl2",
+    "webgpu",
+    "webaudio",
+    "particles",
+    "bvh",
+    "behavior-tree",
+    "inverse-kinematics",
+    "fabrik",
+    "clustered-lighting",
+    "color-management",
+    "typescript"
+  ],
+  "engines": {
+    "node": ">=24"
+  }
+}

package/src/core/geom/3d/mat4/m4_look_at.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Build a view matrix that places the eye at `eye` and points it at `center`, with `up` naming
+ * which way is up.
+ *
+ * Right-handed, matching the camera basis the rest of the renderer uses: the eye looks down its own
+ * −Z, so `center` sits at a negative view-space z. The result is the inverse of the camera's world
+ * transform — it carries world space into view space, not the other way around.
+ *
+ * `up` only has to be non-parallel to the view direction; it is re-orthogonalized against it. When
+ * it *is* parallel the cross product collapses and the basis is degenerate — that is a caller error,
+ * and the assert below is what says so.
+ *
+ * Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
+ * @param {ArrayLike<number>} eye position of the viewer, `[x, y, z]`
+ * @param {ArrayLike<number>} center point the viewer is looking at, `[x, y, z]`
+ * @param {ArrayLike<number>} up up direction, `[x, y, z]`, not parallel to `center - eye`
+ * @returns {number[]|Float32Array|Float64Array} `out`, for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_look_at(out: number[] | Float32Array | Float64Array, eye: ArrayLike<number>, center: ArrayLike<number>, up: ArrayLike<number>): number[] | Float32Array | Float64Array;
+//# sourceMappingURL=m4_look_at.d.ts.map

package/src/core/geom/3d/mat4/m4_look_at.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_look_at.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_look_at.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,gCATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,OAClC,UAAU,MAAM,CAAC,UACjB,UAAU,MAAM,CAAC,MACjB,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CA2E9C"}

package/src/core/geom/3d/mat4/m4_look_at.js

@@ -0,0 +1,96 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Build a view matrix that places the eye at `eye` and points it at `center`, with `up` naming
+ * which way is up.
+ *
+ * Right-handed, matching the camera basis the rest of the renderer uses: the eye looks down its own
+ * −Z, so `center` sits at a negative view-space z. The result is the inverse of the camera's world
+ * transform — it carries world space into view space, not the other way around.
+ *
+ * `up` only has to be non-parallel to the view direction; it is re-orthogonalized against it. When
+ * it *is* parallel the cross product collapses and the basis is degenerate — that is a caller error,
+ * and the assert below is what says so.
+ *
+ * Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
+ * @param {ArrayLike<number>} eye position of the viewer, `[x, y, z]`
+ * @param {ArrayLike<number>} center point the viewer is looking at, `[x, y, z]`
+ * @param {ArrayLike<number>} up up direction, `[x, y, z]`, not parallel to `center - eye`
+ * @returns {number[]|Float32Array|Float64Array} `out`, for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_look_at(out, eye, center, up) {
+    assert.isArrayLike(eye, 'eye');
+    assert.isArrayLike(center, 'center');
+    assert.isArrayLike(up, 'up');
+
+    const eye_x = eye[0];
+    const eye_y = eye[1];
+    const eye_z = eye[2];
+
+    // backward = normalize(eye - center); the view direction is its negation
+    let z0 = eye_x - center[0];
+    let z1 = eye_y - center[1];
+    let z2 = eye_z - center[2];
+
+    const z_length = Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+
+    assert.greaterThan(z_length, 0, 'distance between eye and center');
+
+    const z_scale = 1 / z_length;
+
+    z0 *= z_scale;
+    z1 *= z_scale;
+    z2 *= z_scale;
+
+    const up_x = up[0];
+    const up_y = up[1];
+    const up_z = up[2];
+
+    // right = normalize(cross(up, backward))
+    let x0 = up_y * z2 - up_z * z1;
+    let x1 = up_z * z0 - up_x * z2;
+    let x2 = up_x * z1 - up_y * z0;
+
+    const x_length = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+
+    assert.greaterThan(x_length, 0, 'length of cross(up, eye - center), up must not be parallel to the view direction');
+
+    const x_scale = 1 / x_length;
+
+    x0 *= x_scale;
+    x1 *= x_scale;
+    x2 *= x_scale;
+
+    // up = cross(backward, right); both operands are unit and orthogonal, so this one already is
+    const y0 = z1 * x2 - z2 * x1;
+    const y1 = z2 * x0 - z0 * x2;
+    const y2 = z0 * x1 - z1 * x0;
+
+    // rotation is the transpose of the basis, translation is the eye in that rotated frame
+    out[0] = x0;
+    out[1] = y0;
+    out[2] = z0;
+    out[3] = 0;
+
+    out[4] = x1;
+    out[5] = y1;
+    out[6] = z1;
+    out[7] = 0;
+
+    out[8] = x2;
+    out[9] = y2;
+    out[10] = z2;
+    out[11] = 0;
+
+    out[12] = -(x0 * eye_x + x1 * eye_y + x2 * eye_z);
+    out[13] = -(y0 * eye_x + y1 * eye_y + y2 * eye_z);
+    out[14] = -(z0 * eye_x + z1 * eye_y + z2 * eye_z);
+    out[15] = 1;
+
+    return out;
+}

package/src/core/geom/3d/mat4/m4_make_rotation_x.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Create a 4x4 matrix that corresponds to a rotation around the X axis.
+ *
+ * Right-handed: a positive angle carries +Y towards +Z. The rotation-around-Y and
+ * rotation-around-Z companions are {@link m4_make_rotation_y} and {@link m4_make_rotation_z}; to
+ * compose several, build each one and chain them with {@link m4_multiply}.
+ *
+ * Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} output 4x4 matrix output will be written here
+ * @param {number} angle rotation, in radians
+ * @returns {number[]|Float32Array|Float64Array} `output` parameter, returned for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_make_rotation_x(output: number[] | Float32Array | Float64Array, angle: number): number[] | Float32Array | Float64Array;
+//# sourceMappingURL=m4_make_rotation_x.d.ts.map

package/src/core/geom/3d/mat4/m4_make_rotation_x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_make_rotation_x.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_make_rotation_x.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,2CAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,GACJ,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CAiC9C"}

package/src/core/geom/3d/mat4/m4_make_rotation_x.js

@@ -0,0 +1,47 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Create a 4x4 matrix that corresponds to a rotation around the X axis.
+ *
+ * Right-handed: a positive angle carries +Y towards +Z. The rotation-around-Y and
+ * rotation-around-Z companions are {@link m4_make_rotation_y} and {@link m4_make_rotation_z}; to
+ * compose several, build each one and chain them with {@link m4_multiply}.
+ *
+ * Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} output 4x4 matrix output will be written here
+ * @param {number} angle rotation, in radians
+ * @returns {number[]|Float32Array|Float64Array} `output` parameter, returned for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_make_rotation_x(output, angle) {
+    assert.isNumber(angle, 'angle');
+    assert.notNaN(angle, 'angle');
+
+    const s = Math.sin(angle);
+    const c = Math.cos(angle);
+
+    output[0] = 1;
+    output[1] = 0;
+    output[2] = 0;
+    output[3] = 0;
+
+    output[4] = 0;
+    output[5] = c;
+    output[6] = s;
+    output[7] = 0;
+
+    output[8] = 0;
+    output[9] = -s;
+    output[10] = c;
+    output[11] = 0;
+
+    output[12] = 0;
+    output[13] = 0;
+    output[14] = 0;
+    output[15] = 1;
+
+    return output;
+}

package/src/core/geom/3d/mat4/m4_make_rotation_y.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Create a 4x4 matrix that corresponds to a rotation around the Y axis.
+ *
+ * Right-handed: a positive angle carries +Z towards +X. The rotation-around-X and
+ * rotation-around-Z companions are {@link m4_make_rotation_x} and {@link m4_make_rotation_z}; to
+ * compose several, build each one and chain them with {@link m4_multiply}.
+ *
+ * Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} output 4x4 matrix output will be written here
+ * @param {number} angle rotation, in radians
+ * @returns {number[]|Float32Array|Float64Array} `output` parameter, returned for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_make_rotation_y(output: number[] | Float32Array | Float64Array, angle: number): number[] | Float32Array | Float64Array;
+//# sourceMappingURL=m4_make_rotation_y.d.ts.map

package/src/core/geom/3d/mat4/m4_make_rotation_y.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_make_rotation_y.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_make_rotation_y.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,2CAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,GACJ,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CAiC9C"}

package/src/core/geom/3d/mat4/m4_make_rotation_y.js

@@ -0,0 +1,47 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Create a 4x4 matrix that corresponds to a rotation around the Y axis.
+ *
+ * Right-handed: a positive angle carries +Z towards +X. The rotation-around-X and
+ * rotation-around-Z companions are {@link m4_make_rotation_x} and {@link m4_make_rotation_z}; to
+ * compose several, build each one and chain them with {@link m4_multiply}.
+ *
+ * Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} output 4x4 matrix output will be written here
+ * @param {number} angle rotation, in radians
+ * @returns {number[]|Float32Array|Float64Array} `output` parameter, returned for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_make_rotation_y(output, angle) {
+    assert.isNumber(angle, 'angle');
+    assert.notNaN(angle, 'angle');
+
+    const s = Math.sin(angle);
+    const c = Math.cos(angle);
+
+    output[0] = c;
+    output[1] = 0;
+    output[2] = -s;
+    output[3] = 0;
+
+    output[4] = 0;
+    output[5] = 1;
+    output[6] = 0;
+    output[7] = 0;
+
+    output[8] = s;
+    output[9] = 0;
+    output[10] = c;
+    output[11] = 0;
+
+    output[12] = 0;
+    output[13] = 0;
+    output[14] = 0;
+    output[15] = 1;
+
+    return output;
+}

package/src/core/geom/3d/mat4/m4_make_rotation_z.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Create a 4x4 matrix that corresponds to a rotation around the Z axis.
+ *
+ * Right-handed: a positive angle carries +X towards +Y. The rotation-around-X and
+ * rotation-around-Y companions are {@link m4_make_rotation_x} and {@link m4_make_rotation_y}; to
+ * compose several, build each one and chain them with {@link m4_multiply}.
+ *
+ * Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} output 4x4 matrix output will be written here
+ * @param {number} angle rotation, in radians
+ * @returns {number[]|Float32Array|Float64Array} `output` parameter, returned for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_make_rotation_z(output: number[] | Float32Array | Float64Array, angle: number): number[] | Float32Array | Float64Array;
+//# sourceMappingURL=m4_make_rotation_z.d.ts.map

package/src/core/geom/3d/mat4/m4_make_rotation_z.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_make_rotation_z.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_make_rotation_z.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,2CAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,GACJ,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CAiC9C"}

package/src/core/geom/3d/mat4/m4_make_rotation_z.js

@@ -0,0 +1,47 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Create a 4x4 matrix that corresponds to a rotation around the Z axis.
+ *
+ * Right-handed: a positive angle carries +X towards +Y. The rotation-around-X and
+ * rotation-around-Y companions are {@link m4_make_rotation_x} and {@link m4_make_rotation_y}; to
+ * compose several, build each one and chain them with {@link m4_multiply}.
+ *
+ * Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} output 4x4 matrix output will be written here
+ * @param {number} angle rotation, in radians
+ * @returns {number[]|Float32Array|Float64Array} `output` parameter, returned for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_make_rotation_z(output, angle) {
+    assert.isNumber(angle, 'angle');
+    assert.notNaN(angle, 'angle');
+
+    const s = Math.sin(angle);
+    const c = Math.cos(angle);
+
+    output[0] = c;
+    output[1] = s;
+    output[2] = 0;
+    output[3] = 0;
+
+    output[4] = -s;
+    output[5] = c;
+    output[6] = 0;
+    output[7] = 0;
+
+    output[8] = 0;
+    output[9] = 0;
+    output[10] = 1;
+    output[11] = 0;
+
+    output[12] = 0;
+    output[13] = 0;
+    output[14] = 0;
+    output[15] = 1;
+
+    return output;
+}

package/src/core/geom/3d/mat4/m4_perspective.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Build a conventional perspective projection matrix: right-handed, with clip depth spanning the
+ * full −1…1 that OpenGL and three.js use.
+ *
+ * This is *not* the projection the renderer draws with — Shade's cameras use an infinite reverse-Z
+ * with a 0…1 depth range, which is what WebGPU wants. This one exists for the arithmetic that has to
+ * hold under either shape, and for reading geometry produced against the OpenGL convention.
+ *
+ * `far` is finite here on purpose: an infinite far plane is a different matrix, not a special value
+ * of this one.
+ *
+ * Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
+ * @param {number} fov_y vertical field of view, in radians
+ * @param {number} aspect viewport width divided by its height
+ * @param {number} near distance to the near clipping plane, greater than 0
+ * @param {number} far distance to the far clipping plane, greater than `near`
+ * @returns {number[]|Float32Array|Float64Array} `out`, for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_perspective(out: number[] | Float32Array | Float64Array, fov_y: number, aspect: number, near: number, far: number): number[] | Float32Array | Float64Array;
+//# sourceMappingURL=m4_perspective.d.ts.map

package/src/core/geom/3d/mat4/m4_perspective.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_perspective.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_perspective.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,oCAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,UACN,MAAM,QACN,MAAM,OACN,MAAM,GACJ,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CA6C9C"}

package/src/core/geom/3d/mat4/m4_perspective.js

@@ -0,0 +1,66 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Build a conventional perspective projection matrix: right-handed, with clip depth spanning the
+ * full −1…1 that OpenGL and three.js use.
+ *
+ * This is *not* the projection the renderer draws with — Shade's cameras use an infinite reverse-Z
+ * with a 0…1 depth range, which is what WebGPU wants. This one exists for the arithmetic that has to
+ * hold under either shape, and for reading geometry produced against the OpenGL convention.
+ *
+ * `far` is finite here on purpose: an infinite far plane is a different matrix, not a special value
+ * of this one.
+ *
+ * Allocation-free.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination 4x4 matrix
+ * @param {number} fov_y vertical field of view, in radians
+ * @param {number} aspect viewport width divided by its height
+ * @param {number} near distance to the near clipping plane, greater than 0
+ * @param {number} far distance to the far clipping plane, greater than `near`
+ * @returns {number[]|Float32Array|Float64Array} `out`, for convenience
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_perspective(out, fov_y, aspect, near, far) {
+    assert.isNumber(fov_y, 'fov_y');
+    assert.greaterThan(fov_y, 0, 'fov_y');
+    assert.lessThan(fov_y, Math.PI, 'fov_y');
+
+    assert.isNumber(aspect, 'aspect');
+    assert.greaterThan(aspect, 0, 'aspect');
+
+    assert.isNumber(near, 'near');
+    assert.greaterThan(near, 0, 'near');
+
+    assert.isFinite(far, 'far');
+    assert.greaterThan(far, near, 'far');
+
+    const f = 1 / Math.tan(fov_y * 0.5);
+
+    // 1 / (near - far), negative, and the shared factor of both depth terms
+    const nf = 1 / (near - far);
+
+    out[0] = f / aspect;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+
+    out[4] = 0;
+    out[5] = f;
+    out[6] = 0;
+    out[7] = 0;
+
+    out[8] = 0;
+    out[9] = 0;
+    out[10] = (far + near) * nf;
+    out[11] = -1;
+
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 2 * far * near * nf;
+    out[15] = 0;
+
+    return out;
+}

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonPlayerControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerSystem.js"],"names":[],"mappings":"AAsXA;;;;;;;;;;;;;;;;;GAiBG;AACH;;IAOI,wEAAwD;IAExD,gKAIE;IAEF;;;OAGG;IACH,SAFU,IAAI,MAAM,EAAE,gBAAgB,CAAC,CAEnB;IAEpB;;;;OAIG;IACH,sBAFU,OAAO,CAEW;IAE5B;;;;OAIG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;;;;;;;;;;;;OAgBG;IACH,oBAFc,MAAM,KAAI,MAAM,KAAI,MAAM,KAAK,MAAM,GAAC,IAAI,CAElC;IAEtB;;;;;;;OAOG;IACH,eAFU,aAAa,GAAC,IAAI,CAEP;IAErB;;;;;;;;OAQG;IACH,eAAc;IAEd,+DAA+D;IAC/D,uBAA+B;IAE/B,yDAAyD;IACzD,oBAAyB;IAEzB,2CAA2C;IAC3C,oBAAwC;IAExC,2CAMC;IAED;;;;OAIG;IACH,iBAJW,2BAA2B,iBAC3B,SAAS,UACT,MAAM,QAqIhB;IAED;;;;OAIG;IACH,mBAJW,2BAA2B,iBAC3B,SAAS,UACT,MAAM,QAWhB;IAED;;;;;;;;OAQG;IACH,mBAHW,MAAM,GACJ,gBAAgB,GAAC,SAAS,CAItC;IAUG,mBAAoB;IAYpB,yBAA0B;IAI9B;;;;OAIG;IACH,oBAsUC;IAED;;;;;OAKG;IACH;;;;;;;;;;;;;;OAcG;IACH,2BAaC;IAED,2EA0CC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,2BASC;IAED;;;;;;;;;;;OAWG;IACH,wBA+EC;IAED;;;;;;;;;;;;;OAaG;IACH,2CAIC;IAED;;;;;;;;;;;OAWG;IACH,uBAMC;IAED;;;;;OAKG;IACH,sBAWC;IAED;;;;;OAKG;IACH,sBAgDC;IAED;;;;;;;;OAQG;IACH,wBA4CC;IAED;;;;;;OAMG;IACH,gBAsBC;IAED;;;;OAIG;IACH,uBAIC;IAED;;;OAGG;IACH,wBASC;IAED;;;;;;;;;;;;;;OAcG;IACH,2BA4IC;IAED;;;;;;;;;;;;;;;OAeG;IACH,kCAsDC;IAED;;;;;;;;;;OAUG;IACH,qBAiDC;IAED;;;;;;;;OAQG;IACH,4BAUC;IAED;;;;;;;;;OASG;IACH,8BAkBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBA0BC;IAED;;;;;OAKG;IACH,oBAsLC;CACJ;uBAh9DsB,qBAAqB;0BAClB,kCAAkC;4CAShB,kCAAkC;4CAblC,oDAAoD;0BAStE,gCAAgC;uBAJnC,qCAAqC;AA8E5D;;;;;GAKG;AACH;IACI;;;;;;;OAOG;IACH,WAFU,SAAS,GAAC,IAAI,CAEP;IAEjB;;;;;OAKG;IACH,UAFU,QAAQ,GAAC,IAAI,CAEP;IAEhB;;;;;;;;;;;OAWG;IACH,2BAA0B;IAE1B,+CAA+C;IAC/C,4BAA2B;IAE3B,+CAA+C;IAC/C,2BAA0B;IAE1B,eAAe;IACf,oBAAiB;IAEjB,2DAA2D;IAC3D,iBAAa;IAEb,6CAA6C;IAC7C,gBAAY;IAEZ,sEAAsE;IACtE,yBAAqB;IAWrB;;wBAEoB;IACpB,qBAAiB;IAEjB,uBAA8B;IAC9B,sBAA6B;IAE7B;;gDAE4C;IAC5C,oBAAmB;IAEnB;sDACkD;IAClD,kBAAc;IAEd,kBAAc;IACd,kBAAc;IAEd,qEAAqE;IACrE,sBAAqB;IAErB,oEAAoE;IACpE,wBAAuB;IAEvB,yEAAyE;IACzE,uBAAsB;IAEtB,wEAAwE;IACxE,8BAA0B;IAE1B,mEAAmE;IACnE,gBAAe;IAEf;;;;;OAKG;IACH,kBAAc;IAEd,mEAAmE;IACnE,sBAAoB;IAEpB;;;;OAIG;IACH,gBAAkB;IAElB,kEAAkE;IAClE,mBAA0B;IAE1B,0CAA0C;IAC1C,kBAA2B;IAE3B,iDAAiD;IACjD,wBAAmC;IAEnC,wEAAwE;IACxE,mBAA0B;IAE1B;;;;;;;OAOG;IACH,sBAAkB;IAElB,sEAAsE;IACtE,sBAAkB;IAElB,sBAAkB;IAElB,iDAAiD;IACjD,sBAAoB;IAEpB,uDAAuD;IACvD,kBAAc;IAEd,0EAA0E;IAC1E,qBAAiB;IAEjB,+DAA+D;IAC/D,iBAAgB;IAEhB,oDAAoD;IACpD,mBAAkB;IAElB,2EAA2E;IAC3E,wBAAoB;IAEpB,gFAAgF;IAChF,wBAAoB;IAEpB,+DAA+D;IAC/D,qBAAmB;IAEnB;;;;;;;;;;OAUG;IACH,qBAAmB;IAEnB;;;;;;OAMG;IACH,qBAAiB;IAEjB;;;;OAIG;IACH,2BAAkC;IAElC;;;;OAIG;IACH,6BAAoC;IAEpC;;;;;OAKG;IACH,4BAAmC;IAEnC;;;;OAIG;IACH,wBAA+B;IAE/B;;;;OAIG;IACH,mBAAe;IAEf;;;;;OAKG;IACH,eAAW;IAEX,eAAW;IAEX,8EAA8E;IAC9E,mBAAe;IAEf,4FAA4F;IAC5F,qBAAiB;IAEjB;;;;;OAKG;IACH,+BAAsC;IAEtC;;;;;OAKG;IACH,4BAAmC;IAEnC,sDAAsD;IACtD,kBAAe;IAEf;;;;;OAKG;IACH,4BAA2B;IAE3B;;;;;;OAMG;IACH,4BAAwB;CAC3B;8BAlW6B,oCAAoC;yBADzC,+BAA+B;oBAZpC,+BAA+B;uBAwB5B,kBAAkB;+BAPV,8BAA8B;mCAW1B,iCAAiC"}
+{"version":3,"file":"FirstPersonPlayerControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerSystem.js"],"names":[],"mappings":"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"}