@woosh/meep-engine 2.37.18 → 2.38.0

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

@@ -5,12 +5,17 @@
 
 import Vector4 from '../../../../core/geom/Vector4.js';
 import canvas2Sampler2D from "../../../graphics/texture/Canvas2Sampler2D.js";
-import convertSampler2D2Canvas from "../../../graphics/texture/sampler/Sampler2D2Canvas.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
 import { assert } from "../../../../core/assert.js";
 import ObservedString from "../../../../core/model/ObservedString.js";
-import { ClampToEdgeWrapping, NearestFilter, Texture } from "three";
+import { ClampToEdgeWrapping, DataTexture, NearestFilter } from "three";
+import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
+import { scaleSampler2D } from "../../../graphics/texture/sampler/scaleSampler2D.js";
+import { uint82float } from "../../../../core/binary/uint82float.js";
+import { float2uint8 } from "../../../../core/binary/float2uint8.js";
+import { isTypedArray } from "../../../../core/collection/array/typed/isTypedArray.js";
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
 
 class Context {
     /**
@@ -41,6 +46,8 @@ class Context {
     }
 }
 
+const COLOR_UINT_8_TRANSPARENT = [0, 0, 0, 0];
+
 
 export class TerrainOverlay {
     /**
@@ -68,14 +75,13 @@ export class TerrainOverlay {
          */
         this.tileImage = new ObservedString("");
 
-        const canvas = this.canvas = document.createElement("canvas");
-
-        canvas.width = size.x;
-        canvas.height = size.y;
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        this.sampler = Sampler2D.uint8(4, size.x, size.y);
 
-        this.fillColor = new Vector4();
-        this.context2d = canvas.getContext('2d');
-        const texture = this.texture = new Texture(canvas);
+        const texture = this.texture = new DataTexture(this.sampler.data);
 
         texture.wrapS = ClampToEdgeWrapping;
         texture.wrapT = ClampToEdgeWrapping;
@@ -83,6 +89,8 @@ export class TerrainOverlay {
         texture.magFilter = NearestFilter;
         texture.minFilter = NearestFilter;
 
+        texture.anisotropy = 0;
+
         texture.flipY = false;
 
         texture.repeat.set(1, 1);
@@ -96,17 +104,30 @@ export class TerrainOverlay {
          */
         this.stack = [];
 
-        this.size.onChanged.add(function (x, y) {
-            canvas.width = x;
-            canvas.height = y;
+        this.size.onChanged.add((x, y) => {
+            this.sampler.resize(x, y);
+
+            this.texture.dispose();
+
+            this.texture.image.data = this.sampler.data;
+
+            this.texture.image.width = x;
+            this.texture.image.height = y;
         });
     }
 
+    /**
+     * @returns {HTMLCanvasElement}
+     */
+    get canvas() {
+        throw new Error('Deprecated, used .sampler instead');
+    }
+
     /**
      * Pushes new context onto the stack, allowing you to preserve current state for later
      */
     push() {
-        const sampler = canvas2Sampler2D(this.canvas);
+        const sampler = this.sampler.clone();
 
         const context = new Context(sampler, this.borderWidth.getValue(), this.tileImage.getValue());
 
@@ -135,7 +156,7 @@ export class TerrainOverlay {
         this.size.set(sampler.width, sampler.height);
 
         // write context onto canvas
-        convertSampler2D2Canvas(sampler, 1, 0, this.canvas);
+        this.sampler.copy(sampler, 0, 0, 0, 0, sampler.width, sampler.height);
 
         this.borderWidth.set(context.borderWidth);
 
@@ -146,7 +167,8 @@ export class TerrainOverlay {
 
     clear() {
         const size = this.size;
-        this.context2d.clearRect(0, 0, size.x, size.y);
+
+        this.sampler.zeroFill(0, 0, size.x, size.y);
 
         this.update();
     }
@@ -162,15 +184,11 @@ export class TerrainOverlay {
      * @param {Vector4} result
      */
     readPoint(x, y, result) {
-        const imageData = this.context2d.getImageData(x, y, 1, 1);
-        const data = imageData.data;
-
-        const r = uint82float(data[0]);
-        const g = uint82float(data[1]);
-        const b = uint82float(data[2]);
-        const a = uint82float(data[3]);
+        for (let i = 0; i < 4; i++) {
+            const v = this.sampler.readChannel(x, y, i);
 
-        result.set(r, g, b, a);
+            result[i] = uint82float(v);
+        }
     }
 
     /**
@@ -204,7 +222,7 @@ export class TerrainOverlay {
      * @param {number} y
      */
     clearPoint(x, y) {
-        this.context2d.clearRect(x, y, 1, 1);
+        this.sampler.set(x, y, COLOR_UINT_8_TRANSPARENT);
     }
 
     /**
@@ -214,25 +232,12 @@ export class TerrainOverlay {
      * @param {Vector4} vec4
      */
     paintPoint(x, y, vec4) {
-        const ctx = this.context2d;
-
-        const fill_color = this.fillColor;
-
-        if (!fill_color.equals(vec4)) {
-            // change style
-            fill_color.copy(vec4);
+        for (let i = 0; i < 4; i++) {
 
-            const r = float2uint8(vec4.x);
-            const g = float2uint8(vec4.y);
-            const b = float2uint8(vec4.z);
+            this.sampler.writeChannel(x, y, i, float2uint8(vec4[i]));
 
-            const a = vec4.w;
-
-            ctx.fillStyle = "rgba(" + r + "," + g + "," + b + "," + a + ")";
         }
 
-        ctx.fillRect(x, y, 1, 1);
-
         this.texture.needsUpdate = true;
     }
 
@@ -241,10 +246,7 @@ export class TerrainOverlay {
      * @param {Uint8Array|number[]} data
      */
     writeData(data) {
-
-        assert.ok(Array.isArray(data) || data instanceof Uint8Array || data instanceof Uint8ClampedArray, `expected data to be Array,Uint8Array or ClampedUint8Array, got something else instead`);
-
-        const ctx = this.context2d;
+        assert.isArrayLike(data, 'data');
 
         const size = this.size;
 
@@ -253,13 +255,15 @@ export class TerrainOverlay {
             return;
         }
 
-        const imageData = ctx.createImageData(size.x, size.y);
-
-        const array = imageData.data;
+        assert.equal(data.length, this.sampler.data.length);
 
-        array.set(data);
+        if (isTypedArray(this.sampler.data)) {
+            this.sampler.data.set(data);
+        } else {
+            array_copy(data, 0, this.sampler.data, 0, data.length);
+        }
 
-        ctx.putImageData(imageData, 0, 0);
+        this.sampler.version++;
 
         this.texture.needsUpdate = true;
     }
@@ -273,27 +277,28 @@ export class TerrainOverlay {
      * @param {number} [dHeight]
      */
     paintImage(image, dx, dy, dWidth, dHeight) {
+        const source = canvas2Sampler2D(image);
+
+        this.paintSampler(source, dx, dy, dWidth, dHeight);
+    }
+
+    /**
+     *
+     * @param {Sampler2D} source
+     * @param {number} dx
+     * @param {number} dy
+     * @param {number} dWidth
+     * @param {number} dHeight
+     */
+    paintSampler(source, dx, dy, dWidth, dHeight) {
+
+        // rescale source if needed
+        const scaled_source = Sampler2D.uint8(4, dWidth, dHeight);
+        scaleSampler2D(source, scaled_source);
 
-        this.context2d.drawImage(image, dx, dy, dWidth, dHeight);
+        this.sampler.paint(scaled_source, 0, 0, dx, dy, dWidth, dHeight);
 
         this.texture.needsUpdate = true;
     }
 }
 
-/**
- *
- * @param {number} v
- * @returns {number}
- */
-function float2uint8(v) {
-    return Math.round(v * 255);
-}
-
-/**
- *
- * @param {number} v
- * @returns {number}
- */
-function uint82float(v) {
-    return v / 255;
-}

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

@@ -281,6 +281,29 @@ class TerrainTileManager {
         this.initializeTiles();
     }
 
+    /**
+     * Rebuild tiles that overlap rectangular region of the overall terrain defined by normalized coordinates (UV space)
+     * @param {number} u0
+     * @param {number} v0
+     * @param {number} u1
+     * @param {number} v1
+     */
+    rebuildTilesByUV(u0, v0, u1, v1) {
+
+        const tx0 = u0 * this.totalSize.x;
+        const tx1 = u1 * this.totalSize.x;
+
+        const ty0 = v0 * this.totalSize.y;
+        const ty1 = v1 * this.totalSize.y;
+
+        const dirtyTiles = this.getRawTilesOverlappingRectangle(tx0 - 1, ty0 - 1, tx1 + 1, ty1 + 1);
+
+        dirtyTiles.forEach(tile => {
+            tile.isBuilt = false;
+        });
+    }
+
+
     /**
      *
      * @param {number} x0

package/engine/ecs/terrain/util/loadVisibleTerrainTiles.js

@@ -43,7 +43,7 @@ export function loadVisibleTerrainTiles(em, ecd) {
         });
 
         totalTiles = tiles.length;
-        const tileManager = terrain.tiles;
+        const tileManager = terrain.__tiles;
 
         function handleObtainedTile(t) {
             if (attemptId !== attempt) {

package/engine/ecs/terrain/util/paintTerrainOverlayViaLookupTable.js

@@ -2,6 +2,7 @@ import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
 import { ParameterLookupTable } from "../../../graphics/particles/particular/engine/parameter/ParameterLookupTable.js";
 import { passThrough } from "../../../../core/function/Functions.js";
 import { clamp01 } from "../../../../core/math/clamp01.js";
+import { scaleSampler2D } from "../../../graphics/texture/sampler/scaleSampler2D.js";
 
 
 const heatmap_lut = new ParameterLookupTable(4);
@@ -23,7 +24,13 @@ heatmap_lut.computeUniformPositions();
  * @param {NumericInterval} range Range of values of interest within the sampler that are to be mapped onto LUT
  * @param {function(number):number} [lookupScaleFunction]
  */
-export function paintTerrainOverlayViaLookupTable({ overlay, sampler, lut = heatmap_lut, range, lookupScaleFunction = passThrough }) {
+export function paintTerrainOverlayViaLookupTable({
+                                                      overlay,
+                                                      sampler,
+                                                      lut = heatmap_lut,
+                                                      range,
+                                                      lookupScaleFunction = passThrough
+                                                  }) {
     let i, j;
 
     const colorSample = [];
@@ -33,18 +40,17 @@ export function paintTerrainOverlayViaLookupTable({ overlay, sampler, lut = heat
 
     const buffer = Sampler2D.uint8(4, w, h);
 
-    const j_max = h - 1;
-
-    const i_max = w - 1;
+    // rescale source
+    const scaled_sampler = sampler.clone();
+    scaled_sampler.resize(w, h);
+    scaleSampler2D(sampler, scaled_sampler);
 
     for (j = 0; j < h; j++) {
 
-        const v = j / j_max;
 
         for (i = 0; i < w; i++) {
-            const u = i / i_max;
 
-            const p = sampler.sampleChannelBilinearUV(u, v, 0);
+            const p = scaled_sampler.readChannel(i, j, 0);
 
             const scaledPosition = lookupScaleFunction(p);
 

package/engine/ecs/terrain/util/tensionOptimizeUV.js

@@ -1,4 +1,4 @@
-import { TopoMesh } from "../../../../core/geom/3d/topology/TopoMesh.js";
+import { TopoMesh } from "../../../../core/geom/3d/topology/struct/TopoMesh.js";
 
 /**
  * Move UVs to reduce stretching

package/engine/ecs/transform/Transform.d.ts

@@ -29,4 +29,6 @@ export class Transform {
     toMatrix4(result: ArrayLike<number>): void
 
     fromMatrix4(matrix: ArrayLike<number>): void
+
+    multiplyTransforms(a: Transform, b: Transform): void
 }

package/engine/ecs/transform/Transform.editor.schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema",
+  "title": "Transform",
+  "type": "object",
+  "properties": {
+    "position": {
+      "allOf": [{"$ref": "Vector3"}]
+    },
+    "rotation": {
+      "allOf": [{"$ref": "Quaterion"}]
+    },
+    "scale": {
+      "allOf": [{"$ref": "Vector3"}]
+    }
+  }
+}

package/engine/ecs/transform/Transform.js

@@ -19,6 +19,9 @@ const m4_0 = new Float32Array(scratch_buffer, 0, 16);
 
 const FLAGS_DEFAULT = TransformFlags.AutomaticChangeDetection;
 
+/**
+ * @class
+ */
 export class Transform {
     /**
      *

package/engine/graphics/ecs/highlight/HighlightEditor.js

@@ -0,0 +1,17 @@
+import { ObjectEditor } from "../../../../editor/ecs/component/editors/primitive/ObjectEditor.js";
+import List from "../../../../core/collection/list/List.js";
+import { HighlightDefinition } from "./HighlightDefinition.js";
+
+export class HighlightEditor extends ObjectEditor {
+    get schema() {
+        return {
+            additionalProperties: false,
+            properties: {
+                elements: {
+                    type: List,
+                    type_parameters: [HighlightDefinition]
+                }
+            }
+        };
+    }
+}

package/engine/graphics/ecs/light/Light.js

@@ -6,7 +6,6 @@ import ObservedEnum from "../../../../core/model/ObservedEnum.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
 import { Color } from "../../../../core/color/Color.js";
 import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
-import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { LightType } from "./LightType.js";
 
 export class Light {
@@ -161,49 +160,3 @@ Light.typeName = "Light";
 
 Light.Type = LightType;
 
-export class LightSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = Light;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {Light} value
-     */
-    serialize(buffer, value) {
-
-        buffer.writeUint8(value.type.getValue());
-        buffer.writeUint32(value.color.toUint());
-        value.intensity.toBinaryBuffer(buffer);
-        value.castShadow.toBinaryBuffer(buffer);
-
-        if (value.type.getValue() === LightType.SPOT) {
-            value.angle.toBinaryBuffer(buffer);
-            value.penumbra.toBinaryBuffer(buffer);
-            value.distance.toBinaryBuffer(buffer);
-        }
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {Light} value
-     */
-    deserialize(buffer, value) {
-
-        value.type.set(buffer.readUint8());
-        value.color.fromUint(buffer.readUint32());
-        value.intensity.fromBinaryBuffer(buffer);
-        value.castShadow.fromBinaryBuffer(buffer);
-
-        if (value.type.getValue() === LightType.SPOT) {
-            value.angle.fromBinaryBuffer(buffer);
-            value.penumbra.fromBinaryBuffer(buffer);
-            value.distance.fromBinaryBuffer(buffer);
-        }
-    }
-}

package/engine/graphics/ecs/light/LightSerializationAdapter.js

@@ -0,0 +1,50 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { LightType } from "./LightType.js";
+import { Light } from "./Light.js";
+
+export class LightSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = Light;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param buffer
+     * @param {Light} value
+     */
+    serialize(buffer, value) {
+
+        buffer.writeUint8(value.type.getValue());
+        buffer.writeUint32(value.color.toUint());
+        value.intensity.toBinaryBuffer(buffer);
+        value.castShadow.toBinaryBuffer(buffer);
+
+        if (value.type.getValue() === LightType.SPOT) {
+            value.angle.toBinaryBuffer(buffer);
+            value.penumbra.toBinaryBuffer(buffer);
+            value.distance.toBinaryBuffer(buffer);
+        }
+    }
+
+    /**
+     *
+     * @param buffer
+     * @param {Light} value
+     */
+    deserialize(buffer, value) {
+
+        value.type.set(buffer.readUint8());
+        value.color.fromUint(buffer.readUint32());
+        value.intensity.fromBinaryBuffer(buffer);
+        value.castShadow.fromBinaryBuffer(buffer);
+
+        if (value.type.getValue() === LightType.SPOT) {
+            value.angle.fromBinaryBuffer(buffer);
+            value.penumbra.fromBinaryBuffer(buffer);
+            value.distance.fromBinaryBuffer(buffer);
+        }
+    }
+}

package/engine/graphics/ecs/mesh/MeshEditor.js

@@ -0,0 +1,28 @@
+import { ObjectEditor } from "../../../../editor/ecs/component/editors/primitive/ObjectEditor.js";
+import { BitFlagsEditor } from "../../../../editor/ecs/component/editors/common/BitFlagsEditor.js";
+import { MeshFlags } from "./Mesh.js";
+
+export class MeshEditor extends ObjectEditor {
+    get schema() {
+        return {
+            properties: {
+                bvh: {
+                    transient: true
+                },
+                asset: {
+                    transient: true
+                },
+                boundingBox: {
+                    transient: true
+                },
+                flags: {
+                    editor: new BitFlagsEditor(MeshFlags),
+                    transient: true
+                },
+                center: {
+                    deprecated: true
+                }
+            }
+        };
+    }
+}

package/engine/graphics/ecs/mesh-v2/DrawMode.js

@@ -1,5 +1,6 @@
 export const DrawMode = {
     Triangles: 0,
     Lines: 2,
-    LineSegments: 3
+    LineSegments: 3,
+    Points: 4
 };

package/engine/graphics/ecs/mesh-v2/aggregate/prototypeSGMesh.js

@@ -56,7 +56,7 @@ new EngineHarness().initialize({
 function make_grid(ecd, engine) {
     const random = seededRandom(1);
 
-    const GRID_SIZE = 20;
+    const GRID_SIZE = 40;
     const GRID_FREQUENCY_SIZE = 7;
 
     for (let i = 0; i < GRID_SIZE; i++) {
@@ -106,8 +106,8 @@ function make_grid(ecd, engine) {
             });
 
 
-            // const mesh = SGMesh.fromURL("data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf");
-            const mesh = SGMesh.fromURL("data/models/samples/transform-hierarchy.glb");
+            const mesh = SGMesh.fromURL("data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf");
+            // const mesh = SGMesh.fromURL("data/models/samples/transform-hierarchy.glb");
             new EntityBuilder()
                 .add(mesh)
                 .add(transform)

package/engine/graphics/ecs/mesh-v2/build_three_object.js

@@ -1,5 +1,5 @@
 import { DrawMode } from "./DrawMode.js";
-import { Line, LineSegments, Mesh } from "three";
+import { Line, LineSegments, Mesh, Points } from "three";
 import { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
 
 /**
@@ -24,6 +24,8 @@ export function build_three_object(sg) {
         object = new Line(geo, shader);
     } else if (mode === DrawMode.LineSegments) {
         object = new LineSegments(geo, shader);
+    } else if (mode === DrawMode.Points) {
+        object = new Points(geo, shader);
     } else {
         throw new Error(`Unsupported draw mode '${mode}'`);
     }

package/engine/graphics/ecs/mesh-v2/sg_compute_hierarchy_bounding_box_by_parent_entity.js

@@ -0,0 +1,31 @@
+import { ShadedGeometry } from "./ShadedGeometry.js";
+import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
+import { ParentEntitySystem } from "../../../ecs/parent/ParentEntitySystem.js";
+
+const scratch_aabb3 = new AABB3();
+
+/**
+ *
+ * @param {AABB3} result
+ * @param {number} root_entity
+ * @param {EntityComponentDataset} ecd
+ */
+export function sg_hierarchy_compute_bounding_box_via_parent_entity(result, root_entity, ecd) {
+    function visit(entity, ecd) {
+
+        /**
+         * @type {ShadedGeometry}
+         */
+        const sg = ecd.getComponent(root_entity, ShadedGeometry);
+
+        if (sg !== null) {
+            sg.getBoundingBox(scratch_aabb3);
+
+            result.expandToFit(scratch_aabb3);
+        }
+    }
+
+    result.setNegativelyInfiniteBounds();
+
+    ParentEntitySystem.traverse(ecd, root_entity, visit);
+}

package/engine/graphics/ecs/mesh-v2/sg_hierarchy_compute_bounding_box_via_parent_entity.d.ts

@@ -0,0 +1,4 @@
+import {AABB3} from "../../../../core/bvh2/aabb3/AABB3";
+import {EntityComponentDataset} from "../../../ecs/EntityComponentDataset";
+
+export function sg_hierarchy_compute_bounding_box_via_parent_entity(result: AABB3, root_entity: number, ecd: EntityComponentDataset): void

package/engine/graphics/ecs/sprite/Sprite.js

@@ -0,0 +1,11 @@
+import Vector1 from "../../../../core/geom/Vector1.js";
+import { Color } from "../../../../core/color/Color.js";
+
+export class Sprite {
+    size = 1;
+    url = "";
+    opacity = new Vector1(1);
+    color = new Color(1, 1, 1);
+}
+
+Sprite.typeName = "Sprite";