@woosh/meep-engine 2.133.3 → 2.134.0

package/src/core/geom/3d/topology/struct/binary/io/edge/bt_mesh_fuse_duplicate_edges.js

@@ -0,0 +1,83 @@
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_disk_edge_remove } from "../bt_disk_edge_remove.js";
+import { bt_radial_loop_add } from "../bt_radial_loop_add.js";
+import { bt_radial_loop_remove } from "../bt_radial_loop_remove.js";
+import { bt_kill_only_edge } from "./bt_kill_only_edge.js";
+
+/**
+ * Walk the mesh and fuse any pair of edges that share the same endpoint pair into a single edge.
+ *
+ * When two edges connect the same vertices, all loops on the victim are moved into the master's
+ * radial cycle, the victim is removed from both endpoint disk cycles, and the victim edge is
+ * deallocated. This restores the topology invariant that a vertex pair is represented by at most
+ * one edge — which is what loop/face neighbour queries rely on.
+ *
+ * Degenerate edges (v1 === v2) are left alone; callers that want those removed should run a
+ * dedicated pass.
+ *
+ * Typically used after {@link bt_merge_verts_by_distance}, which re-points vertex references but
+ * can leave behind multiple edges sharing the same endpoint pair.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {number} number of edges fused away
+ */
+export function bt_mesh_fuse_duplicate_edges(mesh) {
+    const edges = mesh.edges;
+    const edge_count = edges.size;
+
+    let removed_count = 0;
+
+    for (let master = 0; master < edge_count; master++) {
+        if (edges.is_allocated(master) === false) {
+            continue;
+        }
+
+        const master_v1 = mesh.edge_read_vertex1(master);
+        const master_v2 = mesh.edge_read_vertex2(master);
+
+        if (master_v1 === master_v2) {
+            // degenerate edge; skip
+            continue;
+        }
+
+        // walk master_v1's disk cycle, fusing any edge that also connects to master_v2
+        let curr = mesh.edge_read_v1_disk_next(master);
+
+        while (curr !== master) {
+
+            const curr_v1 = mesh.edge_read_vertex1(curr);
+            const curr_v2 = mesh.edge_read_vertex2(curr);
+
+            const curr_on_v1 = curr_v1 === master_v1;
+
+            // capture next before we potentially splice curr out of the disk cycle
+            const next = curr_on_v1
+                ? mesh.edge_read_v1_disk_next(curr)
+                : mesh.edge_read_v2_disk_next(curr);
+
+            const other_endpoint = curr_on_v1 ? curr_v2 : curr_v1;
+
+            if (other_endpoint === master_v2) {
+
+                // move every loop on curr into master's radial cycle
+                let l = mesh.edge_read_loop(curr);
+                while (l !== NULL_POINTER) {
+                    bt_radial_loop_remove(mesh, l, curr);
+                    bt_radial_loop_add(mesh, l, master);
+                    l = mesh.edge_read_loop(curr);
+                }
+
+                bt_disk_edge_remove(mesh, curr, master_v1);
+                bt_disk_edge_remove(mesh, curr, master_v2);
+
+                bt_kill_only_edge(mesh, curr);
+
+                removed_count++;
+            }
+
+            curr = next;
+        }
+    }
+
+    return removed_count;
+}

