@woosh/meep-engine 3.40.0 → 3.42.0

package/src/engine/ecs/system/orderSystemsByDeclaredAccess.js

@@ -0,0 +1,282 @@
+import { noop } from "../../../core/function/noop.js";
+import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
+
+/**
+ * @typedef {import("../System.js").System} System
+ */
+
+const PASS_FIXED_UPDATE = 1;
+const PASS_UPDATE = 2;
+
+const WRITES = ResourceAccessKind.Write | ResourceAccessKind.Create;
+
+/**
+ * Which of the two passes over the execution order a system takes part in. `openFixedStep` and
+ * `closeFixedStep` are not counted: they frame a step rather than simulate in it, and run outside
+ * the derived order on purpose (see {@link System#openFixedStep}).
+ *
+ * @param {System} system
+ * @returns {number} bitmask of PASS_* flags
+ */
+function system_passes(system) {
+    let result = 0;
+
+    if (system.fixedUpdate !== noop) {
+        result |= PASS_FIXED_UPDATE;
+    }
+
+    if (system.update !== noop) {
+        result |= PASS_UPDATE;
+    }
+
+    return result;
+}
+
+/**
+ * @param {Map<Function, number[]>} map
+ * @param {Function} component
+ * @param {number} system_index
+ */
+function map_push(map, component, system_index) {
+    const list = map.get(component);
+
+    if (list === undefined) {
+        map.set(component, [system_index]);
+    } else {
+        list.push(system_index);
+    }
+}
+
+/**
+ * Groups the unplaced systems into their strongly connected components — a cycle, or one system on
+ * no cycle — and marks each component that an unplaced system outside it still feeds. A component
+ * nothing outside it feeds holds systems that wait on nothing but each other, if on anything.
+ *
+ * Kosaraju's: a post-order over the edges, then trees over the reversed edges in reverse post-order,
+ * one component per tree. Iterative, O(n²) over the adjacency matrix.
+ *
+ * @param {number} system_count
+ * @param {Uint8Array} edges `edges[a * system_count + b] !== 0`: `a` runs before `b`
+ * @param {Uint8Array} placed
+ * @param {Int32Array} component output: component id per unplaced system
+ * @param {Uint8Array} fed output: per component id, 1 when something outside it feeds it
+ * @param {Uint8Array} visited scratch
+ * @param {Int32Array} post_order scratch
+ * @param {Int32Array} frame_system scratch, the depth-first stack
+ * @param {Int32Array} frame_next scratch, per stack frame the next system to look at
+ */
+function label_components(
+    system_count, edges, placed,
+    component, fed,
+    visited, post_order, frame_system, frame_next
+) {
+    visited.fill(0);
+
+    let finished = 0;
+
+    for (let root = 0; root < system_count; root++) {
+        if (placed[root] !== 0 || visited[root] !== 0) {
+            continue;
+        }
+
+        visited[root] = 1;
+
+        let depth = 0;
+        frame_system[0] = root;
+        frame_next[0] = 0;
+
+        while (depth >= 0) {
+            const a = frame_system[depth];
+            let b = frame_next[depth];
+
+            while (b < system_count && (placed[b] !== 0 || visited[b] !== 0 || edges[a * system_count + b] === 0)) {
+                b++;
+            }
+
+            if (b < system_count) {
+                frame_next[depth] = b + 1;
+
+                visited[b] = 1;
+
+                depth++;
+                frame_system[depth] = b;
+                frame_next[depth] = 0;
+            } else {
+                post_order[finished++] = a;
+                depth--;
+            }
+        }
+    }
+
+    component.fill(-1);
+
+    let component_count = 0;
+
+    for (let k = finished - 1; k >= 0; k--) {
+        const root = post_order[k];
+
+        if (component[root] !== -1) {
+            continue;
+        }
+
+        component[root] = component_count;
+
+        // `frame_system` is free again, and serves as a plain stack
+        let top = 0;
+        frame_system[top++] = root;
+
+        while (top > 0) {
+            const b = frame_system[--top];
+
+            for (let a = 0; a < system_count; a++) {
+                if (placed[a] !== 0 || component[a] !== -1 || edges[a * system_count + b] === 0) {
+                    continue;
+                }
+
+                component[a] = component_count;
+                frame_system[top++] = a;
+            }
+        }
+
+        component_count++;
+    }
+
+    fed.fill(0, 0, component_count);
+
+    for (let a = 0; a < system_count; a++) {
+        if (placed[a] !== 0) {
+            continue;
+        }
+
+        for (let b = 0; b < system_count; b++) {
+            if (placed[b] === 0 && edges[a * system_count + b] !== 0 && component[a] !== component[b]) {
+                fed[component[b]] = 1;
+            }
+        }
+    }
+}
+
+/**
+ * Orders systems by what they declare they touch: a system that writes (or creates) a component
+ * runs before every other system that reads it, when the two run in the same pass.
+ *
+ * A pass is `fixedUpdate` or `update`. Every fixed step runs before the update pass whatever this
+ * order says, so a write in one pass and a read in the other orders nothing, and is not counted —
+ * counting it could only close a cycle out of edges that are each real. One order serves both
+ * passes, so a system in both carries its edges into both.
+ *
+ * Without a cycle the result is a topological order of those edges. Where they leave a choice, the
+ * system with the higher priority runs first, and of equal priorities the one earlier in `systems`.
+ *
+ * A cycle — two systems that both read and write one component is the common one — has no order
+ * that respects every edge. So the rule is stated over cycles: the next system to run is the
+ * highest priority (then earliest) of those that wait on nothing but their own cycle, and a system
+ * on no cycle that waits on nothing qualifies as its own. Running a member of a cycle drops its
+ * edges from the rest of that cycle and nothing else. A system that waits on a cycle from outside
+ * it never qualifies before the cycle has run, so the only edges dropped are edges on a cycle.
+ *
+ * A cycle and a system that waits on nothing compete on those same terms, so a cycle runs where
+ * its best member's priority puts it, never held back behind systems no edge relates to it. Where
+ * sorting by priority alone already respects every edge, the result is that sort; and the result
+ * depends on nothing but the declarations, the passes, the priorities and the order of `systems`.
+ *
+ * O(n²) per system placed, O(n³) in all; it runs when the set of running systems changes.
+ *
+ * @param {System[]} systems sorted in place, the first `system_count` of them
+ * @param {number} system_count
+ * @param {Float64Array|number[]} priorities one per system, in the order `systems` arrives in; higher runs earlier
+ */
+export function orderSystemsByDeclaredAccess(systems, system_count, priorities) {
+    const passes = new Uint8Array(system_count);
+
+    /** @type {Map<Function, number[]>} */
+    const writers = new Map();
+    /** @type {Map<Function, number[]>} */
+    const readers = new Map();
+
+    for (let i = 0; i < system_count; i++) {
+        const system = systems[i];
+
+        passes[i] = system_passes(system);
+
+        const components = system.referenced_components;
+        const component_count = components.length;
+
+        for (let j = 0; j < component_count; j++) {
+            const component = components[j];
+
+            const access = system.getAccessForComponent(component);
+
+            if ((access & WRITES) !== 0) {
+                map_push(writers, component, i);
+            }
+
+            if ((access & ResourceAccessKind.Read) !== 0) {
+                map_push(readers, component, i);
+            }
+        }
+    }
+
+    // edges[a * system_count + b] !== 0: a runs before b
+    const edges = new Uint8Array(system_count * system_count);
+
+    for (const [component, component_writers] of writers) {
+        const component_readers = readers.get(component);
+
+        if (component_readers === undefined) {
+            continue;
+        }
+
+        for (let i = 0; i < component_writers.length; i++) {
+            const writer = component_writers[i];
+
+            for (let j = 0; j < component_readers.length; j++) {
+                const reader = component_readers[j];
+
+                if (writer === reader || (passes[writer] & passes[reader]) === 0) {
+                    continue;
+                }
+
+                edges[writer * system_count + reader] = 1;
+            }
+        }
+    }
+
+    const placed = new Uint8Array(system_count);
+    const sorted = new Array(system_count);
+
+    const component = new Int32Array(system_count);
+    const fed = new Uint8Array(system_count);
+    const visited = new Uint8Array(system_count);
+    const post_order = new Int32Array(system_count);
+    const frame_system = new Int32Array(system_count);
+    const frame_next = new Int32Array(system_count);
+
+    for (let k = 0; k < system_count; k++) {
+        label_components(
+            system_count, edges, placed,
+            component, fed,
+            visited, post_order, frame_system, frame_next
+        );
+
+        // the components form an acyclic graph, so at least one of them is fed by nothing
+        let next = -1;
+
+        for (let i = 0; i < system_count; i++) {
+            if (placed[i] !== 0 || fed[component[i]] !== 0) {
+                continue;
+            }
+
+            if (next === -1 || priorities[i] > priorities[next]) {
+                next = i;
+            }
+        }
+
+        placed[next] = 1;
+        sorted[k] = systems[next];
+    }
+
+    for (let k = 0; k < system_count; k++) {
+        systems[k] = sorted[k];
+    }
+}

