@woosh/meep-engine 2.33.25 → 2.33.29

package/core/geom/3d/shape/util/compute_signed_distance_gradient_by_sampling.js

@@ -0,0 +1,48 @@
+const scratch_v = [];
+
+/**
+ *
+ * @param {number[]} result
+ * @param {AbstractShape3D} shape
+ * @param {number[]} point
+ * @returns {number}
+ */
+export function compute_signed_distance_gradient_by_sampling(result, shape, point) {
+    const v0 = shape.signed_distance_at_point(point);
+
+    scratch_v[0] = point[0] + 1e-5;
+    scratch_v[1] = point[1];
+    scratch_v[2] = point[2];
+
+    const vx = shape.signed_distance_at_point(scratch_v);
+
+    scratch_v[0] = point[0];
+    scratch_v[1] = point[1] + 1e-5;
+    scratch_v[2] = point[2];
+
+    const vy = shape.signed_distance_at_point(point);
+
+    scratch_v[0] = point[0];
+    scratch_v[1] = point[1];
+    scratch_v[2] = point[2] + 1e-5;
+
+    const vz = shape.signed_distance_at_point(point);
+
+    // convert absolute sample values to relative
+    const rx = vx - v0;
+    const ry = vy - v0;
+    const rz = vz - v0;
+
+    // normalize by sampling distance
+    const d = 1e-5 / 1.73205080757;
+
+    const nx = rx * d;
+    const ny = ry * d;
+    const nz = rz * d;
+
+    result[0] = nx;
+    result[1] = ny;
+    result[2] = nz;
+
+    return v0;
+}

package/core/geom/3d/shape/util/shape_to_visual_entity.js

@@ -1,4 +1,4 @@
-import { CompositeShape3D } from "../CompositeShape.js";
+import { UnionShape3D } from "../UnionShape3D.js";
 import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
 import { UnitSphereShape3D } from "../UnitSphereShape3D.js";
 import { TransformedShape3D } from "../TransformedShape3D.js";
@@ -30,7 +30,7 @@ export const SHAPE_VISUAL_ENTITY_TAG = 'util/vis/Shape3D';
 
 /**
  *
- * @param {CompositeShape3D} shape
+ * @param {UnionShape3D} shape
  * @param {EntityComponentDataset} ecd
  * @returns {EntityBuilder}
  */