package/src/core/geom/3d/topology/struct/binary/io/vertex/bt_vert_fuse_duplicate_edges.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Localized counterpart to {@link bt_mesh_fuse_duplicate_edges} that inspects only
+ * `v`'s disk cycle. Any two edges in that cycle sharing the same other endpoint
+ * are fused: loops move from the victim to the master, the victim is untangled
+ * from both endpoint disk cycles, and its memory is released.
+ *
+ * If transferring a loop would leave the master edge with two loops on the same
+ * face (i.e. the face has collapsed to a degenerate two-edge polygon), that face
+ * is killed as well.
+ *
+ * Self-loops on `v` are left alone; the caller should handle them separately.
+ *
+ * Typical use: after an iterative edit that may have produced link-vertex
+ * duplicates around `v`, run this to restore the one-edge-per-vertex-pair
+ * invariant without the cost of a whole-mesh pass.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v
+ * @returns {number} Number of faces killed as a side effect.
+ */
+export function bt_vert_fuse_duplicate_edges(mesh: BinaryTopology, v: number): number;
+//# sourceMappingURL=bt_vert_fuse_duplicate_edges.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/vertex/bt_vert_fuse_duplicate_edges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_vert_fuse_duplicate_edges.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_vert_fuse_duplicate_edges.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,sEAHW,MAAM,GACJ,MAAM,CAyHlB"}

package/src/core/geom/3d/topology/struct/binary/io/vertex/bt_vert_fuse_duplicate_edges.js

