@woosh/meep-engine 2.37.18 → 2.38.0

package/engine/asset/loaders/gltf/extensions/MSFT_texture_dds.js

@@ -1,3 +1,5 @@
+import { REVISION } from 'three';
+
 /**
  * DDS Texture Extension
  *
@@ -28,7 +30,17 @@ export default class GLTFTextureDDSExtension {
             return null;
         }
         const extensionDef = textureDef.extensions[this.name];
-        const source = json.images[extensionDef.source];
-        return this.parser.loadTextureImage(textureIndex, source, this.ddsLoader);
+        const source_index = extensionDef.source;
+
+        const source = json.images[source_index];
+
+        if (REVISION <= 137) {
+
+            return this.parser.loadTextureImage(textureIndex, source, this.ddsLoader);
+
+        } else {
+            // API of GLTFLoader has changed after 137
+            return this.parser.loadTextureImage(textureIndex, source_index, this.ddsLoader);
+        }
     }
 }

package/engine/ecs/components/TagEditor.js

@@ -0,0 +1,15 @@
+import { ObjectEditor } from "../../../editor/ecs/component/editors/primitive/ObjectEditor.js";
+
+export class TagEditor extends ObjectEditor {
+    get schema() {
+        return {
+            additionalProperties: false,
+            properties: {
+                values: {
+                    type: Array,
+                    type_parameters: [String]
+                }
+            }
+        };
+    }
+}

package/engine/ecs/fow/FogOfWarEditor.js

@@ -0,0 +1,13 @@
+import { ObjectEditor } from "../../../editor/ecs/component/editors/primitive/ObjectEditor.js";
+
+export class FogOfWarEditor extends ObjectEditor {
+    get schema() {
+        return {
+            properties: {
+                revealAll: {
+                    type: Function
+                }
+            }
+        };
+    }
+}

package/engine/ecs/parent/ParentEntitySystem.js

@@ -162,4 +162,61 @@ export class ParentEntitySystem extends AbstractContextSystem {
 
         return parent.entity;
     }
+
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} result_offset
+     * @param {EntityComponentDataset} ecd
+     * @param {number} entity
+     * @returns {number}
+     */
+    static findChildrenOf(result, result_offset, ecd, entity) {
+        let result_cursor = result_offset;
+        ecd.traverseComponents(ParentEntity, (p, e) => {
+            if (p.entity === entity) {
+                result[result_cursor++] = e;
+            }
+        });
+
+        return result_cursor - result_offset;
+    }
+
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @param {number} root_entity
+     * @param {function(number, EntityComponentDataset)} callback
+     * @param {*} [thisArg]
+     */
+    static traverse(ecd, root_entity, callback, thisArg) {
+        traverse(ecd, root_entity, callback, thisArg);
+    }
+}
+
+/**
+ *
+ * @param {EntityComponentDataset} ecd
+ * @param {number} root_entity
+ * @param {function(number, EntityComponentDataset)} callback
+ * @param {*} [thisArg]
+ * @param {number[]} path keep track of where we came from, this is used to detect cycles
+ */
+function traverse(ecd, root_entity, callback, thisArg, path = []) {
+
+    callback.call(thisArg, root_entity, ecd);
+
+    const children = [];
+    const child_count = ParentEntitySystem.findChildrenOf(children, 0, ecd, root_entity);
+
+    for (let i = 0; i < child_count; i++) {
+        const entity = children[i];
+
+        if (path.includes(entity)) {
+            console.warn(`Loop in entity hierarchy detected: ${path.join('->')}`);
+            continue;
+        }
+
+        traverse(ecd, entity, callback, thisArg, path.concat(entity));
+    }
 }

package/engine/ecs/terrain/ecs/OffsetScaleTransform2D.d.ts

@@ -0,0 +1,6 @@
+export class OffsetScaleTransform2D {
+    scale_x: number
+    scale_y: number
+    offset_x: number
+    offset_y: number
+}

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

