@woosh/meep-engine 2.47.3 → 2.47.10

package/src/engine/asset/PendingAsset.js

@@ -0,0 +1,61 @@
+import BoundedValue from "../../core/model/BoundedValue.js";
+import { AssetLoadState } from "./AssetLoadState.js";
+
+export class PendingAsset {
+    /**
+     *
+     * @param {AssetDescription} description
+     * @constructor
+     */
+    constructor(description) {
+        /**
+         *
+         * @type {AssetDescription}
+         */
+        this.description = description;
+
+        /**
+         *
+         * @type {AssetRequest[]}
+         */
+        this.requests = [];
+
+        /**
+         *
+         * @type {BoundedValue}
+         */
+        this.progress = new BoundedValue(0, 0);
+
+        /**
+         *
+         * @type {AssetLoadState|number}
+         */
+        this.state = AssetLoadState.Initial;
+    }
+
+    /**
+     * Returns aggregated priority of the pending asset based on highest priority of associated requests
+     * @return {number}
+     */
+    get priority() {
+        let max_priority = 0;
+
+        const requests = this.requests;
+        const n = requests.length;
+
+        if (n > 0) {
+            max_priority = requests[0].priority;
+        }
+
+        for (let i = 1; i < n; i++) {
+            const request = requests[i];
+            const priority = request.priority;
+
+            if (priority > max_priority) {
+                max_priority = request;
+            }
+        }
+
+        return max_priority;
+    }
+}

package/src/engine/asset/loaders/GLTFAssetLoader.js

@@ -2,7 +2,6 @@ import { Transform } from "../../ecs/transform/Transform.js";
 import { Asset } from "../Asset.js";
 import { prepareMaterial, prepareObject } from "../../graphics/three/ThreeFactory.js";
 import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { three_computeObjectBoundingBox } from "../../ecs/systems/RenderSystem.js";
 import { AABB3 } from "../../../core/bvh2/aabb3/AABB3.js";
 import { StaticMaterialCache } from "./material/StaticMaterialCache.js";
 import { DDSLoader } from "three/examples/jsm/loaders/DDSLoader.js";
@@ -28,6 +27,7 @@ import { traverseThreeObject } from "../../graphics/ecs/highlight/renderer/trave
 import { computeTextureHash } from "./material/computeTextureHash.js";
 import { computeTextureEquality } from "./material/computeTextureEquality.js";
 import { async_traverse_three_object } from "./async_traverse_three_object.js";
+import { three_computeObjectBoundingBox } from "../../graphics/three/three_computeObjectBoundingBox.js";
 
 const animationOptimizer = new AnimationOptimizer();
 const materialCache = StaticMaterialCache.Global;

package/src/engine/ecs/foliage/InstancedFoliage.js

@@ -17,7 +17,7 @@ import {
 } from "../../graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.js";
 import { serializeRowFirstTable } from "../../../core/collection/table/serializeRowFirstTable.js";
 import { deserializeRowFirstTable } from "../../../core/collection/table/deserializeRowFirstTable.js";
-import { aabb3_from_v3_array_transformed } from "../../../core/bvh2/aabb3/aabb3_from_v3_array_transformed.js";
+import { aabb3_from_v3_array_transformed } from "../../../core/geom/3d/aabb/aabb3_from_v3_array_transformed.js";
 import { ViewState } from "./ViewState.js";
 import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
 

package/src/engine/ecs/storage/BinaryBufferSerializer.js

@@ -4,6 +4,7 @@ import { BinaryCollectionSerializer } from "./binary/collection/BinaryCollection
 import { COMPONENT_SERIALIZATION_TRANSIENT_FIELD } from "./COMPONENT_SERIALIZATION_TRANSIENT_FIELD.js";
 import { currentTimeInSeconds } from "../../Clock.js";
 import { BinaryObjectSerializationAdapter } from "./binary/object/BinaryObjectSerializationAdapter.js";