package/src/engine/ecs/terrain/ecs/cling/ClingToTerrainSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClingToTerrainSystem.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/cling/ClingToTerrainSystem.js"],"names":[],"mappings":"AA8MA;;;;;;;GAOG;AACH,wCANW,UAAU,aACV,OAAO,gBACP,MAAM,yCA4ChB;;uBA3PsB,wCAAwC;oBAE3C,qCAAqC;AAyCzD;;IAGI,6DAA6C;IAG7C,mHAGE;IAEF;;;OAGG;IACH,aAFU,MAAM,MAAM,CAAC,CAEG;IAE1B,YAAU;IAEV;;;OAGG;IACH,kBAFU,MAAM,CAEwB;IAExC;;;OAGG;IACH,sBAFW,MAAM,QAOhB;IAED;;;;;OAKG;IACH,YAHW,cAAc,aADd,WAAW,YAEX,MAAM,QAyBhB;IAED;;;;;OAKG;IACH,cAHW,cAAc,aADd,WAAW,YAEX,MAAM,QAgBhB;IAED,6BAiDC;CACJ;uBA9KsB,oBAAoB;4BACf,mCAAmC;2BAIpC,qBAAqB;4CANJ,0DAA0D;oBAIlF,eAAe;sBAbb,+CAA+C"}
+{"version":3,"file":"ClingToTerrainSystem.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/cling/ClingToTerrainSystem.js"],"names":[],"mappings":"AA+MA;;;;;;;GAOG;AACH,wCANW,UAAU,aACV,OAAO,gBACP,MAAM,yCA4ChB;;uBA5PsB,wCAAwC;oBAE3C,qCAAqC;AAyCzD;;IAGI,6DAA6C;IAG7C,mHAGE;IAEF;;;OAGG;IACH,aAFU,MAAM,MAAM,CAAC,CAEG;IAE1B,YAAU;IAEV;;;OAGG;IACH,kBAFU,MAAM,CAEwB;IAExC;;;OAGG;IACH,sBAFW,MAAM,QAOhB;IAED;;;;;OAKG;IACH,YAHW,cAAc,aADd,WAAW,YAEX,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,cAHW,cAAc,aADd,WAAW,YAEX,MAAM,QAgBhB;IAED,6BAiDC;CACJ;uBA/KsB,oBAAoB;4BACf,mCAAmC;2BAIpC,qBAAqB;4CANJ,0DAA0D;oBAIlF,eAAe;sBAbb,+CAA+C"}