@@ -173,16 +173,16 @@ class Terrain {
          *
          * @type {WorkerProxy}
          */
-        this.buildWorker = makeTerrainWorkerProxy();
+        this.__buildWorker = makeTerrainWorkerProxy();
 
-        this.tiles = new TerrainTileManager({
+        this.__tiles = new TerrainTileManager({
             material: this.material,
-            buildWorker: this.buildWorker
+            buildWorker: this.__buildWorker
         });
 
-        this.tiles.tileSize.set(TILE_SIZE, TILE_SIZE);
+        this.__tiles.tileSize.set(TILE_SIZE, TILE_SIZE);
 
-        this.tiles.material.set(this.material);
+        this.__tiles.material.set(this.material);
 
         /**
          *
@@ -285,7 +285,7 @@ class Terrain {
         const material = material_handle.getValue();
         this.clouds.addMaterial(material);
 
-        this.tiles.material.set(material);
+        this.__tiles.material.set(material);
 
         this.updateMaterial();
 
@@ -314,7 +314,7 @@ class Terrain {
         // release material handle
         this.__material_reference.release();
 
-        this.tiles.dispose();
+        this.__tiles.dispose();
         this.splat.dispose();
         this.layers.dispose();
 
@@ -428,11 +428,11 @@ class Terrain {
      * @returns {boolean}
      */
     raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ) {
-        if (this.tiles === undefined) {
+        if (this.__tiles === undefined) {
             return false;
         }
 
-        return this.tiles.raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ);
+        return this.__tiles.raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ);
     }
 
     /**
@@ -443,7 +443,7 @@ class Terrain {
      * @param {function} missCallback
      */
     raycast(origin, direction, callback, missCallback) {
-        this.tiles.raycast(origin, direction, callback, missCallback);
+        this.__tiles.raycast(origin, direction, callback, missCallback);
     }
 
     /**
@@ -459,7 +459,7 @@ class Terrain {
         assert.typeOf(missCallback, 'function', 'missCallback');
         assert.typeOf(errorCallback, 'function', 'errorCallback');
 
-        this.tiles.raycastVertical(x, y, callback, missCallback);
+        this.__tiles.raycastVertical(x, y, callback, missCallback);
     }
 
     /**
@@ -470,12 +470,12 @@ class Terrain {
      * @return {boolean}
      */
     raycastVerticalFirstSync(contact, x, y) {
-        if (this.tiles === undefined) {
+        if (this.__tiles === undefined) {
             //tiles don't exist
             return false;
         }
 
-        return this.tiles.raycastVerticalFirstSync(contact, x, y);
+        return this.__tiles.raycastVerticalFirstSync(contact, x, y);
     }
 
     /**
@@ -643,7 +643,7 @@ class Terrain {
          *
          * @type {TerrainTileManager}
          */
-        const tiles = this.tiles;
+        const tiles = this.__tiles;
 
         const promisedTiles = [];
 
@@ -660,25 +660,6 @@ class Terrain {
         return Promise.all(promisedTiles);
     }
 
-    /**
-     * @deprecated use {@link #samplerHeight} instead
-     * @param {Sampler2D} v
-     */
-    set heightMap(v) {
-        this.samplerHeight = v;
-        this.updateHeightTexture();
-
-        console.warn('Deprecated');
-    }
-
-    /**
-     * @deprecated use {@link #samplerHeight} instead
-     * @return {Sampler2D}
-     */
-    get heightMap() {
-        return this.samplerHeight;
-    }
-
     updateMaterial() {
         let m = this.material;
 
@@ -724,6 +705,8 @@ class Terrain {
 
         image.width = sampler.width;
         image.height = sampler.height;
+
+        texture.needsUpdate = true;
     }
 
     /**
@@ -753,24 +736,24 @@ class Terrain {
     }
 
     startBuildService() {
-        this.buildWorker.start();
+        this.__buildWorker.start();
         this.updateWorkerHeights();
     }
 
     async updateWorkerHeights() {
         const s = this.samplerHeight;
-        const worker = this.buildWorker;
+        const worker = this.__buildWorker;
 
         await worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
 
         return await worker.computeHeightRange()
             .then(({ min, max }) => {
-                this.tiles.setHeightRange(min, max);
+                this.__tiles.setHeightRange(min, max);
             });
     }
 
     stopBuildService() {
-        this.buildWorker.stop();
+        this.__buildWorker.stop();
     }
 
     buildGridTransform() {
@@ -816,9 +799,9 @@ class Terrain {
 
         this.overlay.tileImage.set(MeepSettings.ecs.Terrain['tile-decal']);
 
-        this.tiles.totalSize.copy(this.size);
-        this.tiles.scale.set(this.gridScale, this.gridScale);
-        this.tiles.resolution.set(this.resolution);
+        this.__tiles.totalSize.copy(this.size);
+        this.__tiles.scale.set(this.gridScale, this.gridScale);
+        this.__tiles.resolution.set(this.resolution);
 
         if (this.__legacyMaterialSpec !== null) {
             this.buildFromLegacy(assetManager);
@@ -855,9 +838,9 @@ class Terrain {
          * @type {Promise<TerrainTileManager>}
          * @deprecated
          */
-        this.pTiles = Promise.resolve(this.tiles);
+        this.pTiles = Promise.resolve(this.__tiles);
 
-        this.tiles.initialize();
+        this.__tiles.initialize();
 
         this.updateMaterial();
 
@@ -866,6 +849,24 @@ class Terrain {
         this.setFlag(TerrainFlags.Built);
     }
 
+    /**
+     *
+     * @returns {Texture|null}
+     */
+    get aoMap() {
+        const ref = this.__material_reference;
+        if (ref === null) {
+            return null;
+        }
+        const mat = ref.getValue();
+
+        if (mat === null) {
+            return null;
+        }
+
+        return mat.uniforms.aoMap.value;
+    }
+
     /**
      *
      * @param {number} quality resolution in texels per grid cell (4 = 4x4 light map texels per single grid cell)
@@ -896,7 +897,7 @@ class Terrain {
             texture,
             heightSampler: this.samplerHeight,
             worldSize: new Vector2(size_x * this.gridScale, size_y * this.gridScale),
-            resolution: new Vector2(size_x * quality, size_y *quality)
+            resolution: new Vector2(size_x * quality, size_y * quality)
         });
 
 

package/engine/ecs/terrain/ecs/TerrainSystem.js

@@ -131,7 +131,7 @@ class TerrainSystem extends System {
 
         component.link(this.graphics);
 
-        const bvh = component.tiles.bvh;
+        const bvh = component.__tiles.bvh;
 
 
         //record entity for editor
@@ -193,7 +193,7 @@ class TerrainSystem extends System {
         assert.notEqual(terrain, null, 'terrain is null');
         assert.notEqual(terrain, undefined, 'terrain is undefined');
 
-        const tileManager = terrain.tiles;
+        const tileManager = terrain.__tiles;
         if (tileManager !== undefined) {
             CameraSystem.getActiveFrustums(ecd, function (frustums) {
                 tileManager.bvh.threeTraverseFrustumsIntersections(frustums, function (leafNode) {

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

@@ -31,7 +31,7 @@ export class TerrainLayer {
          *
          * @type {String}
          */
-        this.textureDiffuseURL = null;
+        this.textureDiffuseURL = "";
 
         /**
          *

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

@@ -299,20 +299,26 @@ export class SplatMapping {
      */
     sampleWeight(u, v, materialIndex) {
 
+        return this.getLayerWeightSampler(materialIndex).sampleChannelBilinearUV(u, v, 0);
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @returns {Sampler2D}
+     */
+    getLayerWeightSampler(index) {
+
         const width = this.size.x;
         const height = this.size.y;
 
         const layerSize = width * height;
 
-        const startAddress = layerSize * materialIndex;
+        const startAddress = layerSize * index;
         const endAddress = startAddress + layerSize;
 
         //build a sampler for the layer
-        const sampler = new Sampler2D(this.weightData.subarray(startAddress, endAddress), 1, width, height);
-
-        const result = sampler.sampleChannelBilinear(u * width, v * height, 0);
-
-        return result;
+        return new Sampler2D(this.weightData.subarray(startAddress, endAddress), 1, width, height);
     }
 
     /**
@@ -429,7 +435,12 @@ export class SplatMapping {
         const startAddress = index * layerByteSize;
         const endAddress = (index + 1) * layerByteSize;
 
-        const image = this.weightTexture.image;
+        const weightTexture = this.weightTexture;
+
+        // release memory
+        weightTexture.dispose();
+
+        const image = weightTexture.image;
 
         const oldData = image.data;
 
@@ -444,7 +455,7 @@ export class SplatMapping {
 
         image.depth = this.depth;
 
-        this.weightTexture.needsUpdate = true;
+        weightTexture.needsUpdate = true;
 
         return true;
     }
@@ -471,6 +482,8 @@ export class SplatMapping {
     }
 
     addWeightLayer() {
+        // release currently held GPU memory
+        this.weightTexture.dispose();
 
         const layerByteSize = this.size.x * this.size.y;
 
@@ -500,29 +513,14 @@ export class SplatMapping {
 
         this.depth = depth;
 
-        if (width !== oldWidth || height !== oldHeight) {
-
+        if (width !== oldWidth || height !== oldHeight || depth !== oldDepth) {
             this.size.set(width, height);
-
-            const materialImage = this.materialTexture.image;
-
-            const oldMaterialData = materialImage.data;
-
-            materialImage.width = width;
-            materialImage.height = height;
-            materialImage.data = new Uint8Array(width * height * 4);
-
-            const source = new Sampler2D(oldMaterialData, 4, oldWidth, oldHeight);
-            const target = new Sampler2D(materialImage.data, 4, width, height);
-
-            scaleSampler2D(source, target);
-
-            this.weightTexture.needsUpdate = true;
         }
 
-        if (width !== oldWidth || height !== oldHeight || depth !== oldDepth) {
+        const weightImage = this.weightTexture.image;
 
-            const weightImage = this.weightTexture.image;
+        if (weightImage.width !== width || weightImage.height !== height || weightImage.depth !== depth) {
+            // this extra check is in case dimensions were modified from outside
 
             const oldWeightData = weightImage.data;
 
@@ -543,7 +541,7 @@ export class SplatMapping {
             }
 
             this.weightTexture.needsUpdate = true;
-        }
 
+        }
     }
 }