+import { logger } from "../../logging/GlobalLogger.js";
 
 /**
  * @template T
@@ -112,7 +113,10 @@ class BinaryBufferSerializer {
             }
 
             collectionSerializer.setClass(className);
-            collectionSerializer.initialize({
+
+            const problemLog = [];
+
+            const initialized = collectionSerializer.initialize({
                 /**
                  *
                  * @param {string} className
@@ -121,9 +125,17 @@ class BinaryBufferSerializer {
                  */
                 adapterOptionsSupplier(className, klass, adapter) {
                     return [engine, objectAdapter];
+                },
+                problemConsumer(message) {
+                    problemLog.push(message);
                 }
             });
 
+            if (!initialized) {
+                logger.error(`Failed to initialize serializer for class '${className}': ${problemLog.join('; ')}`)
+                continue;
+            }
+
             const __start_time = currentTimeInSeconds();
 
             let lastEntity = 0;

package/src/engine/ecs/storage/binary/collection/BinaryCollectionSerializer.js

@@ -127,23 +127,28 @@ export class BinaryCollectionSerializer {
     /**
      *
      * @param {function(string,Class, BinaryClassSerializationAdapter):[]} [adapterOptionsSupplier]
+     * @param {function(string):*} [problemConsumer]
+     * @returns {boolean}
      */
     initialize({
-                   adapterOptionsSupplier = returnEmptyArray
+                   adapterOptionsSupplier = returnEmptyArray,
+        problemConsumer = console.warn
                } = {}) {
 
-        assert.typeOf(adapterOptionsSupplier, 'function', 'adapterOptionsSupplier');
+        assert.isFunction(adapterOptionsSupplier,  'adapterOptionsSupplier');
 
         const className = this.className;
 
-        assert.typeOf(className, 'string', 'className');
+        assert.isString(className, 'className');
 
         const registry = this.registry;
 
         const adapter = registry.getAdapter(className);
 
         if (adapter === undefined) {
-            throw new Error(`No adapter for class '${className}'`);
+            problemConsumer(`No adapter for class '${className}'`);
+
+            return false;
         }
 
         this.adapter = adapter;
@@ -181,6 +186,8 @@ export class BinaryCollectionSerializer {
 
         //clear dictionary
         this.dictionary.clear();
+
+        return true;
     }
 
     finalize() {

package/src/engine/ecs/storage/binary/object/BinaryObjectSerializationAdapter2.js

@@ -0,0 +1,54 @@
+export class BinaryObjectSerializationAdapter2 {
+    /**
+     *
+     * @type {BinarySerializationRegistry|null}
+     */
+    #registry = null
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Object} object
+     * @param {Object} schema
+     */
+    serialize(buffer, object, schema) {
+        const typeName = object.constructor.typeName;
+
+        const nativeAdapter = this.#registry.getAdapter(typeName);
+
+        // TODO write a header so we can reconstruct the serialization schema on the other side
+
+        if (nativeAdapter !== undefined) {
+            // serialize with native
+            nativeAdapter.serialize(buffer, object);
+            return;
+        }
+
+        for (const property in schema) {
+
+            const field_schema = schema[property];
+
+            const actual_value = object[field_schema];
+
+            this.serialize(buffer, actual_value, field_schema);
+        }
+
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Object} object
+     */
+    deserialize(buffer, object) {
+
+        // read header
+
+    }
+}
+
+/**
+ * @readonly
+ * @type {number}
+ */
+BinaryObjectSerializationAdapter2.prototype.version = 0;

package/src/engine/ecs/systems/RenderSystem.js

@@ -5,44 +5,12 @@ import { System } from '../System.js';
 import Renderable from '../components/Renderable.js';
 import { Transform } from '../transform/Transform.js';
 import { SignalBinding } from "../../../core/events/signal/SignalBinding.js";
-import { Box3 } from "three";
 import { RenderableFlags } from "../components/RenderableFlags.js";
 import { rootObject3DFastMatrixUpdate } from "../../graphics/ecs/mesh/rootObject3DFastMatrixUpdate.js";
 import { updateNodeByTransformAndBBB } from "../../graphics/ecs/mesh/updateNodeByTransformAndBBB.js";
+import { three_computeObjectBoundingBox } from "../../graphics/three/three_computeObjectBoundingBox.js";
 
 
-/**
- *
- * @param {Object3D} object
- * @param {AABB3} result
- */
-export function three_computeObjectBoundingBox(object, result) {
-    const _sX = object.scale.x;
-    const _sY = object.scale.y;
-    const _sZ = object.scale.z;
-
-    object.scale.set(1, 1, 1);
-
-    const box3 = new Box3();
-
-    box3.expandByObject(object);
-
-    object.scale.set(_sX, _sY, _sZ);
-
-    const min = box3.min;
-    const max = box3.max;
-
-    result.setBounds(
-        min.x,
-        min.y,
-        min.z,
-        max.x,
-        max.y,
-        max.z
-    );
-
-}
-
 /**
  * @deprecated use {@link ShadedGeometry} instead
  */

package/src/engine/ecs/terrain/ecs/makeTerrainWorkerProxy.js

@@ -1,6 +1,4 @@
 import WorkerBuilder from "../../../../core/process/worker/WorkerBuilder.js";
-import { sampler2d_channel_compute_max } from "../../../graphics/texture/sampler/sampler2d_channel_compute_max.js";
-import { sampler2d_channel_compute_min } from "../../../graphics/texture/sampler/sampler2d_channel_compute_min.js";
 
 /**
  *
@@ -29,8 +27,8 @@ export function makeTerrainWorkerProxy() {
 
             useSampler(function (sampler) {
 
-                const min = sampler2d_channel_compute_min(sampler);
-                const max = sampler2d_channel_compute_max(sampler);
+                const min = Lib.sampler2d_channel_compute_min(sampler);
+                const max = Lib.sampler2d_channel_compute_max(sampler);
 
                 resolve({
                     min: min.value,

package/src/engine/ecs/terrain/tiles/TileBuildWorker.js

@@ -6,12 +6,17 @@ import * as BinaryBVHFromBufferGeometry from '../../../graphics/geometry/bvh/buf
 import { Sampler2D } from '../../../graphics/texture/sampler/Sampler2D.js';
 import BufferedGeometryArraysBuilder from '../BufferedGeometryArraysBuilder.js';
 import { tensionOptimizeUV } from "../util/tensionOptimizeUV.js";
+import { sampler2d_channel_compute_min } from "../../../graphics/texture/sampler/sampler2d_channel_compute_min.js";
+import { sampler2d_channel_compute_max } from "../../../graphics/texture/sampler/sampler2d_channel_compute_max.js";
+
 
 self.Lib = {
     BinaryBVHFromBufferGeometry,
     Sampler2D,
     BufferedGeometryArraysBuilder,
-    tensionOptimizeUV
+    tensionOptimizeUV,
+    sampler2d_channel_compute_min,
+    sampler2d_channel_compute_max
 };
 
 

package/src/engine/graphics/GraphicsEngine.js

@@ -355,7 +355,11 @@ GraphicsEngine.prototype.start = function () {
         antialias: true,
         logarithmicDepthBuffer: false,
         canvas,
-        context
+        context,
+        /**
+         * @see https://registry.khronos.org/webgl/specs/latest/1.0/#5.2
+         */
+        powerPreference:"high-performance"
     };
 
     const webGLRenderer = this.renderer = new WebGLRenderer(rendererParameters);

package/src/engine/graphics/ecs/decal/v2/Decal.js

@@ -1,3 +1,6 @@
+import { Color } from "../../../../../core/color/Color.js";
+import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
+
 export class Decal {
     constructor() {
         /**
@@ -12,6 +15,12 @@ export class Decal {
          */
         this.priority = 0;
 
+        /**
+         * Color of the decal will be pre-multiplied by this
+         * @type {Color}
+         */
+        this.color = new Color(1, 1, 1, 1);
+
         /**
          * Internal transient reference to loaded asset
          * @type {Sampler2D|null}
@@ -26,15 +35,26 @@ export class Decal {
         this.__cached_uri = null;
     }
 
+    static fromJSON(j) {
+        const r = new Decal();
+
+        r.fromJSON(j);
+
+        return r;
+    }
+
     toJSON() {
         return {
             uri: this.uri,
-            priority: this.priority
+            priority: this.priority,
+            color: this.color.toCssRGBAString()
         };
     }
 
     fromJSON({
-                 uri, priority = 0
+                 uri,
+                 priority = 0,
+                 color
              }) {
         this.uri = uri;
         this.priority = priority;
@@ -44,6 +64,28 @@ export class Decal {
             this.__cached_sampler = null;
             this.__cached_uri = null;
         }
+
+        if (color !== undefined) {
+            this.color.parse(color);
+        } else {
+            this.color.set(1, 1, 1, 1);
+        }
+    }
+
+    hash() {
+        return computeStringHash(this.uri) ^ this.color.hash()
+    }
+
+    /**
+     *
+     * @param {Decal} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.uri === other.uri
+            && this.color.equals(other.color)
+            && this.priority === other.priority
+            ;
     }
 }
 

package/src/engine/graphics/ecs/decal/v2/DecalSerializationAdapter.js

@@ -0,0 +1,31 @@
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { Decal } from "./Decal.js";
+
+export class DecalSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = Decal;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Decal} value
+     */
+    serialize(buffer, value) {
+
+        buffer.writeUTF8String(value.uri);
+        buffer.writeFloat32(value.priority);
+        buffer.writeFloat32Array(value.color, 0, 4);
+
+    }
+
+    deserialize(buffer, value) {
+
+        value.uri = buffer.readUTF8String();
+        value.priority = buffer.readFloat32();
+        buffer.readFloat32Array(value.color, 0, 4);
+
+    }
+}

package/src/engine/graphics/ecs/decal/v2/FPDecalSystem.js

@@ -17,12 +17,12 @@ import {
 } from "../../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
 import { bvh_query_leaves_ray } from "../../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
 import { ray3_array_apply_matrix4 } from "../../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
-import { aabb3_intersects_ray } from "../../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
 import { ray3_array_compose } from "../../../../../core/geom/3d/ray/ray3_array_compose.js";
 import { mat4 } from "gl-matrix";
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import { EBBVHLeafProxy } from "../../../../../core/bvh2/bvh3/EBBVHLeafProxy.js";
 import { aabb3_matrix4_project } from "../../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import { aabb3_raycast } from "../../../../../core/geom/3d/aabb/aabb3_raycast.js";
 
 const placeholder_texture = Sampler2D.uint8(4, 1, 1);
 placeholder_texture.data.fill(255);
@@ -146,9 +146,16 @@ class Context extends SystemEntityContext {
         const decal_spec = this.components[0];
 
         // propagate draw priority onto decal
-        Object.defineProperty(fpDecal, 'draw_priority', {
-            get() {
-                return decal_spec.priority;
+        Object.defineProperties(fpDecal, {
+            'draw_priority': {
+                get() {
+                    return decal_spec.priority;
+                }
+            },
+            'color':{
+                get(){
+                    return decal_spec.color;
+                }
             }
         });
 
@@ -298,6 +305,7 @@ export class FPDecalSystem extends AbstractContextSystem {
         );
 
         const result = [];
+        const temp_hit = new Float32Array(6);
 
 
         for (let i = 0; i < hit_count; i++) {
@@ -338,7 +346,8 @@ export class FPDecalSystem extends AbstractContextSystem {
             // transform ray into decal's local space
             ray3_array_apply_matrix4(scratch_ray_0, 0, scratch_ray_0, 0, scratch_m4);
 
-            if (aabb3_intersects_ray(
+            if (aabb3_raycast(
+                temp_hit, 0,
                 -0.5, -0.5, -0.5,
                 0.5, 0.5, 0.5,
 
@@ -347,6 +356,8 @@ export class FPDecalSystem extends AbstractContextSystem {
             )) {
                 const contact = new SurfacePoint3();
 
+                contact.fromArray(temp_hit);
+
                 // contact will be the center of decal, and normal will follow the decal normal
                 contact.applyMatrix4(transform.matrix);