@woosh/meep-engine 2.39.4 → 2.39.7

package/core/binary/BinaryBuffer.js

@@ -627,6 +627,7 @@ const MAX_SAFE_UINT_VAR = 2147483647;
  * @param {number} value
  */
 BinaryBuffer.prototype.writeUintVar = function (value) {
+    assert.isNonNegativeInteger(value, 'value');
     assert.ok(value <= MAX_SAFE_UINT_VAR, `value=[${value}] exceeds maximum safe limit[=${MAX_SAFE_UINT_VAR}]`);
 
     let first = true;

package/core/geom/3d/topology/bounds/{computeTraingleClusterNormalBoundingCone.js → computeTriangleClusterNormalBoundingCone.js}

@@ -11,7 +11,7 @@ import { v3_angle_between } from "../../../v3_angle_between.js";
  * @param {ConicRay} result
  * @param {Iterable<TopoTriangle>} faces
  */
-export function computeTraingleClusterNormalBoundingCone(result, faces) {
+export function computeTriangleClusterNormalBoundingCone(result, faces) {
     const normal_data = [];
     let normal_count = 0;
 
@@ -45,6 +45,13 @@ export function computeTraingleClusterNormalBoundingCone(result, faces) {
 
     const miniball_center = miniball.center();
 
+    if (Number.isNaN(miniball_center[0]) || Number.isNaN(miniball_center[1]) || Number.isNaN(miniball_center[2])) {
+        // something went wrong, center is undefined, fall-back to an open cone
+        result_direction.set(1, 0, 0);
+        result.angle = Math.PI;
+        return;
+    }
+
     result_direction.readFromArray(miniball_center, 0);
     const center_vector_magnitude = result_direction.length();
 

package/core/math/FLT_EPSILON_32.js

@@ -0,0 +1,7 @@
+/**
+ * Smallest safe increment for a Float32
+ * @see https://www.cplusplus.com/reference/cfloat/
+ * @see https://bitbashing.io/comparing-floats.html
+ * @type {number}
+ */
+export const FLT_EPSILON_32 = 1.192092896E-7;

package/core/math/random/seededRandom_Mulberry32.js

@@ -1,7 +1,7 @@
 /**
  *
  * @param {number} [seed]
- * @returns {function():number|{setCurrentSeed(v:number):void,getCurrentSeed():number}}
+ * @returns {(function():number)|{setCurrentSeed:( function(v:number):void),getCurrentSeed:(function():number)}}
  */
 export function seededRandom_Mulberry32(seed = 0) {
     let _seed = seed;

package/core/model/stat/LinearModifier.js

@@ -124,4 +124,11 @@ class LinearModifier {
     }
 }
 
+/**
+ * @readonly
+ * @type {LinearModifier}
+ */
+LinearModifier.CONSTANT_ONE = Object.freeze(new LinearModifier(0, 1));
+LinearModifier.CONSTANT_ZERO = Object.freeze(new LinearModifier(0, 0));
+
 export default LinearModifier;

package/core/process/task/RemainingTimeEstimator.js

@@ -0,0 +1,49 @@
+export class RemainingTimeEstimator {
+    /**
+     *
+     * @param {number} sampleCount
+     * @constructor
+     */
+    constructor(sampleCount) {
+        this.sampleCount = sampleCount;
+        this.rates = new Float32Array(sampleCount);
+        this.cursor = 0;
+    }
+
+    /**
+     *
+     * @param {number} timeElapsed
+     * @param {number} progress
+     */
+    update(timeElapsed, progress) {
+        const index = this.cursor;
+        this.cursor = (this.cursor + 1) % this.sampleCount;
+
+        const rate = progress / timeElapsed;
+
+        this.rates[index] = rate;
+    }
+
+    /**
+     *
+     * @param {number} currentProgress
+     * @returns {number}
+     */
+    estimate(currentProgress) {
+        let rateSum = 0;
+
+        for (let i = 0; i < this.sampleCount; i++) {
+            rateSum += this.rates[i];
+        }
+
+        const rate = rateSum / this.sampleCount;
+
+        if (rate === 0) {
+            return Infinity;
+        }
+
+        const result = (1 - currentProgress) / rate;
+
+        return result;
+    }
+}

package/core/process/task/Task.js

@@ -114,7 +114,7 @@ class Task {
             //is a task group, add all children instead
             this.addDependencies(task.children);
 
-        } else {
+        } else if (task.isTask) {
 
             //check that the dependency is not registered yet
             if (this.dependencies.indexOf(task) === -1) {
@@ -123,6 +123,8 @@ class Task {
 
             }
 
+        } else {
+            throw new Error('Expected a Task or a TaskGroup, got something else');
         }
 
         return this;

package/engine/Engine.js

@@ -14,12 +14,10 @@ import KeyboardDevice from "./input/devices/KeyboardDevice.js";
 import Grid from './grid/Grid.js';
 import Preloader from "./asset/preloader/Preloader.js";
 import SceneManager from "./scene/SceneManager.js";
-import TaskProgressView from '../view/common/TaskProgressView.js';
 import CompressionService from "./compression/CompressionService.js";
 
 import GUIEngine from './ui/GUIEngine.js';
 import { EntityManager } from "./ecs/EntityManager.js";
-import { AssetLoaderStatusView } from "../view/asset/AssetLoaderStatusView.js";
 import ObservedBoolean from "../core/model/ObservedBoolean.js";
 import Vector1 from "../core/geom/Vector1.js";
 import { ViewStack } from "../view/elements/navigation/ViewStack.js";
@@ -407,83 +405,6 @@ class Engine {
         }
     }
 
-    makeLoadingScreen(task) {
-        const localization = this.localization;
-
-        const taskProgressView = new TaskProgressView({ task, localization });
-        taskProgressView.el.classList.add('loading-screen');
-
-        //add asset manager loading progress
-        const loaderStatusView = new AssetLoaderStatusView({ assetManager: this.assetManager, localization });
-        taskProgressView.addChild(loaderStatusView);
-        taskProgressView.link();
-
-        let __renderingEnabled = this.renderingEnabled;
-        this.renderingEnabled = false;
-
-
-        const domParent = document.body;
-
-        domParent.appendChild(taskProgressView.el);
-
-        // suspend rendering
-        const graphics = this.graphics;
-        const _autoDraw = graphics.autoDraw;
-
-        graphics.autoDraw = false;
-
-        const cleanup = () => {
-            domParent.removeChild(taskProgressView.el);
-
-            taskProgressView.unlink();
-
-            this.renderingEnabled = __renderingEnabled;
-
-            // restore rendering
-            graphics.autoDraw = _autoDraw;
-        };
-
-        task.join(cleanup, printError);
-    }
-
-    /**
-     *
-     * @param {Task|TaskGroup} task
-     * @returns {Promise<any>}
-     */
-    loadSlowTask(task) {
-        assert.defined(task, 'task');
-        assert.notNull(task, 'task');
-
-        const engine = this;
-
-        return new Promise(function (resolve, reject) {
-
-            function cleanup() {
-                simulator.resume();
-            }
-
-            function success() {
-                logger.info("Task finished");
-                cleanup();
-                resolve();
-            }
-
-            function failure(e) {
-                printError(e);
-                cleanup();
-                reject();
-            }
-
-            const simulator = engine.ticker;
-            simulator.pause();
-
-            task.join(success, failure);
-
-            engine.makeLoadingScreen(task);
-        });
-    }
-
     /**
      * Startup
      * @returns {Promise}

package/engine/asset/AssetManager.d.ts

@@ -2,8 +2,11 @@ import {AssetLoader} from "./loaders/AssetLoader";
 import {Asset} from "./Asset";
 import {CrossOriginConfig} from "./CORS/CrossOriginConfig";
 import {AssetTransformer} from "./AssetTransformer";
+import Engine from "../Engine";
 
 export class AssetManager {
+    constructor(engine: Engine)
+
     public readonly crossOriginConfig: CrossOriginConfig
 
     promise<T>(path: string, type: string): Promise<Asset<T>>

package/engine/asset/AssetManager.js

@@ -12,6 +12,7 @@ import { HashSet } from "../../core/collection/HashSet.js";
 import { CrossOriginConfig } from "./CORS/CrossOriginConfig.js";
 import { array_remove_element } from "../../core/collection/array/array_remove_element.js";
 import { AssetDescription } from "./AssetDescription.js";
+import { noop } from "../../core/function/Functions.js";
 
 /**
  *
@@ -147,14 +148,14 @@ export class AssetManager {
     }
 
     /**
-     *
+     * @template T
      * @param {String} path
      * @param {String} type
-     * @param {function(asset:Asset)} callback
-     * @param {function(*)} failure
+     * @param {function(asset:Asset<T>)} callback
+     * @param {function(*)} [failure]
      * @param {function(loaded:number, total:number)} [progress]
      */
-    get(path, type, callback, failure, progress) {
+    get(path, type, callback, failure = console.error, progress = noop) {
         if (typeof path !== "string") {
             throw new Error("Path must be string. Path = " + JSON.stringify(path));
         }

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

@@ -647,6 +647,39 @@ class Terrain {
         );
 
         this.layers.updateLayerScales(this.size.x * this.gridScale, this.size.y * this.gridScale);
+
+        m.uniformsNeedUpdate = true;
+    }
+
+    /**
+     *
+     * @param {TerrainLayer} layer
+     */
+    addLayer(layer) {
+        const layers = this.layers;
+        const index = layers.addLayer(layer);
+
+        // expand splat
+        this.splat.addWeightLayer();
+
+        if (this.getFlag(TerrainFlags.Built)) {
+            // terrain is built, need to do a few updates
+
+            layers.buildTexture();
+
+            layer.loadTextureData(this.__assetManager).then(() => {
+                // verify that layer is still present
+                if (layers.get(index) !== layer) {
+                    return;
+                }
+
+                layers.writeLayerDataIntoTexture(index);
+            });
+
+            this.updateMaterial();
+        }
+
+        return index;
     }
 
     /**

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

@@ -87,6 +87,19 @@ export class TerrainLayer {
         return r;
     }
 
+    /**
+     *
+     * @param {TerrainLayerDescription} d
+     * @returns {TerrainLayer}
+     */
+    static fromDescription(d) {
+        return TerrainLayer.from(
+            d.diffuse,
+            d.size.x,
+            d.size.y
+        );
+    }
+
     /**
      *
      * @param {AssetManager} assetManager

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

@@ -23,6 +23,7 @@ import { BinaryClassSerializationAdapter } from "../../../storage/binary/BinaryC
 import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
 import { invokeObjectEquals } from "../../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../../core/model/object/invokeObjectHash.js";
+import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
 
 class ScaledTextureKey {
     constructor() {
@@ -145,7 +146,7 @@ export class TerrainLayers {
         this.texture.encoding = LinearEncoding;
         this.texture.internalFormat = 'RGB8';
 
-        this.scalesTexture = new DataTexture(new Float32Array(512), 256, 1, RGFormat, FloatType);
+        this.scalesTexture = new DataTexture(new Float32Array(64), 32, 1, RGFormat, FloatType);
 
         this.scalesTexture.wrapS = ClampToEdgeWrapping;
         this.scalesTexture.wrapT = ClampToEdgeWrapping;
@@ -185,7 +186,7 @@ export class TerrainLayers {
 
         const scaleTextureDataLength = n * 2;
 
-        if (image.data.length !== scaleTextureDataLength) {
+        if (image.data.length < scaleTextureDataLength) {
             // dispose of old texture data
             texture.dispose();
 
@@ -256,6 +257,43 @@ export class TerrainLayers {
         return this.layers.get(index);
     }
 
+    /**
+     *
+     * @param {TerrainLayerDescription} description
+     * @returns {number}
+     */
+    findIndexByDescription(description) {
+        assert.defined(description, 'description');
+
+        const layers = this.layers;
+        const n = layers.length;
+
+        for (let i = 0; i < n; i++) {
+            const terrainLayer = layers.get(i);
+
+            if (
+                terrainLayer.size.equals(description.size)
+                && terrainLayer.textureDiffuseURL === description.diffuse
+            ) {
+                return i;
+            }
+        }
+
+        // not found
+        return -1;
+    }
+
+    /**
+     *
+     * @param {string} url
+     * @returns {number}
+     */
+    findIndexByDiffuseTextureURL(url) {
+        assert.isString(url, 'url');
+
+        return this.layers.findIndex(t => t.textureDiffuseURL === url);
+    }
+
     /**
      *
      * @return {number}
@@ -397,6 +435,10 @@ export class TerrainLayers {
         //build an array to hold texture array
         const arrayData = new Uint8Array(size_x * size_y * 3 * layerCount);
 
+        if (image.width === size_x && image.height === size_y) {
+            // dimensions preserved, copy old data
+            typed_array_copy(image.data, arrayData);
+        }
 
         image.data = arrayData;
         image.width = size_x;

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

@@ -7,6 +7,7 @@ import { assert } from "../../../../../core/assert.js";
 import { scaleSampler2D } from "../../../../graphics/texture/sampler/scaleSampler2D.js";
 import { countTask } from "../../../../../core/process/task/TaskUtils.js";
 import { array_copy } from "../../../../../core/collection/array/copyArray.js";
+import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
 
 
 /**
@@ -478,12 +479,19 @@ export class SplatMapping {
             weightImage.depth = depth;
             weightImage.data = new Uint8Array(newLayerSize * depth);
 
-            for (let d = 0; d < min2(depth, oldDepth); d++) {
+            if (oldWidth === width && oldHeight === height) {
+                // dimensions haven't changed, we can copy data directly
+                typed_array_copy(oldWeightData, weightImage.data);
+            } else {
 
-                const source = new Sampler2D(oldWeightData.subarray(d * oldLayerSize, (d + 1) * oldLayerSize), 1, oldWidth, oldHeight);
-                const target = new Sampler2D(weightImage.data.subarray(d * newLayerSize, (d + 1) * newLayerSize), 1, width, height);
+                // different dimensions, copy layer-by-layer
+                for (let d = 0; d < min2(depth, oldDepth); d++) {
 
-                scaleSampler2D(source, target);
+                    const source = new Sampler2D(oldWeightData.subarray(d * oldLayerSize, (d + 1) * oldLayerSize), 1, oldWidth, oldHeight);
+                    const target = new Sampler2D(weightImage.data.subarray(d * newLayerSize, (d + 1) * newLayerSize), 1, width, height);
+
+                    scaleSampler2D(source, target);
+                }
             }
 
             weightTexture.needsUpdate = true;

package/engine/graphics/ecs/path/testPathDisplaySystem.js

@@ -44,7 +44,6 @@ import { PathDisplaySystem } from "./PathDisplaySystem.js";
 import { PathDisplay } from "./PathDisplay.js";
 import { PathDisplayType } from "./PathDisplayType.js";
 import EntityBuilder from "../../../ecs/EntityBuilder.js";
-import { RibbonPathStyle } from "./ribbon/RibbonPathStyle.js";
 import { enableEditor } from "../../../../editor/enableEditor.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { GLTFAssetLoader } from "../../../asset/loaders/GLTFAssetLoader.js";
@@ -70,6 +69,7 @@ import { BasicMaterialDefinition } from "./tube/BasicMaterialDefinition.js";
 
 import '../../../../../../../css/game.scss';
 import { GizmoRenderingPlugin } from "../../render/gizmo/GizmoRenderingPlugin.js";
+import { PathNormalType } from "./tube/PathNormalType.js";
 
 const engineHarness = new EngineHarness();
 
@@ -303,7 +303,9 @@ function sample_style_entity() {
 }
 
 function sample_style_tube() {
+
     const style = new TubePathStyle();
+    style.path_normal_type = PathNormalType.FixedStart;
 
     style.color.setRGB(1, 1, 1);
 
@@ -333,7 +335,7 @@ function sample_style_tube() {
         style.color.setHSV(0, 1, 0.9);
     }
 
-    make_basic(style);
+    make_standard(style);
 
     style.width = 0.5;
     style.cast_shadow = true;
@@ -379,70 +381,73 @@ function sample_style_tube() {
     return style;
 }
 
+/**
+ *
+ * @param {number[]} points
+ * @param {InterpolationType} [interp]
+ * @param {Vector3} [offset]
+ * @returns {EntityBuilder}
+ */
+function makePath({
+                      points,
+                      interp = InterpolationType.Linear,
+                      offset = Vector3.zero
+                  }) {
+    const _p = new Path();
 
-function main(engine) {
-    EngineHarness.buildBasics({ engine });
+    _p.interpolation = interp;
 
-    const _p = new Path();
-    _p.interpolation = InterpolationType.CatmullRom;
-    // _p.interpolation = InterpolationType.Linear;
-
-    // _p.setPositionsFromVectorArray(Path.smoothPath([
-    //     new Vector3(3, 1, 1),
-    //     new Vector3(3, 1, 3),
-    //     new Vector3(7, 1, 3),
-    //     new Vector3(7, 1, 7),
-    //     new Vector3(3, 1, 7),
-    //     new Vector3(3, 1, 8),
-    // ], 50));
-
-    _p.setPositionsFromVectorArray([
-        new Vector3(3, 1, 1),
-        new Vector3(3, 1, 3),
-        new Vector3(7, 1, 3),
-        new Vector3(7, 1, 7),
-        new Vector3(3, 1, 7),
-        new Vector3(3, 1, 8),
-    ]);
-
-
-    // _p.setPositionsFromVectorArray([
-    //     new Vector3(1, 1, 3),
-    //     new Vector3(3, 1, 3),
-    //     new Vector3(3, 1, 7),
-    //     new Vector3(7, 1, 7),
-    //     new Vector3(7, 1, 3),
-    //     new Vector3(8, 1, 3),
-    // ]);
-    // _p.reverse();
-
-    const trailPathStyle = new RibbonPathStyle();
-    trailPathStyle.material.diffuse = "data/textures/trail/Circle_04.png";
-    trailPathStyle.resolution = 10;
-    trailPathStyle.thickness = 0.1;
+    const pk = points.length / 3;
+
+    _p.setPointCount(pk);
+    for (let i = 0; i < pk; i++) {
+        const i3 = i * 3;
+        _p.setPosition(i,
+            points[i3] + offset.x,
+            points[i3 + 1] + offset.y,
+            points[i3 + 2] + offset.z
+        );
+    }
 
     const pathDisplay = new PathDisplay();
     pathDisplay.specs.push(
-        // PathDisplaySpec.from(
-        //     PathDisplayType.Ribbon,
-        //     trailPathStyle
-        // ),
-        // PathDisplaySpec.from(
-        //     PathDisplayType.Entity,
-        //     sample_style_entity()
-        // ),
         PathDisplaySpec.from(
             PathDisplayType.Tube,
             sample_style_tube()
         )
     );
 
-
-    new EntityBuilder()
+    return new EntityBuilder()
         .add(_p)
         .add(pathDisplay)
-        .add(Highlight.fromOne(0, 1, 1, 1))
-        .build(engine.entityManager.dataset);
+        .add(Highlight.fromOne(0, 1, 1, 1));
+
+}
+
+function main(engine) {
+    EngineHarness.buildBasics({ engine });
+
+    makePath({
+        points: [
+            3, 1, 1,
+            3, 1, 3,
+            7, 1, 3,
+            7, 1, 7,
+            3, 1, 7,
+            3, 1, 8
+        ],
+        interp: InterpolationType.Linear
+    }).build(engine.entityManager.dataset);
+
+    makePath({
+        points: [
+            17.600000381469727, 3.2100000381469727, -16.34000015258789,
+            17.84000015258789, 4.559999942779541, -10.029999732971191,
+            16.979999542236328, 3.130000114440918, -8.25,
+            16.719999313354492, 3.130000114440918, -6.889999866485596
+        ],
+        interp: InterpolationType.Linear
+    }).build(engine.entityManager.dataset);
 }
 
 init(engineHarness);

package/engine/graphics/ecs/path/tube/PathNormalType.d.ts

@@ -0,0 +1,4 @@
+export enum PathNormalType {
+    Automatic = "auto",
+    FixedStart = "fixed-start"
+}

package/engine/graphics/ecs/path/tube/PathNormalType.js

@@ -0,0 +1,11 @@
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const PathNormalType = {
+    Automatic: "auto",
+    /**
+     * Start of the path has a fixed normal, this will affect all normals along the path too
+     */
+    FixedStart: "fixed-start"
+};

package/engine/graphics/ecs/path/tube/TubePathStyle.d.ts

@@ -3,6 +3,8 @@ import {TubeMaterialType} from "./TubeMaterialType";
 import {StandardMaterialDefinition} from "./StandardMaterialDefinition";
 import {MatcapMaterialDefinition} from "./MatcapMaterialDefinition";
 import {CapType} from "./CapType";
+import Vector3 from "../../../../../core/geom/Vector3";
+import {PathNormalType} from "./PathNormalType";
 
 export class TubePathStyle {
     public color: Color
@@ -28,4 +30,6 @@ export class TubePathStyle {
     public receive_shadow: boolean
     public path_mask: number[]
     public cap_type: CapType
+    public path_normal: Vector3
+    public path_normal_type: PathNormalType
 }