package/src/engine/ecs/terrain/ecs/cling/ClingToTerrainSystem.js

@@ -103,7 +103,8 @@ class ClingToTerrainSystem extends System {
             transform,
             component: cling,
             ecd,
-            entity: entityId
+            entity: entityId,
+            hasProcessedSurface: false
         };
 
         ecd.addEntityEventListener(entityId, TRANSFORM64_EVENT_CHANGE, update);
@@ -368,7 +369,8 @@ function doCling(el, terrain, timeDelta) {
     t64_read_rotation(scratch_rotation, t);
 
     if (
-        cling.__lastPosition.roughlyEquals(scratch_position, 0.001)
+        el.hasProcessedSurface
+        && cling.__lastPosition.roughlyEquals(scratch_position, 0.001)
         && cling.__lastRotation.roughlyEquals(scratch_rotation, 0.0001)
     ) {
         //do nothing, cached position matches with existing position
@@ -385,6 +387,7 @@ function doCling(el, terrain, timeDelta) {
     }
 
     processRaycastHit(temp_sp.position, t, temp_sp.normal, cling, timeDelta, el);
+    el.hasProcessedSurface = true;
 
     // The pose now matches the terrain. If `processRaycastHit` moved anything it announced the
     // change, and that announcement re-queues the entity through the system's own listener; if it

package/src/engine/ecs/terrain/ecs/layers/TerrainLayers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainLayers.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayers.js"],"names":[],"mappings":"AAkGA;IACI;;;OAGG;IACH,QAFU,KAAK,YAAY,CAAC,CAER;IAEpB;;;OAGG;IACH,YAFU,OAAO,CAEgD;IAG7D;;;;;;;;OAQG;IACH,SAFU,cAAc,CAEuB;IAG/C;;;;;OAKG;IACH,QAFU,SAAS,CAEsB;IAG7C;;;;;;MAKC;IAED;;;aAGC;IAED;;;;OAIG;IACH,gCAHW,MAAM,iBACN,MAAM,QA6BhB;IAED;;;;OAIG;IACH,2GAyBC;IAED,sCAIC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACL,YAAY,CAIvB;IAED;;;;OAIG;IACH,oCAHW,uBAAuB,GACrB,MAAM,CAqBlB;IAED;;;;OAIG;IACH,kCAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,SAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,gBAHW,YAAY,GACV,MAAM,CAWlB;IAED;;;;OAIG;IACH,mBAHW,YAAY,GACX,OAAO,CAIlB;IAED;;;;;;OAMG;IACH,0CAqCC;IAED;;;OAGG;IACH,iCAFW,MAAM,QA6BhB;IAED,cAEC;IAGD,qBAuCC;CACJ;sCAhZY,OAAO,4DAA4D,EAAE,uBAAuB;;iBAjBxF,6CAA6C;6BAcjC,mBAAmB;oBAb5B,qCAAqC;+BAM1B,wDAAwD;0BAD7D,mDAAmD"}
+{"version":3,"file":"TerrainLayers.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayers.js"],"names":[],"mappings":"AAkGA;IACI;;;OAGG;IACH,QAFU,KAAK,YAAY,CAAC,CAER;IAEpB;;;OAGG;IACH,YAFU,OAAO,CAEgD;IAG7D;;;;;;;;OAQG;IACH,SAFU,cAAc,CAEuB;IAG/C;;;;;OAKG;IACH,QAFU,SAAS,CAEsB;IAG7C;;;;;;MAKC;IAED;;;aAGC;IAED;;;;OAIG;IACH,gCAHW,MAAM,iBACN,MAAM,QA6BhB;IAED;;;;OAIG;IACH,2GA4BC;IAED,sCAIC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACL,YAAY,CAIvB;IAED;;;;OAIG;IACH,oCAHW,uBAAuB,GACrB,MAAM,CAqBlB;IAED;;;;OAIG;IACH,kCAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,SAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,gBAHW,YAAY,GACV,MAAM,CAWlB;IAED;;;;OAIG;IACH,mBAHW,YAAY,GACX,OAAO,CAIlB;IAED;;;;;;OAMG;IACH,0CAqCC;IAED;;;OAGG;IACH,iCAFW,MAAM,QA6BhB;IAED,cAEC;IAGD,qBAuCC;CACJ;sCAnZY,OAAO,4DAA4D,EAAE,uBAAuB;;iBAjBxF,6CAA6C;6BAcjC,mBAAmB;oBAb5B,qCAAqC;+BAM1B,wDAAwD;0BAD7D,mDAAmD"}

package/src/engine/ecs/terrain/ecs/layers/TerrainLayers.js

@@ -196,6 +196,9 @@ export class TerrainLayers {
 
             promise.then(
                 () => {
+                    if (this.get(layerIndex) !== layer) {
+                        return;
+                    }
                     this.writeLayerDataIntoTexture(layerIndex);
                 },
                 (reason) => {

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SplatMapping.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/splat/SplatMapping.js"],"names":[],"mappings":"AAYA;;GAEG;AAGH;;GAEG;AACH;IACI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAGN;;;OAGG;IACH,MAFU,OAAO,CAEY;IAO7B;;;OAGG;IACH,SAFU,cAAc,CAEgC;IAG5D;;;;;;;MAQC;IAED;;;;;;;aA6BC;IAED;;;;;OAKG;IACH,8BAJW,SAAS,SACT,MAAM,YACN,MAAM,QAkDhB;IAED;;;;;OAKG;IACH,gCAJW,SAAS,SACT,MAAM,YACN,MAAM,QA2BhB;IAED;;;;;;;OAOG;IACH,wBANW,UAAU,gBACV,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,QA2ChB;IAED;;;;;;;OAOG;IACH,4BANW,UAAU,WACV,MAAM,WACN,MAAM,SACN,MAAM,UACN,MAAM,QAuChB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,iBACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,SAAS,CAcrB;IAED;;OAEG;IACH,iDAEC;IAED;;;OAGG;IACH,mDAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,gCAHW,UAAU,GACR,IAAI,CAmDhB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAgCnB;IAED;;;;OAIG;IACH,8BAHW,MAAM,SACN,MAAM,QAqBhB;IAED,uBAiBC;IAED;;;;;;OAMG;IACH,cALW,MAAM,UACN,MAAM,SACN,MAAM,cACN,OAAO,QAwDjB;CACJ;mBAngBY,OAAO,0CAA0C,EAAE,IAAI;oBAThD,qCAAqC;+BAM1B,wDAAwD;0BAD7D,mDAAmD"}
+{"version":3,"file":"SplatMapping.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/splat/SplatMapping.js"],"names":[],"mappings":"AAYA;;GAEG;AAGH;;GAEG;AACH;IACI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAGN;;;OAGG;IACH,MAFU,OAAO,CAEY;IAO7B;;;OAGG;IACH,SAFU,cAAc,CAEgC;IAG5D;;;;;;;MAQC;IAED;;;;;;;aA6BC;IAED;;;;;OAKG;IACH,8BAJW,SAAS,SACT,MAAM,YACN,MAAM,QAkDhB;IAED;;;;;OAKG;IACH,gCAJW,SAAS,SACT,MAAM,YACN,MAAM,QA2BhB;IAED;;;;;;;OAOG;IACH,wBANW,UAAU,gBACV,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,QA4ChB;IAED;;;;;;;OAOG;IACH,4BANW,UAAU,WACV,MAAM,WACN,MAAM,SACN,MAAM,UACN,MAAM,QAuChB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,iBACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,SAAS,CAcrB;IAED;;OAEG;IACH,iDAEC;IAED;;;OAGG;IACH,mDAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,gCAHW,UAAU,GACR,IAAI,CAmDhB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAgCnB;IAED;;;;OAIG;IACH,8BAHW,MAAM,SACN,MAAM,QAqBhB;IAED,uBAiBC;IAED;;;;;;OAMG;IACH,cALW,MAAM,UACN,MAAM,SACN,MAAM,cACN,OAAO,QAwDjB;CACJ;mBApgBY,OAAO,0CAA0C,EAAE,IAAI;oBAThD,qCAAqC;+BAM1B,wDAAwD;0BAD7D,mDAAmD"}

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.js

@@ -223,6 +223,7 @@ export class SplatMapping {
             }
 
         }
+        this.weights.invalidate();
     }
 
     /**

package/src/engine/ecs/terrain/overlay/TerrainOverlay.js

@@ -295,7 +295,7 @@ export class TerrainOverlay {
         const scaled_source = Sampler2D.uint8(4, dWidth, dHeight);
         sampler2d_scale(source, scaled_source);
 
-        sampler2d_paint(this, scaled_source, 0, 0, dx, dy, dWidth, dHeight);
+        sampler2d_paint(this.sampler, scaled_source, 0, 0, dx, dy, dWidth, dHeight);
 
     }
 }

package/src/engine/ecs/terrain/tiles/TerrainTile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainTile.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/tiles/TerrainTile.js"],"names":[],"mappings":";AAwBA;;GAEG;AACH;IACI,sBAA6B;IAC7B,eAA0B;IAC1B,cAAyB;IACzB,kBAAyB;IACzB,4BAAoC;IAUpC;;;;;;;;;;;OAWG;IACH,UAFU,YAAY,GAAC,IAAI,CAEX;IAEhB;;OAEG;IACH,SAFU,YAAY,GAAC,IAAI,CAEZ;IAEf;;OAEG;IACH,KAFU,YAAY,GAAC,IAAI,CAEhB;IAEX;;OAEG;IACH,SAFU,WAAW,GAAC,WAAW,GAAC,IAAI,CAEvB;IAEf;;;OAGG;IACH,WAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,cAFU,SAAS,CAEY;IAE/B;;;OAGG;IACH,KAFU,eAAe,CAEd;IAEX;;;OAGG;IACH,SAFU,OAAO,CAED;IAChB;;;OAGG;IACH,mBAFU,OAAO,CAES;IAC1B,uBAAmB;IAEnB;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,aAAuB;IACvB,oBAA2B;IAE3B;;;;OAIG;IACH,kBAWE;IAEF;;;;;OAKG;IACH,+BAAiG;IAEjG;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAUZ;;;OAGG;IACH,gCAGC;IAfD;;;OAGG;IACH,8BAEC;IAWD;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACL,OAAO,CA8ClB;IAED,+CAKC;IAED,8CAOC;IAED;;;;;;;;;;OAUG;IACH,mBATW,WAAW,GAAC,SAAS,UACrB,WAAW,GAAC,SAAS,QACrB,WAAW,GAAC,SAAS,SACrB,WAAW,GAAC,SAAS,WACrB,WAAW,GAAC,SAAS,YACrB,WAAW,GAAC,SAAS,cACrB,WAAW,GAAC,SAAS,eACrB,WAAW,GAAC,SAAS,QA4M/B;IAED,2BAoDC;IAED;;;;OAIG;IACH,mCAHW,MAAM,cACN,MAAM,QAIhB;IAED,gBAoBC;IA6BD;;;;;OAKG;IACH,gBAFW;QAAC,QAAQ,EAAE;YAAC,QAAQ,EAAE,YAAY,CAAC;YAAC,OAAO,EAAE,YAAY,CAAC;YAAC,GAAG,EAAE,YAAY,CAAC;YAAC,OAAO,EAAE,WAAW,GAAC,WAAW,CAAA;SAAC,CAAC;QAAC,GAAG,CAAC,EAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,IAAI,EAAC,WAAW,CAAA;SAAC,CAAA;KAAC,QA0BtK;;CACJ;oBA7kBmB,kCAAkC;4BAG1B,2CAA2C;0BAZ7C,yCAAyC;gCADnC,mDAAmD;mBAGhE,0CAA0C;8BAM/B,2CAA2C"}
+{"version":3,"file":"TerrainTile.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/tiles/TerrainTile.js"],"names":[],"mappings":";AAwBA;;GAEG;AACH;IACI,sBAA6B;IAC7B,eAA0B;IAC1B,cAAyB;IACzB,kBAAyB;IACzB,4BAAoC;IAUpC;;;;;;;;;;;OAWG;IACH,UAFU,YAAY,GAAC,IAAI,CAEX;IAEhB;;OAEG;IACH,SAFU,YAAY,GAAC,IAAI,CAEZ;IAEf;;OAEG;IACH,KAFU,YAAY,GAAC,IAAI,CAEhB;IAEX;;OAEG;IACH,SAFU,WAAW,GAAC,WAAW,GAAC,IAAI,CAEvB;IAEf;;;OAGG;IACH,WAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,cAFU,SAAS,CAEY;IAE/B;;;OAGG;IACH,KAFU,eAAe,CAEd;IAEX;;;OAGG;IACH,SAFU,OAAO,CAED;IAChB;;;OAGG;IACH,mBAFU,OAAO,CAES;IAC1B,uBAAmB;IAEnB;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,aAAuB;IACvB,oBAA2B;IAE3B;;;;OAIG;IACH,kBAWE;IAEF;;;;;OAKG;IACH,+BAAiG;IAEjG;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAUZ;;;OAGG;IACH,gCAGC;IAfD;;;OAGG;IACH,8BAEC;IAWD;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACL,OAAO,CA0DlB;IAED,+CAKC;IAED,8CAOC;IAED;;;;;;;;;;OAUG;IACH,mBATW,WAAW,GAAC,SAAS,UACrB,WAAW,GAAC,SAAS,QACrB,WAAW,GAAC,SAAS,SACrB,WAAW,GAAC,SAAS,WACrB,WAAW,GAAC,SAAS,YACrB,WAAW,GAAC,SAAS,cACrB,WAAW,GAAC,SAAS,eACrB,WAAW,GAAC,SAAS,QA4M/B;IAED,2BAoDC;IAED;;;;OAIG;IACH,mCAHW,MAAM,cACN,MAAM,QAIhB;IAED,gBAoBC;IA6BD;;;;;OAKG;IACH,gBAFW;QAAC,QAAQ,EAAE;YAAC,QAAQ,EAAE,YAAY,CAAC;YAAC,OAAO,EAAE,YAAY,CAAC;YAAC,GAAG,EAAE,YAAY,CAAC;YAAC,OAAO,EAAE,WAAW,GAAC,WAAW,CAAA;SAAC,CAAC;QAAC,GAAG,CAAC,EAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,IAAI,EAAC,WAAW,CAAA;SAAC,CAAA;KAAC,QA0BtK;;CACJ;oBAzlBmB,kCAAkC;4BAG1B,2CAA2C;0BAZ7C,yCAAyC;gCADnC,mDAAmD;mBAGhE,0CAA0C;8BAM/B,2CAA2C"}

package/src/engine/ecs/terrain/tiles/TerrainTile.js

@@ -215,7 +215,19 @@ class TerrainTile {
         );
 
         if (hit_found) {
-            result.applyMatrix4(m4);
+            result.position.applyMatrix4(m4);
+
+            // Normals use the inverse transpose; the ray already computed this inverse.
+            const normal = result.normal;
+            const normal_x = normal.x;
+            const normal_y = normal.y;
+            const normal_z = normal.z;
+
+            normal.set(
+                m4_tmp[0] * normal_x + m4_tmp[1] * normal_y + m4_tmp[2] * normal_z,
+                m4_tmp[4] * normal_x + m4_tmp[5] * normal_y + m4_tmp[6] * normal_z,
+                m4_tmp[8] * normal_x + m4_tmp[9] * normal_y + m4_tmp[10] * normal_z
+            );
 
             // make sure to pull normal to magnitude of 1
             result.normal.normalize();

package/src/engine/ecs/terrain/tiles/TerrainTileManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainTileManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/tiles/TerrainTileManager.js"],"names":[],"mappings":";0BAoBa,OAAO,gDAAgD,EAAE,OAAO;AA4B7E;IA2FI;;;;;;;OAOG;IACH;QAFgC,WAAW,EAAhC,WAAW;OAYrB;IA5GD;;;OAGG;IACH,OAFU,WAAW,EAAE,CAEZ;IAEX;;;MAGE;IAEF;;;;;;;;;;OAUG;IACH,aAFU,OAAO,CAEiB;IAElC;;;;;;;;;;;;OAYG;IACH,oBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,WAFU,OAAO,CAEa;IAC9B;;;OAGG;IACH,YAFU,eAAe,CAEW;IAEpC;;;OAGG;IACH,OAFU,OAAO,CAES;IAG1B;;;;OAIG;IACH,oBAAmC;IAEnC;;;OAGG;IACH,cAFU,GAAG,CAEG;IAEhB;;;OAGG;IACH,aAFU,eAAe,CAEe;IAExC;;;;;;;;;;;OAWG;IACH,eAFU,MAAM,CAEG;IAef;;;OAGG;IACH,aAFU,WAAW,CAES;IAGlC,gCAWC;IAED,8BAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,0BAFW,MAAM,QAuBhB;IAED;;;;OAIG;IACH,2BAHW,MAAM,cACN,MAAM,QAiChB;IAED,mBAIC;IAED;;;;OAIG;IACH,mBAHW,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,uBAYrC;IAED,qBAqBC;IAED;;OAEG;IACH,gBAIC;IAED;;;;;;OAMG;IACH,qBALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAuBhB;IAGD;;;;;;;OAOG;IACH,oCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,WAAW,EAAE,CAgCzB;IAED,wBA0CC;IAED;;;;;OAKG;IACH,oBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;;;;;;;;;;OAcG;IACH,wBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;;;OAMG;IACH,wBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,WAAW,GAAC,SAAS,CAiBjC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,GACJ,WAAW,CAavB;IAED;;;;;OAKG;IACH,4BAJW,MAAM,KACN,MAAM,GACL,WAAW,GAAC,SAAS,CAoBhC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,KACN,MAAM,GACJ,QAAQ,WAAW,CAAC,CAYhC;IAED;;;;;;OAMG;IACH,UALW,MAAM,KACN,MAAM,GACJ,QAAQ,WAAW,CAAC,CA4BhC;IAED;;;OAGG;IACH,cAFW,WAAW,QAcrB;IAED,gBAMC;IAED;;;;;;OAMG;IACH,cAJW,MAAM,KACN,MAAM,QACN,WAAW,QAUrB;IAED;;;;;;;;;;;;OAYG;IACH,yBAJW,MAAM,KACN,MAAM;YACG,MAAM,GAAC,WAAW,GAAC,SAAS;MAkD/C;IAED;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,OAAO,CAuDnB;IAED;;;;;;OAMG;IACH,kCALW,aAAa,KACb,MAAM,KACN,MAAM,GACL,OAAO,CAOlB;IAED;;;;;;OAMG;IACH,SALW,MAAM,KACN,MAAM,WACN,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,UAC3B,CAAC,MAAM,KAAG,KAAK,IAAI,QAiG7B;CACJ;wBA72BuB,kBAAkB;mBATvB,0CAA0C;oBAGzC,kCAAkC;4BAI1B,2CAA2C;oBAVnD,mCAAmC;gCAOvB,mDAAmD;8BAFrD,2CAA2C"}
+{"version":3,"file":"TerrainTileManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/tiles/TerrainTileManager.js"],"names":[],"mappings":";0BAoBa,OAAO,gDAAgD,EAAE,OAAO;AA4B7E;IA2FI;;;;;;;OAOG;IACH;QAFgC,WAAW,EAAhC,WAAW;OAYrB;IA5GD;;;OAGG;IACH,OAFU,WAAW,EAAE,CAEZ;IAEX;;;MAGE;IAEF;;;;;;;;;;OAUG;IACH,aAFU,OAAO,CAEiB;IAElC;;;;;;;;;;;;OAYG;IACH,oBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,WAFU,OAAO,CAEa;IAC9B;;;OAGG;IACH,YAFU,eAAe,CAEW;IAEpC;;;OAGG;IACH,OAFU,OAAO,CAES;IAG1B;;;;OAIG;IACH,oBAAmC;IAEnC;;;OAGG;IACH,cAFU,GAAG,CAEG;IAEhB;;;OAGG;IACH,aAFU,eAAe,CAEe;IAExC;;;;;;;;;;;OAWG;IACH,eAFU,MAAM,CAEG;IAef;;;OAGG;IACH,aAFU,WAAW,CAES;IAGlC,gCAWC;IAED,8BAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,0BAFW,MAAM,QAuBhB;IAED;;;;OAIG;IACH,2BAHW,MAAM,cACN,MAAM,QAiChB;IAED,mBAIC;IAED;;;;OAIG;IACH,mBAHW,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,uBAYrC;IAED,qBAqBC;IAED;;OAEG;IACH,gBAIC;IAED;;;;;;OAMG;IACH,qBALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAuBhB;IAGD;;;;;;;OAOG;IACH,oCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,WAAW,EAAE,CAgCzB;IAED,wBA0CC;IAED;;;;;OAKG;IACH,oBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;;;;;;;;;;OAcG;IACH,wBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;;;OAMG;IACH,wBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,WAAW,GAAC,SAAS,CAkBjC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,GACJ,WAAW,CAavB;IAED;;;;;OAKG;IACH,4BAJW,MAAM,KACN,MAAM,GACL,WAAW,GAAC,SAAS,CAoBhC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,KACN,MAAM,GACJ,QAAQ,WAAW,CAAC,CAYhC;IAED;;;;;;OAMG;IACH,UALW,MAAM,KACN,MAAM,GACJ,QAAQ,WAAW,CAAC,CA4BhC;IAED;;;OAGG;IACH,cAFW,WAAW,QAcrB;IAED,gBAMC;IAED;;;;;;OAMG;IACH,cAJW,MAAM,KACN,MAAM,QACN,WAAW,QAUrB;IAED;;;;;;;;;;;;OAYG;IACH,yBAJW,MAAM,KACN,MAAM;YACG,MAAM,GAAC,WAAW,GAAC,SAAS;MAkD/C;IAED;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,OAAO,CAuDnB;IAED;;;;;;OAMG;IACH,kCALW,aAAa,KACb,MAAM,KACN,MAAM,GACL,OAAO,CAOlB;IAED;;;;;;OAMG;IACH,SALW,MAAM,KACN,MAAM,WACN,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,UAC3B,CAAC,MAAM,KAAG,KAAK,IAAI,QAiG7B;CACJ;wBA92BuB,kBAAkB;mBATvB,0CAA0C;oBAGzC,kCAAkC;4BAI1B,2CAA2C;oBAVnD,mCAAmC;gCAOvB,mDAAmD;8BAFrD,2CAA2C"}

package/src/engine/ecs/terrain/tiles/TerrainTileManager.js

@@ -494,6 +494,7 @@ class TerrainTileManager {
             x < 0
             || x >= this.gridWidth
             || y < 0
+            || y >= this.gridHeight
         ) {
             return undefined;
         }