@woosh/meep-engine 3.11.3 → 3.13.0

package/src/view/minimap/dom/MinimapCameraView.js

@@ -1,206 +1,206 @@
-import View from "../../View.js";
-import Vector3 from "../../../core/geom/Vector3.js";
-import ObservedValue from "../../../core/model/ObservedValue.js";
-import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
-import SVG from "../../SVG.js";
-import { plane3_compute_ray_intersection } from "../../../core/geom/3d/plane/plane3_compute_ray_intersection.js";
-
-
-const rayContact = new SurfacePoint3();
-
-export class MinimapCameraView extends View {
-    /**
-     * @param {Camera} camera
-     * @param {Transform} transform
-     * @param entity
-     * @param {Rectangle} world
-     * @param {Vector2} worldScale
-     * @param {GraphicsEngine|GraphicsEngine3} graphics asked for the ray the frame is traced with
-     * @constructor
-     */
-    constructor({ camera, transform, entity, world, worldScale, graphics }) {
-        super();
-
-        this.el = SVG.createElement('svg');
-
-        this.addClass('ui-camera-view');
-
-        /**
-         *
-         * @type {Element}
-         * @private
-         */
-        this.__el_polygon = SVG.createElement('polygon');
-
-        this.el.appendChild(this.__el_polygon);
-
-        /**
-         *
-         * @type {Camera}
-         */
-        this.camera = camera;
-
-        /**
-         * **The frame is traced with the renderer's own ray, not the camera component's.**
-         * `Camera.projectRay` went through a three camera object that only the legacy camera
-         * system built — under Shade it was never built, so every update warned and drew
-         * nothing. `viewportProjectionRay` is the one picking primitive both engines answer with the
-         * same meaning, and it reports the camera that actually drew.
-         *
-         * It therefore traces the view the player has rather than this entity's camera. The two are
-         * the same wherever the game has one camera, which is everywhere it has a minimap.
-         *
-         * @type {GraphicsEngine|GraphicsEngine3}
-         */
-        this.graphics = graphics;
-        /**
-         *
-         * @type {Transform}
-         */
-        this.transform = transform;
-
-        this.entity = entity;
-
-        /**
-         *
-         * @type {Rectangle}
-         * @private
-         */
-        this.__world = world;
-
-        /**
-         *
-         * @type {Vector2}
-         * @private
-         */
-        this.__world_scale = worldScale;
-
-        /**
-         *
-         * @type {ObservedValue<Terrain>}
-         */
-        this.terrain = new ObservedValue(null);
-
-
-        this
-            .bindSignal(this.camera.projectionType.onChanged, this.__update, this)
-            .bindSignal(this.transform.position.onChanged, this.__update, this)
-            .bindSignal(worldScale.onChanged, this.__update, this)
-            .bindSignal(world.position.onChanged, this.__update, this)
-            .bindSignal(this.transform.rotation.onChanged, this.__update, this);
-
-    }
-
-    /**
-     *
-     * @param {Vector3} result
-     * @param {number} originX
-     * @param {number} originY
-     * @param {number} originZ
-     * @param {number} directionX
-     * @param {number} directionY
-     * @param {number} directionZ
-     */
-    castTerrainRay(result, originX, originY, originZ, directionX, directionY, directionZ) {
-        const terrain = this.terrain.getValue();
-
-        const JITTER = 0.00001;
-
-        if (terrain === null) {
-            plane3_compute_ray_intersection(result, originX, originY, originZ, directionX, directionY, directionZ, 0, 1, 0, 0);
-        } else {
-
-            let oX = originX;
-            let oY = originY;
-            let oZ = originZ;
-
-            let foundHit = false;
-
-            for (let i = 0; i < 10 && !foundHit; i++) {
-                foundHit = terrain.raycastFirstSync(rayContact, originX, originY, originZ, directionX, directionY, directionZ);
-
-                if (!foundHit) {
-                    //no hit found, try to jitter origin in case of mathematical error at polygon edges
-                    oX += (Math.random() - 0.5) * JITTER;
-                    oY += (Math.random() - 0.5) * JITTER;
-                    oZ += (Math.random() - 0.5) * JITTER;
-                } else {
-                    result.copy(rayContact.position);
-                }
-
-            }
-
-            if (!foundHit) {
-                //no hit found, fall back to planar test
-                plane3_compute_ray_intersection(result, originX, originY, originZ, directionX, directionY, directionZ, 0, 1, 0, 0);
-            }
-
-        }
-
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @returns {Vector3}
-     */
-    getPoint(x, y) {
-        /**
-         *
-         * @type {Rectangle}
-         */
-        const world = this.__world;
-
-        /**
-         *
-         * @type {Vector2}
-         */
-        const worldScale = this.__world_scale;
-
-        const vOrigin = new Vector3(-1, 1, 0.5);
-        const vDirection = new Vector3(1, -1, 0.5);
-
-        this.graphics.viewportProjectionRay(x, y, vOrigin, vDirection);
-
-        const vResult = new Vector3(0, 0, 0);
-
-        this.castTerrainRay(vResult, vOrigin.x, vOrigin.y, vOrigin.z, vDirection.x, vDirection.y, vDirection.z);
-
-        vResult.x -= world.position.x;
-        vResult.x *= worldScale.x;
-
-        vResult.z -= world.position.y;
-        vResult.z *= worldScale.y;
-
-        return vResult;
-    }
-
-    __update() {
-        const v_tl = this.getPoint(-1, 1);
-        const v_tr = this.getPoint(1, 1);
-        const v_br = this.getPoint(1, -1);
-        const v_bl = this.getPoint(-1, -1);
-
-
-        this.__el_polygon.setAttribute('points', `${v_tl.x},${v_tl.z} ${v_tr.x},${v_tr.z} ${v_br.x},${v_br.z} ${v_bl.x},${v_bl.z}`);
-    };
-
-
-    link() {
-        super.link();
-        try {
-            this.__update();
-        } catch (e) {
-            console.error('Failed to execute update', e);
-        }
-    }
-
-    unlink() {
-        super.unlink();
-
-    }
-}
-
-
-
+import View from "../../View.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import ObservedValue from "../../../core/model/ObservedValue.js";
+import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
+import SVG from "../../SVG.js";
+import { plane3_compute_ray_intersection } from "../../../core/geom/3d/plane/plane3_compute_ray_intersection.js";
+
+
+const rayContact = new SurfacePoint3();
+
+export class MinimapCameraView extends View {
+    /**
+     * @param {Camera} camera
+     * @param {Transform} transform
+     * @param entity
+     * @param {Rectangle} world
+     * @param {Vector2} worldScale
+     * @param {GraphicsEngine|GraphicsEngine} graphics asked for the ray the frame is traced with
+     * @constructor
+     */
+    constructor({ camera, transform, entity, world, worldScale, graphics }) {
+        super();
+
+        this.el = SVG.createElement('svg');
+
+        this.addClass('ui-camera-view');
+
+        /**
+         *
+         * @type {Element}
+         * @private
+         */
+        this.__el_polygon = SVG.createElement('polygon');
+
+        this.el.appendChild(this.__el_polygon);
+
+        /**
+         *
+         * @type {Camera}
+         */
+        this.camera = camera;
+
+        /**
+         * **The frame is traced with the renderer's own ray, not the camera component's.**
+         * `Camera.projectRay` went through a three camera object that only the legacy camera
+         * system built — under Shade it was never built, so every update warned and drew
+         * nothing. `viewportProjectionRay` is the one picking primitive both engines answer with the
+         * same meaning, and it reports the camera that actually drew.
+         *
+         * It therefore traces the view the player has rather than this entity's camera. The two are
+         * the same wherever the game has one camera, which is everywhere it has a minimap.
+         *
+         * @type {GraphicsEngine|GraphicsEngine}
+         */
+        this.graphics = graphics;
+        /**
+         *
+         * @type {Transform}
+         */
+        this.transform = transform;
+
+        this.entity = entity;
+
+        /**
+         *
+         * @type {Rectangle}
+         * @private
+         */
+        this.__world = world;
+
+        /**
+         *
+         * @type {Vector2}
+         * @private
+         */
+        this.__world_scale = worldScale;
+
+        /**
+         *
+         * @type {ObservedValue<Terrain>}
+         */
+        this.terrain = new ObservedValue(null);
+
+
+        this
+            .bindSignal(this.camera.projectionType.onChanged, this.__update, this)
+            .bindSignal(this.transform.position.onChanged, this.__update, this)
+            .bindSignal(worldScale.onChanged, this.__update, this)
+            .bindSignal(world.position.onChanged, this.__update, this)
+            .bindSignal(this.transform.rotation.onChanged, this.__update, this);
+
+    }
+
+    /**
+     *
+     * @param {Vector3} result
+     * @param {number} originX
+     * @param {number} originY
+     * @param {number} originZ
+     * @param {number} directionX
+     * @param {number} directionY
+     * @param {number} directionZ
+     */
+    castTerrainRay(result, originX, originY, originZ, directionX, directionY, directionZ) {
+        const terrain = this.terrain.getValue();
+
+        const JITTER = 0.00001;
+
+        if (terrain === null) {
+            plane3_compute_ray_intersection(result, originX, originY, originZ, directionX, directionY, directionZ, 0, 1, 0, 0);
+        } else {
+
+            let oX = originX;
+            let oY = originY;
+            let oZ = originZ;
+
+            let foundHit = false;
+
+            for (let i = 0; i < 10 && !foundHit; i++) {
+                foundHit = terrain.raycastFirstSync(rayContact, originX, originY, originZ, directionX, directionY, directionZ);
+
+                if (!foundHit) {
+                    //no hit found, try to jitter origin in case of mathematical error at polygon edges
+                    oX += (Math.random() - 0.5) * JITTER;
+                    oY += (Math.random() - 0.5) * JITTER;
+                    oZ += (Math.random() - 0.5) * JITTER;
+                } else {
+                    result.copy(rayContact.position);
+                }
+
+            }
+
+            if (!foundHit) {
+                //no hit found, fall back to planar test
+                plane3_compute_ray_intersection(result, originX, originY, originZ, directionX, directionY, directionZ, 0, 1, 0, 0);
+            }
+
+        }
+
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {Vector3}
+     */
+    getPoint(x, y) {
+        /**
+         *
+         * @type {Rectangle}
+         */
+        const world = this.__world;
+
+        /**
+         *
+         * @type {Vector2}
+         */
+        const worldScale = this.__world_scale;
+
+        const vOrigin = new Vector3(-1, 1, 0.5);
+        const vDirection = new Vector3(1, -1, 0.5);
+
+        this.graphics.viewportProjectionRay(x, y, vOrigin, vDirection);
+
+        const vResult = new Vector3(0, 0, 0);
+
+        this.castTerrainRay(vResult, vOrigin.x, vOrigin.y, vOrigin.z, vDirection.x, vDirection.y, vDirection.z);
+
+        vResult.x -= world.position.x;
+        vResult.x *= worldScale.x;
+
+        vResult.z -= world.position.y;
+        vResult.z *= worldScale.y;
+
+        return vResult;
+    }
+
+    __update() {
+        const v_tl = this.getPoint(-1, 1);
+        const v_tr = this.getPoint(1, 1);
+        const v_br = this.getPoint(1, -1);
+        const v_bl = this.getPoint(-1, -1);
+
+
+        this.__el_polygon.setAttribute('points', `${v_tl.x},${v_tl.z} ${v_tr.x},${v_tr.z} ${v_br.x},${v_br.z} ${v_bl.x},${v_bl.z}`);
+    };
+
+
+    link() {
+        super.link();
+        try {
+            this.__update();
+        } catch (e) {
+            console.error('Failed to execute update', e);
+        }
+    }
+
+    unlink() {
+        super.unlink();
+
+    }
+}
+
+
+

package/src/shade/device/timing/profile/make_profiling_pass_encoder.d.ts

@@ -1,21 +0,0 @@
-/**
- * Wrap a pass encoder so that the work encoded into it is recorded.
- *
- * **A `Proxy` rather than a hand-written forwarder.** A pass encoder has around twenty methods and
- * WebGPU keeps adding them; a forwarding class that misses one does not fail loudly, it silently
- * drops a call that the renderer needed, and only while profiling — the worst possible shape for a
- * bug. Everything not named below is forwarded untouched, including anything added later.
- *
- * The cost is a `Proxy` on the hot encoding path, which is why this exists only while a capture is
- * running at {@link GPUProfileLevel.WORKLOAD} or above. Bound methods are cached per encoder so the
- * `get` trap does not allocate a new closure on every `setBindGroup`.
- *
- * @param {GPUComputePassEncoder|GPURenderPassEncoder} encoder
- * @param {GPUProfileWork} work accumulated into
- * @returns {GPUComputePassEncoder|GPURenderPassEncoder}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function make_profiling_pass_encoder(encoder: GPUComputePassEncoder | GPURenderPassEncoder, work: GPUProfileWork): GPUComputePassEncoder | GPURenderPassEncoder;
-//# sourceMappingURL=make_profiling_pass_encoder.d.ts.map

package/src/shade/device/timing/profile/make_profiling_pass_encoder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"make_profiling_pass_encoder.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/make_profiling_pass_encoder.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qDAPW,4CAA0C,yBAExC,4CAA0C,CAiGtD"}

package/src/shade/device/timing/profile/make_profiling_pass_encoder.js

@@ -1,114 +0,0 @@
-import { assert } from "../../../../core/assert.js";
-
-/**
- * Wrap a pass encoder so that the work encoded into it is recorded.
- *
- * **A `Proxy` rather than a hand-written forwarder.** A pass encoder has around twenty methods and
- * WebGPU keeps adding them; a forwarding class that misses one does not fail loudly, it silently
- * drops a call that the renderer needed, and only while profiling — the worst possible shape for a
- * bug. Everything not named below is forwarded untouched, including anything added later.
- *
- * The cost is a `Proxy` on the hot encoding path, which is why this exists only while a capture is
- * running at {@link GPUProfileLevel.WORKLOAD} or above. Bound methods are cached per encoder so the
- * `get` trap does not allocate a new closure on every `setBindGroup`.
- *
- * @param {GPUComputePassEncoder|GPURenderPassEncoder} encoder
- * @param {GPUProfileWork} work accumulated into
- * @returns {GPUComputePassEncoder|GPURenderPassEncoder}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function make_profiling_pass_encoder(encoder, work) {
-    assert.defined(encoder, 'encoder');
-    assert.defined(work, 'work');
-
-    /**
-     * @type {Map<string|symbol, function>}
-     */
-    const bound = new Map();
-
-    /**
-     * @param {string} name
-     * @param {function} original
-     * @returns {function}
-     */
-    function wrap(name, original) {
-        switch (name) {
-
-            case 'dispatchWorkgroups':
-                return function (x, y = 1, z = 1) {
-                    work.dispatch_count++;
-                    work.workgroups[0] += x;
-                    work.workgroups[1] += y;
-                    work.workgroups[2] += z;
-
-                    return original.call(encoder, x, y, z);
-                };
-
-            case 'dispatchWorkgroupsIndirect':
-                return function (...args) {
-                    // Size lives in a GPU buffer, so there is nothing to add to `workgroups`.
-                    // Counted apart so the totals are not read as covering this.
-                    work.indirect_dispatch_count++;
-
-                    return original.apply(encoder, args);
-                };
-
-            case 'draw':
-                return function (vertex_count, instance_count = 1, ...rest) {
-                    work.draw_count++;
-                    work.vertex_count += vertex_count;
-                    work.instance_count += instance_count;
-
-                    return original.call(encoder, vertex_count, instance_count, ...rest);
-                };
-
-            case 'drawIndexed':
-                return function (index_count, instance_count = 1, ...rest) {
-                    work.draw_count++;
-                    work.index_count += index_count;
-                    work.instance_count += instance_count;
-
-                    return original.call(encoder, index_count, instance_count, ...rest);
-                };
-
-            case 'drawIndirect':
-            case 'drawIndexedIndirect':
-                return function (...args) {
-                    work.indirect_draw_count++;
-
-                    return original.apply(encoder, args);
-                };
-
-            default:
-                return function (...args) {
-                    return original.apply(encoder, args);
-                };
-        }
-    }
-
-    return new Proxy(encoder, {
-        get(target, property) {
-            const value = Reflect.get(target, property, target);
-
-            if (typeof value !== 'function') {
-                return value;
-            }
-
-            let fn = bound.get(property);
-
-            if (fn === undefined) {
-                fn = wrap(property, value);
-
-                bound.set(property, fn);
-            }
-
-            return fn;
-        },
-
-        set(target, property, value) {
-            return Reflect.set(target, property, value, target);
-        }
-    });
-}

package/src/shade/device/timing/profile/parse_workgroup_size.d.ts

@@ -1,20 +0,0 @@
-/**
- * Read a compute entry point's workgroup size out of its WGSL.
- *
- * **Only literal sizes.** WGSL allows `@workgroup_size(WG_X)` against a pipeline-overridable
- * constant, and resolving that would mean tracking override values through pipeline creation for a
- * number that is nice to have. Such a shader reports `[0, 0, 0]`, which the model treats as
- * *unknown* rather than as zero — an invocation count of 0 alongside a real duration would be a
- * lie, and this is the difference between the two.
- *
- * A module with several entry points reports the first size found. Shade compiles one entry point
- * per compute pipeline, so in practice there is only ever one.
- *
- * @param {string} code WGSL source
- * @returns {number[]} `[x, y, z]`, or `[0, 0, 0]` when it could not be read
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function parse_workgroup_size(code: string): number[];
-//# sourceMappingURL=parse_workgroup_size.d.ts.map

package/src/shade/device/timing/profile/parse_workgroup_size.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse_workgroup_size.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/parse_workgroup_size.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;GAiBG;AACH,2CANW,MAAM,GACJ,MAAM,EAAE,CAqBpB"}

package/src/shade/device/timing/profile/parse_workgroup_size.js

@@ -1,43 +0,0 @@
-/**
- * `@workgroup_size(...)` with literal integer arguments. Whitespace is permitted anywhere WGSL
- * permits it; anything that is not a plain decimal literal deliberately fails to match.
- *
- * @type {RegExp}
- */
-const WORKGROUP_SIZE = /@workgroup_size\s*\(\s*(\d+)\s*(?:,\s*(\d+)\s*)?(?:,\s*(\d+)\s*)?\)/;
-
-/**
- * Read a compute entry point's workgroup size out of its WGSL.
- *
- * **Only literal sizes.** WGSL allows `@workgroup_size(WG_X)` against a pipeline-overridable
- * constant, and resolving that would mean tracking override values through pipeline creation for a
- * number that is nice to have. Such a shader reports `[0, 0, 0]`, which the model treats as
- * *unknown* rather than as zero — an invocation count of 0 alongside a real duration would be a
- * lie, and this is the difference between the two.
- *
- * A module with several entry points reports the first size found. Shade compiles one entry point
- * per compute pipeline, so in practice there is only ever one.
- *
- * @param {string} code WGSL source
- * @returns {number[]} `[x, y, z]`, or `[0, 0, 0]` when it could not be read
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function parse_workgroup_size(code) {
-    if (typeof code !== 'string') {
-        return [0, 0, 0];
-    }
-
-    const match = WORKGROUP_SIZE.exec(code);
-
-    if (match === null) {
-        return [0, 0, 0];
-    }
-
-    return [
-        Number(match[1]),
-        match[2] !== undefined ? Number(match[2]) : 1,
-        match[3] !== undefined ? Number(match[3]) : 1
-    ];
-}

package/src/shade/renderer/shadow/map/csm/shader/shader_setup_cascades.d.ts

@@ -1,3 +0,0 @@
-export const shader_setup_cascades: ComputeShader;
-import { ComputeShader } from "../../../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_setup_cascades.d.ts.map

package/src/shade/renderer/shadow/map/csm/shader/shader_setup_cascades.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_setup_cascades.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shadow/map/csm/shader/shader_setup_cascades.js"],"names":[],"mappings":"AAeA,kDAIG;8BAlB2B,qCAAqC"}

package/src/shade/renderer/shadow/map/csm/shader/shader_setup_cascades.js

@@ -1,20 +0,0 @@
-import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-fn main(){
-
-}
-    `
-)
-
-export const shader_setup_cascades = ComputeShader.from({
-    label: "CSM / Setup cascades",
-    resources,
-    body,
-});