@woosh/meep-engine 3.11.3 → 3.12.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/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,
-});