@woosh/meep-engine 3.0.0 → 3.0.1

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js

@@ -1,281 +1,296 @@
-import { Matrix4 } from "three";
-import { assert } from "../../../../../core/assert.js";
-import { m4_euler_angles } from "../../../../../core/geom/3d/mat4/m4_euler_angles.js";
-import { normalize_angle_rad } from "../../../../../core/geom/normalize_angle_rad.js";
-import Quaternion from "../../../../../core/geom/Quaternion.js";
-import Vector3 from '../../../../../core/geom/Vector3.js';
-import { lerp } from "../../../../../core/math/lerp.js";
-import { max2 } from "../../../../../core/math/max2.js";
-import { sign_not_zero } from "../../../../../core/math/sign_not_zero.js";
-
-const m4 = new Matrix4();
-const angles = [];
-
-const q_view = new Quaternion();
-
-const v3_view_right = new Vector3();
-const v3_view_up = new Vector3();
-
-
-/**
- *
- * @param {number} displacement_x
- * @param {number} displacement_y
- * @param {TopDownCameraController} input source thing being rotated
- * @param {TopDownCameraController} output target thing where the result is written to
- */
-export function rotate_from_view(displacement_x, displacement_y, input, output) {
-    // crop yaw and pitch to safe range of -PI to PI
-    const i_pitch = normalize_angle_rad(input.pitch);
-    const i_yaw = normalize_angle_rad(input.yaw);
-    const i_roll = normalize_angle_rad(input.roll);
-
-    const quaternion = Quaternion.fromEulerAngles(i_pitch, i_yaw, i_roll);
-    const forward = Vector3.up.clone();
-    forward.applyQuaternion(quaternion);
-
-    // flip rotation axis when pitch is over 90deg in either direction, that is UP vector is pointing down
-    const d_yaw = sign_not_zero(forward.y) * displacement_x;
-
-    output.yaw = i_yaw + d_yaw;
-    output.pitch = i_pitch - displacement_y;
-}
-
-/**
- * The orientation a controller looks along. The camera's transform is built from this and the
- * distance, so anything that needs the view's own axes takes them from here rather than from
- * whatever object a renderer happens to keep.
- *
- * @param {Quaternion} result
- * @param {TopDownCameraController} controller
- */
-export function top_down_view_rotation(result, controller) {
-    result.fromEulerAnglesZYX(controller.pitch, controller.yaw, controller.roll);
-}
-
-/**
- * @param {Vector3} result
- * @param {Vector3} direction unit length
- * @param {number} distance world units
- * @param {Vector3} multiplier
- */
-function move_along(result, direction, distance, multiplier) {
-    result._add(
-        direction.x * distance * multiplier.x,
-        direction.y * distance * multiplier.y,
-        direction.z * distance * multiplier.z
-    );
-}
-
-const deg2_in_rad = Math.PI / 360;
-
-/**
- * Move a controller's target across the view plane it is looking at, by a displacement given in
- * viewport pixels; right and down are positive.
- *
- * Handlers pass where the pointer *was* less where it *is*, so the target travels against the drag
- * and the world under the pointer comes with it.
- *
- * **The viewer's right is the negated X axis of the view rotation**, which is the one thing here
- * that is easy to invert silently: meep's forward is +Z with up +Y, so a viewer facing along
- * forward has world −X on their right. Both renderers read it that way — Shade builds its view
- * matrix from `[−right, up, −forward]`, and the three camera the legacy path drives carries the
- * object orientation with its forward negated, which flips the same axis.
- *
- * @param {Vector2} delta viewport pixels
- * @param {TopDownCameraController} controller its {@link TopDownCameraController#target} is moved
- * @param {number} viewport_height_px the perspective camera is fitted to height alone, so width
- * plays no part
- * @param {number} fov vertical field of view, in degrees
- * @param {Vector3} [multiplier] per-axis scale on the world displacement; the strategy map zeroes Y
- * to keep its target on the ground
- */
-function pan(delta, controller, viewport_height_px, fov, multiplier = Vector3.one) {
-    assert.isNumber(viewport_height_px, 'viewport_height_px');
-    assert.isNumber(fov, 'fov');
-
-    // half of the fov is center to top of screen
-    const d = controller.distance * Math.tan(fov * deg2_in_rad);
-
-    const m = 2 * d / viewport_height_px;
-
-    top_down_view_rotation(q_view, controller);
-
-    v3_view_right.copy(Vector3.right);
-    v3_view_right.applyQuaternion(q_view);
-    v3_view_right.negate();
-
-    v3_view_up.copy(Vector3.up);
-    v3_view_up.applyQuaternion(q_view);
-
-    const target = controller.target;
-
-    move_along(target, v3_view_right, delta.x * m, multiplier);
-
-    // screen Y runs down the viewport and the view's up runs the other way
-    move_along(target, v3_view_up, -delta.y * m, multiplier);
-}
-
-
-class TopDownCameraController {
-    target = new Vector3();
-    pitch = 0;
-    yaw = 0;
-    roll = 0;
-    distance = 0;
-    distanceMin = 1;
-    distanceMax = 200;
-
-    constructor(options) {
-        //
-        if (options !== void 0) {
-            this.fromJSON(options);
-        }
-    }
-
-    /**
-     * Set target, rotation and distance from 2 vectors
-     * @param {Vector3} eye
-     * @param {Vector3} target
-     * @param {Vector3} [up]
-     */
-    setFromEyeAndTarget(eye, target, up = Vector3.up) {
-
-        /*
-        NOTE: I'm not sure why, but three.js camera points in the opposite direction to normal objects
-        See: https://github.com/mrdoob/three.js/blob/412b99a7f26e117ea97f40eb53d010ab81aa3279/src/core/Object3D.js#L282
-         */
-        m4.lookAt(target, eye, up);
-
-        m4_euler_angles(angles, m4.elements, 2, 1, 0)
-
-        this.pitch = angles[2];
-        this.yaw = angles[1];
-        this.roll = angles[0];
-
-        this.distance = eye.distanceTo(target);
-
-        // ensure we can maintain this distance
-        this.distanceMax = max2(this.distance, this.distanceMax);
-
-        this.target.copy(target);
-    }
-
-    /**
-     *
-     * @param {TopDownCameraController} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.target.equals(other.target)
-            && this.pitch === other.pitch
-            && this.yaw === other.yaw
-            && this.roll === other.roll
-            && this.distance === other.distance
-            && this.distanceMin === other.distanceMin
-            && this.distanceMax === other.distanceMax
-            ;
-    }
-
-    /**
-     *
-     * @param {TopDownCameraController} other
-     */
-    copy(other) {
-        this.target.copy(other.target);
-
-        this.pitch = other.pitch;
-        this.yaw = other.yaw;
-        this.roll = other.roll;
-
-        this.distance = other.distance;
-        this.distanceMax = other.distanceMax;
-        this.distanceMin = other.distanceMin;
-    }
-
-    /**
-     *
-     * @returns {TopDownCameraController}
-     */
-    clone() {
-        const r = new TopDownCameraController();
-
-        r.copy(this);
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {TopDownCameraController} a
-     * @param {TopDownCameraController} b
-     * @param {number} t
-     */
-    lerp(a, b, t) {
-        this.target.lerpVectors(a.target, b.target, t);
-
-        this.pitch = lerp(a.pitch, b.pitch, t);
-        this.yaw = lerp(a.yaw, b.yaw, t);
-        this.roll = lerp(a.roll, b.roll, t);
-
-        this.distance = lerp(a.distance, b.distance, t);
-
-        this.distanceMin = lerp(a.distanceMin, b.distanceMin, t);
-        this.distanceMax = lerp(a.distanceMax, b.distanceMax, t);
-    }
-
-    toJSON() {
-        return {
-            target: this.target.toJSON(),
-
-            pitch: this.pitch,
-            yaw: this.yaw,
-            roll: this.roll,
-
-            distance: this.distance,
-            distanceMin: this.distanceMin,
-            distanceMax: this.distanceMax
-        };
-    }
-
-    fromJSON(
-        {
-            distance = 0,
-            distanceMin = 0,
-            distanceMax = 0,
-            pitch = 0,
-            yaw = 0,
-            roll = 0,
-            target = Vector3.zero,
-        }
-    ) {
-
-        this.distance = distance;
-        this.distanceMin = distanceMin;
-        this.distanceMax = distanceMax;
-
-        this.pitch = pitch;
-        this.roll = roll;
-        this.yaw = yaw;
-
-        this.target.fromJSON(target);
-
-    }
-
-    static fromJSON(j) {
-        const r = new TopDownCameraController();
-
-        r.fromJSON(j);
-
-        return r;
-    }
-}
-
-TopDownCameraController.typeName = "TopDownCameraController";
-
-TopDownCameraController.pan = pan;
-TopDownCameraController.rotate = rotate_from_view;
-
-export default TopDownCameraController;
-
-
+import { assert } from "../../../../../core/assert.js";
+import { m4_euler_angles } from "../../../../../core/geom/3d/mat4/m4_euler_angles.js";
+import {
+    m4_from_rotation_translation_scale_scalar
+} from "../../../../../core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.js";
+import { normalize_angle_rad } from "../../../../../core/geom/normalize_angle_rad.js";
+import Quaternion from "../../../../../core/geom/Quaternion.js";
+import Vector3 from '../../../../../core/geom/Vector3.js';
+import { lerp } from "../../../../../core/math/lerp.js";
+import { max2 } from "../../../../../core/math/max2.js";
+import { sign_not_zero } from "../../../../../core/math/sign_not_zero.js";
+
+const m4 = [];
+const angles = [];
+
+const q_look = new Quaternion();
+const v3_forward = new Vector3();
+
+const q_view = new Quaternion();
+
+const v3_view_right = new Vector3();
+const v3_view_up = new Vector3();
+
+
+/**
+ *
+ * @param {number} displacement_x
+ * @param {number} displacement_y
+ * @param {TopDownCameraController} input source thing being rotated
+ * @param {TopDownCameraController} output target thing where the result is written to
+ */
+export function rotate_from_view(displacement_x, displacement_y, input, output) {
+    // crop yaw and pitch to safe range of -PI to PI
+    const i_pitch = normalize_angle_rad(input.pitch);
+    const i_yaw = normalize_angle_rad(input.yaw);
+    const i_roll = normalize_angle_rad(input.roll);
+
+    const quaternion = Quaternion.fromEulerAngles(i_pitch, i_yaw, i_roll);
+    const forward = Vector3.up.clone();
+    forward.applyQuaternion(quaternion);
+
+    // flip rotation axis when pitch is over 90deg in either direction, that is UP vector is pointing down
+    const d_yaw = sign_not_zero(forward.y) * displacement_x;
+
+    output.yaw = i_yaw + d_yaw;
+    output.pitch = i_pitch - displacement_y;
+}
+
+/**
+ * The orientation a controller looks along. The camera's transform is built from this and the
+ * distance, so anything that needs the view's own axes takes them from here rather than from
+ * whatever object a renderer happens to keep.
+ *
+ * @param {Quaternion} result
+ * @param {TopDownCameraController} controller
+ */
+export function top_down_view_rotation(result, controller) {
+    result.fromEulerAnglesZYX(controller.pitch, controller.yaw, controller.roll);
+}
+
+/**
+ * @param {Vector3} result
+ * @param {Vector3} direction unit length
+ * @param {number} distance world units
+ * @param {Vector3} multiplier
+ */
+function move_along(result, direction, distance, multiplier) {
+    result._add(
+        direction.x * distance * multiplier.x,
+        direction.y * distance * multiplier.y,
+        direction.z * distance * multiplier.z
+    );
+}
+
+const deg2_in_rad = Math.PI / 360;
+
+/**
+ * Move a controller's target across the view plane it is looking at, by a displacement given in
+ * viewport pixels; right and down are positive.
+ *
+ * Handlers pass where the pointer *was* less where it *is*, so the target travels against the drag
+ * and the world under the pointer comes with it.
+ *
+ * **The viewer's right is the negated X axis of the view rotation**, which is the one thing here
+ * that is easy to invert silently: meep's forward is +Z with up +Y, so a viewer facing along
+ * forward has world −X on their right. Both renderers read it that way — Shade builds its view
+ * matrix from `[−right, up, −forward]`, and the three camera the legacy path drives carries the
+ * object orientation with its forward negated, which flips the same axis.
+ *
+ * @param {Vector2} delta viewport pixels
+ * @param {TopDownCameraController} controller its {@link TopDownCameraController#target} is moved
+ * @param {number} viewport_height_px the perspective camera is fitted to height alone, so width
+ * plays no part
+ * @param {number} fov vertical field of view, in degrees
+ * @param {Vector3} [multiplier] per-axis scale on the world displacement; the strategy map zeroes Y
+ * to keep its target on the ground
+ */
+function pan(delta, controller, viewport_height_px, fov, multiplier = Vector3.one) {
+    assert.isNumber(viewport_height_px, 'viewport_height_px');
+    assert.isNumber(fov, 'fov');
+
+    // half of the fov is center to top of screen
+    const d = controller.distance * Math.tan(fov * deg2_in_rad);
+
+    const m = 2 * d / viewport_height_px;
+
+    top_down_view_rotation(q_view, controller);
+
+    v3_view_right.copy(Vector3.right);
+    v3_view_right.applyQuaternion(q_view);
+    v3_view_right.negate();
+
+    v3_view_up.copy(Vector3.up);
+    v3_view_up.applyQuaternion(q_view);
+
+    const target = controller.target;
+
+    move_along(target, v3_view_right, delta.x * m, multiplier);
+
+    // screen Y runs down the viewport and the view's up runs the other way
+    move_along(target, v3_view_up, -delta.y * m, multiplier);
+}
+
+
+class TopDownCameraController {
+    target = new Vector3();
+    pitch = 0;
+    yaw = 0;
+    roll = 0;
+    distance = 0;
+    distanceMin = 1;
+    distanceMax = 200;
+
+    constructor(options) {
+        //
+        if (options !== void 0) {
+            this.fromJSON(options);
+        }
+    }
+
+    /**
+     * Set target, rotation and distance from 2 vectors.
+     *
+     * `eye` must not coincide with `target`, and `up` must not be parallel to the direction between
+     * them — a degenerate basis has no angles to report and the caller gets an arbitrary one.
+     *
+     * @param {Vector3} eye
+     * @param {Vector3} target
+     * @param {Vector3} [up]
+     */
+    setFromEyeAndTarget(eye, target, up = Vector3.up) {
+
+        v3_forward.copy(target);
+        v3_forward.sub(eye);
+
+        q_look.lookRotation(v3_forward, up);
+
+        m4_from_rotation_translation_scale_scalar(
+            m4,
+            q_look.x, q_look.y, q_look.z, q_look.w,
+            0, 0, 0,
+            1, 1, 1
+        );
+
+        m4_euler_angles(angles, m4, 2, 1, 0)
+
+        this.pitch = angles[2];
+        this.yaw = angles[1];
+        this.roll = angles[0];
+
+        this.distance = eye.distanceTo(target);
+
+        // ensure we can maintain this distance
+        this.distanceMax = max2(this.distance, this.distanceMax);
+
+        this.target.copy(target);
+    }
+
+    /**
+     *
+     * @param {TopDownCameraController} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.target.equals(other.target)
+            && this.pitch === other.pitch
+            && this.yaw === other.yaw
+            && this.roll === other.roll
+            && this.distance === other.distance
+            && this.distanceMin === other.distanceMin
+            && this.distanceMax === other.distanceMax
+            ;
+    }
+
+    /**
+     *
+     * @param {TopDownCameraController} other
+     */
+    copy(other) {
+        this.target.copy(other.target);
+
+        this.pitch = other.pitch;
+        this.yaw = other.yaw;
+        this.roll = other.roll;
+
+        this.distance = other.distance;
+        this.distanceMax = other.distanceMax;
+        this.distanceMin = other.distanceMin;
+    }
+
+    /**
+     *
+     * @returns {TopDownCameraController}
+     */
+    clone() {
+        const r = new TopDownCameraController();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {TopDownCameraController} a
+     * @param {TopDownCameraController} b
+     * @param {number} t
+     */
+    lerp(a, b, t) {
+        this.target.lerpVectors(a.target, b.target, t);
+
+        this.pitch = lerp(a.pitch, b.pitch, t);
+        this.yaw = lerp(a.yaw, b.yaw, t);
+        this.roll = lerp(a.roll, b.roll, t);
+
+        this.distance = lerp(a.distance, b.distance, t);
+
+        this.distanceMin = lerp(a.distanceMin, b.distanceMin, t);
+        this.distanceMax = lerp(a.distanceMax, b.distanceMax, t);
+    }
+
+    toJSON() {
+        return {
+            target: this.target.toJSON(),
+
+            pitch: this.pitch,
+            yaw: this.yaw,
+            roll: this.roll,
+
+            distance: this.distance,
+            distanceMin: this.distanceMin,
+            distanceMax: this.distanceMax
+        };
+    }
+
+    fromJSON(
+        {
+            distance = 0,
+            distanceMin = 0,
+            distanceMax = 0,
+            pitch = 0,
+            yaw = 0,
+            roll = 0,
+            target = Vector3.zero,
+        }
+    ) {
+
+        this.distance = distance;
+        this.distanceMin = distanceMin;
+        this.distanceMax = distanceMax;
+
+        this.pitch = pitch;
+        this.roll = roll;
+        this.yaw = yaw;
+
+        this.target.fromJSON(target);
+
+    }
+
+    static fromJSON(j) {
+        const r = new TopDownCameraController();
+
+        r.fromJSON(j);
+
+        return r;
+    }
+}
+
+TopDownCameraController.typeName = "TopDownCameraController";
+
+TopDownCameraController.pan = pan;
+TopDownCameraController.rotate = rotate_from_view;
+
+export default TopDownCameraController;
+
+

package/src/engine/graphics/ecs/render_layers_compute_depth_range.d.ts

@@ -5,7 +5,7 @@
  *
  * WHY THIS EXISTS
  *
- * `auto_set_camera_clipping_planes` and `extend_shadow_camera_near_for_casters`
+ * `extend_shadow_camera_near_for_casters` and the camera auto-clipping pass that has since gone
  * each restated two things verbatim:
  *
  *  - the three.js matrix-layout invariant that a camera's view direction is the

package/src/engine/graphics/ecs/render_layers_compute_depth_range.js

@@ -5,7 +5,7 @@
  *
  * WHY THIS EXISTS
  *
- * `auto_set_camera_clipping_planes` and `extend_shadow_camera_near_for_casters`
+ * `extend_shadow_camera_near_for_casters` and the camera auto-clipping pass that has since gone
  * each restated two things verbatim:
  *
  *  - the three.js matrix-layout invariant that a camera's view direction is the

package/src/engine/graphics/geometry/AttributeData.d.ts

@@ -0,0 +1,52 @@
+/**
+ * An {@link AttributeSpec} and the elements stored under it.
+ *
+ * The spec says what one item is — how many components, in what type, whether integer values are
+ * read back normalized — and the array holds `count` of them end to end. Nothing here knows about a
+ * renderer: uploading is the business of whoever is drawing, and a consumer that re-reads the array
+ * every frame has nothing to be told.
+ */
+export class AttributeData {
+    /**
+     * Allocate storage for `count` items of `spec`.
+     *
+     * @param {AttributeSpec} spec
+     * @param {number} count
+     * @returns {AttributeData}
+     */
+    static allocate(spec: AttributeSpec, count: number): AttributeData;
+    /**
+     * @param {AttributeSpec} spec
+     * @param {Float32Array|Float64Array|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array} array
+     */
+    constructor(spec: AttributeSpec, array: Float32Array | Float64Array | Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array);
+    /**
+     * @type {AttributeSpec}
+     */
+    spec: AttributeSpec;
+    /**
+     * `count * spec.itemSize` elements, item-major.
+     *
+     * @type {Float32Array|Float64Array|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array}
+     */
+    array: Float32Array | Float64Array | Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array;
+    /**
+     * @returns {string}
+     */
+    get name(): string;
+    /**
+     * @returns {number}
+     */
+    get itemSize(): number;
+    /**
+     * @returns {boolean}
+     */
+    get normalized(): boolean;
+    /**
+     * How many items the array has room for.
+     *
+     * @returns {number}
+     */
+    get count(): number;
+}
+//# sourceMappingURL=AttributeData.d.ts.map