@@ -0,0 +1,148 @@
+import { assert } from "../../../../../../../assert.js";
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_disk_edge_remove } from "../bt_disk_edge_remove.js";
+import { bt_loop_kill } from "../bt_loop_kill.js";
+import { bt_radial_loop_add } from "../bt_radial_loop_add.js";
+import { bt_radial_loop_remove } from "../bt_radial_loop_remove.js";
+import { bt_kill_only_edge } from "../edge/bt_kill_only_edge.js";
+
+/**
+ * Localized counterpart to {@link bt_mesh_fuse_duplicate_edges} that inspects only
+ * `v`'s disk cycle. Any two edges in that cycle sharing the same other endpoint
+ * are fused: loops move from the victim to the master, the victim is untangled
+ * from both endpoint disk cycles, and its memory is released.
+ *
+ * If transferring a loop would leave the master edge with two loops on the same
+ * face (i.e. the face has collapsed to a degenerate two-edge polygon), that face
+ * is killed as well.
+ *
+ * Self-loops on `v` are left alone; the caller should handle them separately.
+ *
+ * Typical use: after an iterative edit that may have produced link-vertex
+ * duplicates around `v`, run this to restore the one-edge-per-vertex-pair
+ * invariant without the cost of a whole-mesh pass.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v
+ * @returns {number} Number of faces killed as a side effect.
+ */
+export function bt_vert_fuse_duplicate_edges(mesh, v) {
+    assert.defined(mesh, 'mesh');
+    assert.notNull(mesh, 'mesh');
+    assert.isNonNegativeInteger(v, 'v');
+
+    const edge_pool = mesh.edges;
+
+    const start_e = mesh.vertex_read_edge(v);
+
+    if (start_e === NULL_POINTER) {
+        return 0;
+    }
+
+    // Snapshot v's disk cycle up front so that later fusion operations, which
+    // mutate that cycle, don't invalidate our traversal cursor.
+    const edges_in_disk = [];
+    let curr_e = start_e;
+
+    do {
+        edges_in_disk.push(curr_e);
+
+        if (mesh.edge_read_vertex1(curr_e) === v) {
+            curr_e = mesh.edge_read_v1_disk_next(curr_e);
+        } else {
+            curr_e = mesh.edge_read_v2_disk_next(curr_e);
+        }
+    } while (curr_e !== start_e && curr_e !== NULL_POINTER);
+
+    // Group edges by other endpoint to detect duplicates in a single pass.
+    const master_by_other = new Map();
+    const fusion_masters = [];
+    const fusion_victims = [];
+    const fusion_others = [];
+
+    for (let i = 0; i < edges_in_disk.length; i++) {
+        const e = edges_in_disk[i];
+
+        if (!edge_pool.is_allocated(e)) {
+            continue;
+        }
+
+        const v1 = mesh.edge_read_vertex1(e);
+        const v2 = mesh.edge_read_vertex2(e);
+        const other = v1 === v ? v2 : v1;
+
+        if (other === v) {
+            // Self-loop; not our concern here.
+            continue;
+        }
+
+        if (master_by_other.has(other)) {
+            fusion_masters.push(master_by_other.get(other));
+            fusion_victims.push(e);
+            fusion_others.push(other);
+        } else {
+            master_by_other.set(other, e);
+        }
+    }
+
+    const face_pool = mesh.faces;
+
+    let faces_killed = 0;
+
+    for (let i = 0; i < fusion_masters.length; i++) {
+        const master = fusion_masters[i];
+        const victim = fusion_victims[i];
+        const other = fusion_others[i];
+
+        if (!edge_pool.is_allocated(victim) || !edge_pool.is_allocated(master)) {
+            continue;
+        }
+
+        let l = mesh.edge_read_loop(victim);
+
+        while (l !== NULL_POINTER) {
+            bt_radial_loop_remove(mesh, l, victim);
+
+            const face = mesh.loop_read_face(l);
+            let collapse_face = false;
+
+            if (face !== NULL_POINTER && face_pool.is_allocated(face)) {
+                // If master already has a loop on the same face, transferring
+                // this loop would give that face two coincident edges -- a
+                // degenerate polygon that has to die.
+                let mast_l = mesh.edge_read_loop(master);
+                if (mast_l !== NULL_POINTER) {
+                    const mast_start = mast_l;
+                    do {
+                        if (mesh.loop_read_face(mast_l) === face) {
+                            collapse_face = true;
+                            break;
+                        }
+                        mast_l = mesh.loop_read_radial_next(mast_l);
+                    } while (mast_l !== mast_start && mast_l !== NULL_POINTER);
+                }
+            }
+
+            bt_radial_loop_add(mesh, l, master);
+
+            if (collapse_face) {
+                const face_to_kill = face;
+                let fl = mesh.face_read_loop(face_to_kill);
+                while (fl !== NULL_POINTER) {
+                    bt_loop_kill(mesh, fl);
+                    fl = mesh.face_read_loop(face_to_kill);
+                }
+                face_pool.release(face_to_kill);
+                faces_killed++;
+            }
+
+            l = mesh.edge_read_loop(victim);
+        }
+
+        bt_disk_edge_remove(mesh, victim, v);
+        bt_disk_edge_remove(mesh, victim, other);
+        bt_kill_only_edge(mesh, victim);
+    }
+
+    return faces_killed;
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_face_get_incenter.js

@@ -64,11 +64,11 @@ export function bt_face_get_incenter(
 
     do {
         const vertex_id = mesh.loop_read_vertex(current_loop_id);
-        mesh.vertex_read_coordinate(scratch_coord, 0, vertex_id);
+        mesh.vertex_read_coordinate(scratch_coords, 0, vertex_id);
 
-        sum_x += scratch_coord[0];
-        sum_y += scratch_coord[1];
-        sum_z += scratch_coord[2];
+        sum_x += scratch_coords[0];
+        sum_y += scratch_coords[1];
+        sum_z += scratch_coords[2];
 
         vertex_count++;
         current_loop_id = mesh.loop_read_next(current_loop_id);

package/src/core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Find the loop in `face_a` whose edge is shared with `face_b`.
+ *
+ * The returned loop belongs to `face_a` and its edge is also used by a loop in `face_b`.
+ * Combined with {@link BinaryTopology#loop_read_vertex} and {@link BinaryTopology#loop_read_next},
+ * this is enough to read the two vertices of the shared edge in `face_a`'s winding order,
+ * which is useful for constructing directed portals.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face_a
+ * @param {number} face_b
+ * @returns {number} loop ID in `face_a` that shares an edge with `face_b`, or {@link NULL_POINTER} if no shared edge exists
+ */
+export function bt_faces_shared_loop(mesh: BinaryTopology, face_a: number, face_b: number): number;
+//# sourceMappingURL=bt_faces_shared_loop.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_faces_shared_loop.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,mEAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAiClB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.js

@@ -0,0 +1,48 @@
+import { assert } from "../../../../../../assert.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * Find the loop in `face_a` whose edge is shared with `face_b`.
+ *
+ * The returned loop belongs to `face_a` and its edge is also used by a loop in `face_b`.
+ * Combined with {@link BinaryTopology#loop_read_vertex} and {@link BinaryTopology#loop_read_next},
+ * this is enough to read the two vertices of the shared edge in `face_a`'s winding order,
+ * which is useful for constructing directed portals.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face_a
+ * @param {number} face_b
+ * @returns {number} loop ID in `face_a` that shares an edge with `face_b`, or {@link NULL_POINTER} if no shared edge exists
+ */
+export function bt_faces_shared_loop(mesh, face_a, face_b) {
+    assert.defined(mesh, "mesh");
+    assert.notNull(mesh, "mesh");
+    assert.equal(mesh.isBinaryTopology, true, "mesh.isBinaryTopology !== true");
+    assert.isNonNegativeInteger(face_a, "face_a");
+    assert.isNonNegativeInteger(face_b, "face_b");
+
+    const start_loop = mesh.face_read_loop(face_a);
+
+    if (start_loop === NULL_POINTER) {
+        return NULL_POINTER;
+    }
+
+    let current_loop = start_loop;
+
+    do {
+        // walk the radial cycle around the edge of this loop
+        let radial_loop = mesh.loop_read_radial_next(current_loop);
+
+        while (radial_loop !== current_loop) {
+            if (mesh.loop_read_face(radial_loop) === face_b) {
+                return current_loop;
+            }
+
+            radial_loop = mesh.loop_read_radial_next(radial_loop);
+        }
+
+        current_loop = mesh.loop_read_next(current_loop);
+    } while (current_loop !== start_loop);
+
+    return NULL_POINTER;
+}

package/src/engine/ecs/terrain/ecs/Terrain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Terrain.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/Terrain.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Terrain.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/Terrain.js"],"names":[],"mappings":"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"}

package/src/engine/ecs/terrain/ecs/Terrain.js

@@ -586,7 +586,12 @@ class Terrain {
 
         uniforms.splatWeightMap.value = this.splat.weightTexture;
 
-        uniforms.splatLayerCount.value = this.layers.count();
+        // Update layer count as a compile-time define (AMD GLSL 300 ES requires constant loop bounds)
+        const layerCount = this.layers.count();
+        if (m.defines.SPLAT_LAYER_COUNT !== layerCount) {
+            m.defines.SPLAT_LAYER_COUNT = layerCount;
+            m.needsUpdate = true;
+        }
 
         uniforms.materialScalesMap.value = this.layers.scalesTexture;
 

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

@@ -1 +1 @@
-{"version":3,"file":"TerrainLayer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayer.js"],"names":[],"mappings":"AA2BA;IA+CI;;;;;OAKG;IACH,iBAJW,MAAM,SACN,MAAM,UACN,MAAM,gBAShB;IAED;;;;OAIG;IACH,oDAFa,YAAY,CAQxB;IAvED;;;OAGG;IACH,0BAAuB;IAEvB;;;OAGG;IACH,SAFU,SAAS,CAEgB;IAEnC;;;OAGG;IACH,MAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,WAAW;IAEX;;;OAGG;IACH,WAFU,MAAM,CAES;IAGzB;;;;;;;MAMC;IAED;;;;aAIC;IA8BD;;;;OAIG;IACH,0DAwDC;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CANpC;0BA9JyB,mDAAmD;oBAJzD,qCAAqC;mBADtC,6CAA6C"}
+{"version":3,"file":"TerrainLayer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayer.js"],"names":[],"mappings":"AA2BA;IA+CI;;;;;OAKG;IACH,iBAJW,MAAM,SACN,MAAM,UACN,MAAM,gBAShB;IAED;;;;OAIG;IACH,oDAFa,YAAY,CAQxB;IAvED;;;OAGG;IACH,0BAAuB;IAEvB;;;OAGG;IACH,SAFU,SAAS,CAEgB;IAEnC;;;OAGG;IACH,MAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,WAAW;IAEX;;;OAGG;IACH,WAFU,MAAM,CAES;IAGzB;;;;;;;MAMC;IAED;;;;aAIC;IA8BD;;;;OAIG;IACH,0DAyDC;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CANpC;0BA/JyB,mDAAmD;oBAJzD,qCAAqC;mBADtC,6CAA6C"}

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

@@ -5,7 +5,7 @@ import { computeStringHash } from "../../../../../core/primitives/strings/comput
 import { string_compute_byte_size } from "../../../../../core/primitives/strings/string_compute_byte_size.js";
 import { GameAssetType } from "../../../../asset/GameAssetType.js";
 import { Sampler2D } from "../../../../graphics/texture/sampler/Sampler2D.js";
-import { sampler2d_transfer_data } from "../../../../graphics/texture/sampler/sampler2d_transfer_data.js";
+import { sampler2d_ensure_uint8_RGBA } from "../../../../graphics/texture/sampler/sampler2d_ensure_uint8_RGBA.js";
 
 /**
  *
@@ -37,7 +37,7 @@ export class TerrainLayer {
      *
      * @type {Sampler2D}
      */
-    diffuse = Sampler2D.uint8(3, 1, 1);
+    diffuse = Sampler2D.uint8(4, 1, 1);
 
     /**
      *
@@ -135,21 +135,22 @@ export class TerrainLayer {
             .then(assert => {
                 const image = assert.create();
 
+                const source_data = image.data;
                 const source_item_size = image.itemSize;
 
-                const source_data = image.data;
+                // RGBA (4 channels) for AMD GPU compatibility
+                const destination_item_size = 4;
+
+                const source = new Sampler2D(source_data, source_item_size, image.width, image.height);
 
-                // RGB
-                const destination_item_size = 3;
+                // Convert to uint8 RGBA, handling any source format
+                const rgba = sampler2d_ensure_uint8_RGBA(source);
 
                 if (this.diffuse === null || this.diffuse.width !== image.width || this.diffuse.height !== image.height) {
-                    // loaded image does not match the side of the layer
                     this.diffuse = Sampler2D.uint8(destination_item_size, image.width, image.height);
                 }
 
-                const source = new Sampler2D(source_data, source_item_size, image.width, image.height);
-
-                sampler2d_transfer_data(source, this.diffuse);
+                this.diffuse.data.set(rgba.data);
 
                 this.onChanged.send0();
 

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":"AA6EA;IAGQ;;;OAGG;IACH,QAFU,KAAK,YAAY,CAAC,CAEJ;IAExB;;;OAGG;IACH,YAFU,OAAO,CAEoD;IAMrE;;;OAGG;IACH,SAFU,kBAAkB,CAE8B;IAiB1D,2BAAsF;IAc1F;;;;;;MAKC;IAED;;;aAGC;IAED;;;;OAIG;IACH,gCAHW,MAAM,iBACN,MAAM,QAuChB;IAED;;;;OAIG;IACH,0DAyBC;IAED,sCAIC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACL,YAAY,CAIvB;IAED;;;;OAIG;IACH,8DAFa,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,0CA8BC;IAED;;;OAGG;IACH,iCAFW,MAAM,QAgChB;IAED,gBAGC;IAED,cAEC;IAGD,qBAsCC;CACJ;iBA5ZgB,6CAA6C;6BAQjC,mBAAmB;oBAP5B,qCAAqC;mCALlD,OAAO;4BAAP,OAAO"}
+{"version":3,"file":"TerrainLayers.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayers.js"],"names":[],"mappings":"AA8EA;IAGQ;;;OAGG;IACH,QAFU,KAAK,YAAY,CAAC,CAEJ;IAExB;;;OAGG;IACH,YAFU,OAAO,CAEoD;IAMrE;;;OAGG;IACH,SAFU,kBAAkB,CAE8B;IAiB1D,2BAAsF;IAc1F;;;;;;MAKC;IAED;;;aAGC;IAED;;;;OAIG;IACH,gCAHW,MAAM,iBACN,MAAM,QAuChB;IAED;;;;OAIG;IACH,0DAyBC;IAED,sCAIC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACL,YAAY,CAIvB;IAED;;;;OAIG;IACH,8DAFa,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,0CAgCC;IAED;;;OAGG;IACH,iCAFW,MAAM,QAgChB;IAED,gBAGC;IAED,cAEC;IAGD,qBAsCC;CACJ;iBA9ZgB,6CAA6C;6BAQjC,mBAAmB;oBAP5B,qCAAqC;mCALlD,OAAO;4BAAP,OAAO"}

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

@@ -8,6 +8,7 @@ import {
     LinearMipMapLinearFilter,
     NearestFilter,
     RepeatWrapping,
+    RGBAFormat,
     RGFormat,
     UnsignedByteType
 } from "three";
@@ -19,9 +20,9 @@ import Vector2 from "../../../../../core/geom/Vector2.js";
 import { invokeObjectEquals } from "../../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../../core/model/object/invokeObjectHash.js";
 import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
-import { GL_RGBFormat } from "../../../../graphics/texture/GL_RGBFormat.js";
 import { sampler2d_scale } from "../../../../graphics/texture/sampler/resize/sampler2d_scale.js";
 import { Sampler2D } from "../../../../graphics/texture/sampler/Sampler2D.js";
+import { sampler2d_ensure_uint8_RGBA } from "../../../../graphics/texture/sampler/sampler2d_ensure_uint8_RGBA.js";
 import { TerrainLayer } from "./TerrainLayer.js";
 
 class ScaledTextureKey {
@@ -91,7 +92,7 @@ export class TerrainLayers {
         this.resolution = new Vector2(DEFAULT_RESOLUTION, DEFAULT_RESOLUTION);
 
 
-        const layer_data = new Uint8Array(3);
+        const layer_data = new Uint8Array(4);
         layer_data.fill(255); //pre-fill with white
 
         /**
@@ -99,7 +100,7 @@ export class TerrainLayers {
          * @type {DataTexture2DArray}
          */
         this.texture = new DataTexture2DArray(layer_data, 1, 1, 1);
-        this.texture.format = GL_RGBFormat;
+        this.texture.format = RGBAFormat;
         this.texture.type = UnsignedByteType;
 
         this.texture.wrapS = RepeatWrapping;
@@ -112,7 +113,7 @@ export class TerrainLayers {
 
         this.texture.generateMipmaps = true;
         this.texture.encoding = LinearEncoding;
-        this.texture.internalFormat = 'RGB8';
+        this.texture.internalFormat = 'RGBA8';
         this.texture.needsUpdate = true;
 
         this.scalesTexture = new DataTexture(new Float32Array(64), 32, 1, RGFormat, FloatType);
@@ -312,7 +313,7 @@ export class TerrainLayers {
     __obtain_layer_data_at_resolution(layer, resolution) {
         const layerSampler = layer.diffuse;
 
-        assert.equal(layerSampler.itemSize, 3, 'layer sampler must have 3 channels');
+        assert.equal(layerSampler.itemSize, 4, 'layer sampler must have 4 channels');
 
         const resolution_x = resolution.x;
         const resolution_y = resolution.y;
@@ -330,14 +331,16 @@ export class TerrainLayers {
                 return existing;
             }
 
-            const scaledLayerSampler = Sampler2D.uint8(3, resolution_x, resolution_y);
+            const scaledLayerSampler = Sampler2D.uint8(4, resolution_x, resolution_y);
 
             sampler2d_scale(layerSampler, scaledLayerSampler);
 
-            // write scaled texture into the cache
-            scaled_texture_cache.put(key, scaledLayerSampler);
+            // Ensure result is uint8 RGBA
+            const rgba = sampler2d_ensure_uint8_RGBA(scaledLayerSampler);
 
-            return scaledLayerSampler;
+            scaled_texture_cache.put(key, rgba);
+
+            return rgba;
         }
     }
 
@@ -359,7 +362,7 @@ export class TerrainLayers {
 
         const resolution = this.resolution;
 
-        const single_layer_byte_size = resolution.x * resolution.y * 3;
+        const single_layer_byte_size = resolution.x * resolution.y * 4;
 
         if (arrayData.length < single_layer_byte_size * index) {
             throw new Error('Texture data is too small, make sure you rebuild texture data before attempting to write');
@@ -411,7 +414,7 @@ export class TerrainLayers {
         texture.dispose();
 
         //build an array to hold texture array
-        const arrayData = new Uint8Array(size_x * size_y * 3 * layerCount);
+        const arrayData = new Uint8Array(size_x * size_y * 4 * layerCount);
         arrayData.fill(255); // fill with white
 
         if (image.width === size_x && image.height === size_y) {

package/src/engine/graphics/ecs/water/WaterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAWA;IAyBI;;;;OAIG;IACH,sCAYC;IAzCD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,4CAMC;IAED,2CA0DC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBA7QsB,wBAAwB;kBAM7B,YAAY;oBAPV,mCAAmC"}
+{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAYA;IAyBI;;;;OAIG;IACH,sCAYC;IAzCD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,4CAMC;IAED,2CA4DC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBA/QsB,wBAAwB;kBAM7B,YAAY;oBAPV,mCAAmC"}

package/src/engine/graphics/ecs/water/WaterSystem.js

@@ -1,4 +1,5 @@
 import { BackSide, PlaneBufferGeometry } from 'three';
+import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { System } from '../../../ecs/System.js';
 import { obtainTerrain } from "../../../ecs/terrain/util/obtainTerrain.js";
@@ -76,6 +77,8 @@ class WaterSystem extends System {
             (destination, offset, entity, ecd) => {
                 const component = ecd.getComponent(entity, Water);
 
+                assert.defined(component, 'component');
+
                 const mesh = component.__threeObject;
 
                 if (mesh === null) {

package/src/engine/graphics/material/SplatMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SplatMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/material/SplatMaterial.js"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AACH,oFAPW,OAAO,GAIN,cAAc,CAkIzB;;IAxID;;;;;;;;OAQG;IACH,kEAPW,OAAO,EAsIjB;;wBA5IM,OAAO;+BAAP,OAAO"}
+{"version":3,"file":"SplatMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/material/SplatMaterial.js"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AACH,oFAPW,OAAO,GAIN,cAAc,CAgIzB;;IAtID;;;;;;;;OAQG;IACH,kEAPW,OAAO,EAoIjB;;wBA1IM,OAAO;+BAAP,OAAO"}

package/src/engine/graphics/material/SplatMaterial.js

@@ -47,10 +47,7 @@ export function SplatMaterial(
                 type: "t",
                 value: null
             },
-            "splatLayerCount": {
-                type: "f",
-                value: 4
-            },
+
             "splatResolution": {
                 type: 'v2',
                 value: new Vector2(1, 1)
@@ -115,6 +112,7 @@ export function SplatMaterial(
         transparent: false,
         lights: true,
         defines: {
+            SPLAT_LAYER_COUNT: 4,
             SHADOWMAP_CLOUDS: false,
             DIFFUSE_GRAIN: false
         },

package/src/engine/graphics/shaders/TerrainShader.js

@@ -95,7 +95,7 @@ function fragment() {
     precision highp sampler2DArray;
     
     uniform sampler2DArray splatWeightMap;
-    uniform int splatLayerCount;
+    // SPLAT_LAYER_COUNT is injected as a #define from the material defines
     
     uniform vec2 splatResolution;
    
@@ -240,14 +240,7 @@ function fragment() {
         return hsv2rgb(hsv);
     }
     
-    vec3 brighten2(const in vec3 color, in float factor, float p){
-        vec3 yiq = rgb2yiq*color;
-        
-        yiq.x *= p;
-        yiq.x = pow(yiq.x,factor);
-        
-        return yiq2rgb * yiq;
-    }
+
     
     vec4 computeGridOverlayTexel(const in vec2 grid_uv, const in vec2 grid_resolution){
         vec2 grid_texel = vGridPosition + 0.5;
@@ -276,7 +269,7 @@ function fragment() {
         float weightSum = 0.0;
         vec4 colorSum = vec4(0.0);
         
-        for( int i = 0; i < splatLayerCount; i++){
+        for( int i = 0; i < SPLAT_LAYER_COUNT; i++){
                
             vec2 scale = texelFetch(materialScalesMap, ivec2(i, 0), 0 ).xy;
             
@@ -290,7 +283,7 @@ function fragment() {
             colorSum += diffuseData*weight;
         }
         
-        return colorSum / weightSum;  
+        return weightSum > 0.0 ? colorSum / weightSum : vec4(0.0);  
     }
     
     ${ShaderChunks.clouds_pars_fragment}

package/src/engine/navigation/mesh/NavigationMesh.d.ts

@@ -10,20 +10,22 @@ export class NavigationMesh {
      * @param {BinaryTopology} source
      * @param {number} [agent_radius]
      * @param {number} [agent_height]
-     * @param {number} [agent_max_climb] In radians, how steep of an angle can the agent go up by
+     * @param {number} [agent_max_climb_angle] In radians, how steep of an angle can the agent go up by
      * @param {Vector3} [up] Defines world's "UP" direction, this is what the agent will respect for climbing constraint
      */
-    build({ source, agent_radius, agent_height, agent_max_climb, up, }: BinaryTopology): void;
+    build({ source, agent_radius, agent_height, agent_max_climb_angle, up, }: BinaryTopology): void;
     /**
+     * Compute a walkable path between the two points.
+     * The result is a sequence of 3d points written into `output`. First point matches start, last point matches goal (snapped onto the mesh).
      *
-     * @param {Float32Array} output
+     * @param {Float32Array} output packed XYZ triples
      * @param {number} start_x
      * @param {number} start_y
      * @param {number} start_z
      * @param {number} goal_x
      * @param {number} goal_y
      * @param {number} goal_z
-     * @returns {number}
+     * @returns {number} number of 3d points written to `output` (0 if no path was found)
      */
     find_path(output: Float32Array, start_x: number, start_y: number, start_z: number, goal_x: number, goal_y: number, goal_z: number): number;
 }

package/src/engine/navigation/mesh/NavigationMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NavigationMesh.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/mesh/NavigationMesh.js"],"names":[],"mappings":"AAmCA;IAEI,yBAAgC;IAEhC;;;OAGG;IACH,KAFU,GAAG,CAEG;IAEhB;;;;;;;OAOG;IACH,oEANW,cAAc,QAwBxB;IAGD;;;;;;;;;;OAUG;IACH,kBATW,YAAY,WACZ,MAAM,WACN,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAwGlB;CAEJ;+BA3L4C,gEAAgE;oBAFzF,gCAAgC"}
+{"version":3,"file":"NavigationMesh.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/mesh/NavigationMesh.js"],"names":[],"mappings":"AAgCA;IAEI,yBAAgC;IAEhC;;;OAGG;IACH,KAFU,GAAG,CAEG;IAEhB;;;;;;;OAOG;IACH,0EANW,cAAc,QAwBxB;IAGD;;;;;;;;;;;;OAYG;IACH,kBATW,YAAY,WACZ,MAAM,WACN,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CA+HlB;CAEJ;+BAlN4C,gEAAgE;oBADzF,gCAAgC"}