@@ -145,7 +145,7 @@ function transformed_shape_to_entity(shape, ecd) {
  * @returns {EntityBuilder}
  */
 export function shape_to_visual_entity(shape, ecd) {
-    if (shape instanceof CompositeShape3D) {
+    if (shape instanceof UnionShape3D) {
         return composite_shape_to_entity(shape, ecd);
     } else if (shape instanceof UnitCubeShape3D) {
         return cube_shape_to_entity(shape, ecd);

package/core/model/ObservedBoolean.d.ts

@@ -1,4 +1,6 @@
 export default class ObservedBoolean {
+    constructor(value: boolean)
+
     set(value: boolean): ObservedBoolean
 
     getValue(): boolean

package/core/parser/simple/Token.d.ts

@@ -0,0 +1,13 @@
+export class Token<V = string, T = string> {
+    readonly value: V
+    readonly start: number
+    readonly end: number
+    readonly name: string
+    readonly type: T
+
+    constructor(value: V, start: number, end: number, name: string, type: T)
+
+    equals(other: Token<V, T>): boolean
+
+    hash(): number
+}

package/core/parser/simple/Token.js

@@ -1,31 +1,65 @@
-function Token(value, start, end, name, type) {
-    this.value = value;
-    this.start = start;
-    this.end = end;
-    this.name = name;
-    this.type = type;
-}
+class Token {
+    /**
+     * @template V,T
+     * @param {V} value
+     * @param {number} start
+     * @param {number} end
+     * @param {string} name
+     * @param {T} type
+     */
+    constructor(value, start, end, name, type) {
+        /**
+         * @readonly
+         * @type {V}
+         */
+        this.value = value;
+        /**
+         * Starting position in the input
+         * @readonly
+         * @type {number}
+         */
+        this.start = start;
+        /**
+         * End position in the input
+         * @readonly
+         * @type {number}
+         */
+        this.end = end;
+        /**
+         * @readonly
+         * @type {string}
+         */
+        this.name = name;
+        /**
+         * Token type
+         * @readonly
+         * @type {T}
+         */
+        this.type = type;
+    }
 
-/**
- *
- * @param {Token} other
- * @returns {boolean}
- */
-Token.prototype.equals = function (other) {
-    return this.value === other.value &&
-        this.start === other.start &&
-        this.end === other.end &&
-        this.name === other.name &&
-        this.type === other.type
-        ;
-};
+    /**
+     *
+     * @param {Token} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.value === other.value &&
+            this.start === other.start &&
+            this.end === other.end &&
+            this.name === other.name &&
+            this.type === other.type
+            ;
+    }
 
-/**
- *
- * @return {number}
- */
-Token.prototype.hash = function () {
-    return 0;
-};
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        // TODO make an actual hash
+        return 0;
+    }
+}
 
 export default Token;

package/editor/tools/FoliagePaintTool.js

@@ -6,7 +6,7 @@ import { parseHex } from "../../core/color/ColorUtils.js";
 import Vector4 from "../../core/geom/Vector4.js";
 import loadSampler2D from "../../engine/graphics/texture/sampler/loadSampler2D.js";
 import convertSampler2D2Canvas from "../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
-import { Foliage2 } from "../../engine/ecs/foliage/ecs/Foliage2.js";
+import { InstancedMeshComponent } from "../../engine/ecs/foliage/ecs/InstancedMeshComponent.js";
 
 class FoliagePaintTool extends Tool {
     constructor() {
@@ -100,7 +100,7 @@ class FoliagePaintTool extends Tool {
 
         /**
          *
-         * @param {Foliage2} foliage
+         * @param {InstancedMeshComponent} foliage
          * @param {Number} entity
          */
         function visit(foliage, entity) {
@@ -149,9 +149,9 @@ class FoliagePaintTool extends Tool {
 
             /**
              *
-             * @type {Foliage2}
+             * @type {InstancedMeshComponent}
              */
-            const foliage = entityManger.getComponent(entity, Foliage2);
+            const foliage = entityManger.getComponent(entity, InstancedMeshComponent);
 
 
             if (foliage === null) {

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -24,10 +24,42 @@ import { HashSet } from "../../../core/collection/HashSet.js";
 import { computeGeometryHash } from "./geometry/geometry/computeGeometryHash.js";
 import { computeGeometryEquality } from "./geometry/geometry/computeGeometryEquality.js";
 import { traverseThreeObject } from "../../graphics/ecs/highlight/renderer/traverseThreeObject.js";
+import { computeTextureHash } from "./material/computeTextureHash.js";
+import { computeTextureEquality } from "./material/computeTextureEquality.js";
 
 const animationOptimizer = new AnimationOptimizer();
 const materialCache = StaticMaterialCache.Global;
 
+/**
+ *
+ * @param {THREE.Material} material
+ * @param {HashSet<Texture>} texture_cache
+ */
+function replace_material_textures_from_cache(material, texture_cache) {
+    const attachments = TextureAttachmentsByMaterialType[material.type];
+
+    if (attachments === undefined) {
+        // unsupported material
+        return;
+    }
+
+    const attachment_count = attachments.length;
+
+    for (let i = 0; i < attachment_count; i++) {
+        const attachment = attachments[i];
+
+        const texture = attachment.read(material);
+        if (texture !== undefined && texture !== null) {
+            const cached = texture_cache.ensure(texture);
+
+            if (cached !== texture) {
+                // got an existing cached texture, write that instead
+                attachment.write(material, cached);
+            }
+        }
+    }
+}
+
 /**
  * Transfer any transform on the root down to the children instead
  * @param {Object3D} root
@@ -154,7 +186,20 @@ export class GLTFAssetLoader extends AssetLoader {
          */
         this.__geometry_cache = new HashSet({
             keyHashFunction: computeGeometryHash,
-            keyEqualityFunction: computeGeometryEquality
+            keyEqualityFunction: computeGeometryEquality,
+            capacity: 1024
+        });
+
+
+        /**
+         *
+         * @type {HashSet<Texture>}
+         * @private
+         */
+        this.__texture_cache = new HashSet({
+            keyHashFunction: computeTextureHash,
+            keyEqualityFunction: computeTextureEquality,
+            capacity: 2048
         });
     }
 
@@ -234,9 +279,12 @@ export class GLTFAssetLoader extends AssetLoader {
         }
     }
 
+
     load(path, success, failure, progress) {
         const loader = this.loader;
         const geometry_cache = this.__geometry_cache;
+        const texture_cache = this.__texture_cache;
+
 
         /**
          *
@@ -253,6 +301,9 @@ export class GLTFAssetLoader extends AssetLoader {
             geometry = geometry_cache.ensure(geometry);
             mesh.geometry = geometry;
 
+            // replace textures from cache
+            replace_material_textures_from_cache(mesh.material, texture_cache);
+
             const isSkinned = mesh.isSkinnedMesh === true;
 
 

package/engine/asset/loaders/image/ImageDecoderWorker.js

@@ -10,7 +10,7 @@ async function decode_png(png_bytes) {
 
         const png = reader.parse();
 
-        const data = png.getRGBA8Array();
+        const uint_channels = png.getUint8Data();
 
         const width = png.getWidth();
         const height = png.getHeight();
@@ -19,9 +19,10 @@ async function decode_png(png_bytes) {
         // console.profileEnd('decode');
 
         resolve({
-            data,
+            data: uint_channels.data,
             width,
-            height
+            height,
+            itemSize: uint_channels.itemSize
         });
     });
 }

package/engine/asset/loaders/image/ImageRGBADataAsset.js

@@ -6,8 +6,9 @@ export class ImageRGBADataAsset extends Asset {
      * @param {number[]|Uint8Array} data
      * @param {number} width
      * @param {number} height
+     * @param {number} [itemSize]
      */
-    constructor(data, width, height) {
+    constructor(data, width, height, itemSize = 4) {
         super();
 
         /**
@@ -32,7 +33,7 @@ export class ImageRGBADataAsset extends Asset {
          * Number of channels
          * @type {number}
          */
-        this.itemSize = 4;
+        this.itemSize = itemSize;
 
         this.byteSize = data.length;
     }

package/engine/asset/loaders/image/ImageRGBADataLoader.js

@@ -23,7 +23,7 @@ export class ImageRGBADataLoader extends AssetLoader {
     /**
      *
      * @param {string} path
-     * @returns {Promise<{data:ArrayBuffer, width: number, height:number}>}
+     * @returns {Promise<{data:ArrayBuffer, width: number, height:number, itemSize: number}>}
      * @private
      */
     async __decode_via_worker(path) {
@@ -45,7 +45,7 @@ export class ImageRGBADataLoader extends AssetLoader {
 
         const bitmap = await this.__decode_via_worker(path);
 
-        return new ImageRGBADataAsset(new Uint8Array(bitmap.data), bitmap.width, bitmap.height);
+        return new ImageRGBADataAsset(new Uint8Array(bitmap.data), bitmap.width, bitmap.height, bitmap.itemSize);
     }
 
     load(path, success, failure, progress) {
@@ -65,7 +65,7 @@ export class ImageRGBADataLoader extends AssetLoader {
 
                 texture.dispose();
 
-                const f = new ImageRGBADataAsset(sampler2D.data, sampler2D.width, sampler2D.height);
+                const f = new ImageRGBADataAsset(sampler2D.data, sampler2D.width, sampler2D.height, sampler2D.itemSize);
 
                 success(f);
 

package/engine/asset/loaders/image/codec/NativeImageDecoder.js

@@ -45,7 +45,8 @@ export class NativeImageDecoder extends Codec {
         return {
             data: rgba_data,
             width: width,
-            height: height
+            height: height,
+            itemSize: 4
         };
     }
 }

package/engine/asset/loaders/image/png/PNG.js

@@ -5,12 +5,23 @@ export function PNG() {
     // initialize all members to keep the same hidden class
     this.width = 0;
     this.height = 0;
+
+    /**
+     * Number of bits per channel?
+     * @type {number}
+     */
     this.bitDepth = 0;
+
     this.colorType = 0;
     this.compressionMethod = 0;
     this.filterMethod = 0;
     this.interlaceMethod = 0;
 
+    /**
+     * Number of channels in the image
+     * @example RGB = 3, RGBA = 4, etc.
+     * @type {number}
+     */
     this.colors = 0;
     this.alpha = false;
     this.pixelBits = 0;
@@ -23,6 +34,10 @@ export function PNG() {
      */
     this.pixels = null;
 
+    /**
+     * Transparency palette
+     * @type {Uint8Array|null}
+     */
     this.trns = null;
 
 }
@@ -138,6 +153,10 @@ PNG.prototype.setInterlaceMethod = function (interlaceMethod) {
     this.interlaceMethod = interlaceMethod;
 };
 
+/**
+ *
+ * @param {Uint8Array} trns
+ */
 PNG.prototype.setTRNS = function (trns) {
     this.trns = trns;
 };
@@ -161,7 +180,9 @@ PNG.prototype.getPalette = function () {
  * result is an array: [red, green, blue, alpha]
  */
 PNG.prototype.getPixel = function (result, result_offset, x, y) {
-    if (!this.pixels) {
+    var pixels = this.pixels;
+
+    if (!pixels) {
         throw new Error("pixel data is empty");
     }
 
@@ -170,7 +191,6 @@ PNG.prototype.getPixel = function (result, result_offset, x, y) {
     }
 
     var i = this.colors * this.bitDepth / 8 * (y * this.width + x);
-    var pixels = this.pixels;
 
     let r, g, b, a;
 
@@ -189,14 +209,17 @@ PNG.prototype.getPixel = function (result, result_offset, x, y) {
             break;
         case 3:
             a = 255;
-            if (this.trns != null && this.trns[pixels[i]] != null) {
+
+            if (this.trns != null) {
                 a = this.trns[pixels[i]];
             }
+
             const offset = pixels[i] * 3;
 
-            r = this.palette[offset];
-            g = this.palette[offset + 1];
-            b = this.palette[offset + 2];
+            const palette = this.palette;
+            r = palette[offset];
+            g = palette[offset + 1];
+            b = palette[offset + 2];
 
             break;
         case 4:
@@ -293,3 +316,87 @@ PNG.prototype.getRGBA8Array = function () {
 
     return data;
 };
+
+PNG.prototype.getUint8Data_case3 = function () {
+    const w = this.width;
+    const h = this.height;
+
+    const pixel_count = w * h;
+
+    let itemSize;
+
+    const transparency_lookup = this.trns;
+    if (transparency_lookup !== null) {
+        // has transparency
+        itemSize = 4;
+    } else {
+        itemSize = 3;
+    }
+
+    const result_data = new Uint8Array(pixel_count * itemSize);
+
+    const pixels = this.pixels;
+    const palette = this.palette;
+
+    const d = this.colors * this.bitDepth / 8;
+
+    for (let i = 0; i < pixel_count; i++) {
+        const destination_address = i * itemSize;
+
+        const lookup_value = pixels[i * d];
+
+        result_data[destination_address] = palette[lookup_value];
+        result_data[destination_address + 1] = palette[lookup_value + 1];
+        result_data[destination_address + 2] = palette[lookup_value + 2];
+    }
+
+    //transparency
+    if (transparency_lookup !== null) {
+        for (let i = 0; i < pixel_count; i++) {
+            result_data[i * 4 + 3] = transparency_lookup[pixels[i * d]];
+        }
+    }
+
+    return {
+        data: result_data,
+        itemSize: itemSize
+    }
+}
+
+/**
+ * @returns {{itemSize:number, data:Uint8Array}}
+ */
+PNG.prototype.getUint8Data = function () {
+    let data;
+    let itemSize = 0; // note, can take this from this.colors
+
+    switch (this.colorType) {
+        case 0:
+            data = this.pixels;
+            itemSize = 1;
+            break;
+        case 2:
+            data = this.pixels;
+            itemSize = 3;
+            break;
+        case 3:
+            // palette
+            return this.getUint8Data_case3();
+        case 4:
+            // grayscale with alpha
+            data = this.pixels;
+            itemSize = 2;
+            break;
+        case 6:
+            data = this.pixels;
+            itemSize = 4;
+            break;
+        default:
+            throw new Error('Unsupported color type');
+    }
+
+    return {
+        data,
+        itemSize
+    };
+};

package/engine/asset/loaders/image/png/PNGReader.js

@@ -91,6 +91,10 @@ PNGReader.prototype.decodeChunk = function () {
 
     const type = buffer.readASCIICharacters(4);
 
+    /**
+     *
+     * @type {Uint8Array}
+     */
     var chunk = this.readBytes(length);
 
     // checksum
@@ -161,6 +165,7 @@ PNGReader.prototype.decodeIDAT = function (chunk) {
 
 /**
  * https://www.w3.org/TR/PNG/#11tRNS
+ * @param {Uint8Array} chunk
  */
 PNGReader.prototype.decodeTRNS = function (chunk) {
     this.png.setTRNS(chunk);

package/engine/asset/loaders/material/bitmap2sampler_gl.js

@@ -1,5 +1,5 @@
 /**
- *
+ * Transfer bitmap contents to Sampler2D, effectively moving data to CPU, making it readable
  * @param {WebGL2RenderingContext} gl
  * @param {Sampler2D} sampler
  * @param {ImageBitmap} bitmap

package/engine/asset/loaders/material/computeImageBitmapEquality.js

@@ -40,7 +40,7 @@ function obtainSampler(bitmap, ctx) {
 }
 
 /**
- *
+ * Ref holding webgl context, being weak-ref, allows context to be removed when not in use
  * @type {WeakRef<WebGL2RenderingContext>|null}
  */
 let ctx_ref = null;
@@ -97,8 +97,13 @@ export function sampler_from_bitmap(bitmap) {
  * @returns {boolean}
  */
 export function computeImageBitmapEquality(a, b) {
+    if (a === b) {
+        // strict equality check, special case
+        return true;
+    }
 
     if (a.width !== b.width || a.height !== b.height) {
+        // check dimensions
         return false;
     }