@woosh/meep-engine 2.33.24 → 2.33.28

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/{engine/graphics/render/forward_plus/materials → core/primitives/strings}/insert_after.js

@@ -3,6 +3,7 @@
  * @param {string} source
  * @param {string} term
  * @param {string} extra
+ * @returns {string}
  */
 export function insert_after(source, term, extra) {
     const i = source.indexOf(term);
@@ -16,3 +17,5 @@ export function insert_after(source, term, extra) {
 
     return source.slice(0, end) + extra + source.slice(end);
 }
+
+

package/core/primitives/strings/insert_after_or_replace.js

@@ -0,0 +1,27 @@
+/**
+ *
+ * @param {string} source
+ * @param {string} insert_term
+ * @param {string} replace_term
+ * @param {string} value
+ * @returns {string}
+ */
+export function insert_after_or_replace(source, insert_term, replace_term, value) {
+    const insert_term_index = source.indexOf(insert_term);
+
+    if (insert_term_index !== -1) {
+        const end = insert_term_index + insert_term.length;
+        return source.slice(0, end) + value + source.slice(end);
+    }
+
+    const replace_term_index = source.indexOf(replace_term);
+
+    if (replace_term_index === -1) {
+        // not found
+        console.warn(`Neither insert term '${insert_term}', nor replacement term '${replace_term}' were found in the source`, source, value);
+        return source;
+    }
+
+
+    return source.slice(0, replace_term_index) + value + source.slice(replace_term_index + replace_term.length);
+}

package/editor/process/symbolic/makeHelperBoxGeometry.js

@@ -0,0 +1,44 @@
+import { BufferAttribute, BufferGeometry, Float32BufferAttribute } from "three";
+
+export function makeHelperBoxGeometry(sx = 1, sy = 1, sz = 1) {
+
+    const geometry = new BufferGeometry();
+
+    const dx = sx / 2;
+    const dy = sy / 2;
+    const dz = sz / 2;
+
+    const vertices = new Float32Array([
+        -dx, -dy, -dz,
+        dx, -dy, -dz,
+        dx, dy, -dz,
+        -dx, dy, -dz,
+
+        -dx, dy, dz,
+        dx, dy, dz,
+        dx, -dy, dz,
+        -dx, -dy, dz
+    ]);
+
+    geometry.setAttribute("position", new Float32BufferAttribute(vertices, 3));
+
+    geometry.setIndex(new BufferAttribute(new Uint8Array([
+        0, 1,
+        1, 2,
+        2, 3,
+        3, 0,
+
+        4, 5,
+        5, 6,
+        6, 7,
+        7, 4,
+
+
+        0, 7,
+        1, 6,
+        2, 5,
+        3, 4
+    ]), 1, false));
+
+    return geometry;
+}

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/editor/view/ecs/EntityEditor.js

@@ -38,7 +38,7 @@ import { HeadsUpDisplayController } from "./components/HeadsUpDisplayController.
 import { BlackboardController } from "./components/BlackboardController.js";
 import { GridObstacleController } from "./components/GridObstacleController.js";
 import { AttachmentSocketsController } from "./components/sockets/AttachmentSocketsController.js";
-import { ParticleEmitterSystem2 } from "../../../engine/graphics/particles/ecs/ParticleEmitterSystem2.js";
+import { ParticleEmitterSystem } from "../../../engine/graphics/particles/ecs/ParticleEmitterSystem.js";
 
 /**
  *
@@ -82,7 +82,7 @@ function prepareComponentFactory(factory, editor) {
         .register('ParticleEmitter', () => {
             const em = editor.engine.entityManager;
 
-            const particleEmitterSystem = em.getSystem(ParticleEmitterSystem2);
+            const particleEmitterSystem = em.getSystem(ParticleEmitterSystem);
 
             return new ParticleEmitterController(particleEmitterSystem);
         })

package/editor/view/ecs/components/particles/ParticleEmitterController.js

@@ -24,7 +24,7 @@ export function enumNameByValue(value, enumerable) {
 /**
  *
  * @param {ParticleEmitter} emitter
- * @param {ParticleEmitterSystem2} system
+ * @param {ParticleEmitterSystem} system
  * @param {function} op
  * @param {*} [arg0]
  */
@@ -61,7 +61,7 @@ function applyEmitterChanges(emitter, system, op, arg0) {
 export class ParticleEmitterController extends EmptyView {
     /**
      *
-     * @param {ParticleEmitterSystem2} particleEmitterSystem
+     * @param {ParticleEmitterSystem} particleEmitterSystem
      * @constructor
      */
     constructor(particleEmitterSystem) {

package/engine/EngineHarness.js

@@ -367,6 +367,7 @@ export class EngineHarness {
             sensitivity
         });
 
+        eb.add(Tag.fromJSON(['CameraController']));
         eb.add(SerializationMetadata.Transient);
 
         eb.build(ecd);

package/engine/animation/AnimationUtils.js

@@ -7,7 +7,7 @@ import { removeComponentsExcept } from "../ecs/util/removeComponentsExcept.js";
 import { createSound, createTimer } from "../EntityCreator.js";
 import Mesh from "../graphics/ecs/mesh/Mesh.js";
 import Trail2D, { Trail2DFlags } from "../graphics/ecs/trail2d/Trail2D.js";
-import { ParticleEmitterSystem2 } from "../graphics/particles/ecs/ParticleEmitterSystem2.js";
+import { ParticleEmitterSystem } from "../graphics/particles/ecs/ParticleEmitterSystem.js";
 import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
 import { ParticleEmitterFlag } from "../graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js";
 import { distributeParticlesOnObject3D } from "../graphics/particles/particular/engine/utils/distributeParticlesOnObject3D.js";
@@ -137,9 +137,9 @@ export function removeEntityWithMeshParticlesEffect(
 
     /**
      *
-     * @type {ParticleEmitterSystem2}
+     * @type {ParticleEmitterSystem}
      */
-    const sPE = entityManager.getSystem(ParticleEmitterSystem2);
+    const sPE = entityManager.getSystem(ParticleEmitterSystem);
 
     /**
      *
@@ -214,9 +214,9 @@ export function removeEntityGenericEffect(
 
     /**
      *
-     * @type {ParticleEmitterSystem2}
+     * @type {ParticleEmitterSystem}
      */
-    const sPE = engine.entityManager.getSystem(ParticleEmitterSystem2);
+    const sPE = engine.entityManager.getSystem(ParticleEmitterSystem);
 
     /**
      *

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