@woosh/meep-engine 2.47.3 → 2.47.8

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);
 

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

@@ -27,6 +27,10 @@ import { OctahedralUvEncoder } from "../../../impostors/octahedral/grid/Octahedr
 import { makeSolidArrowGeometry } from "../../../../../../editor/process/symbolic/makeSolidArrowGeometry.js";
 import { vec3 } from "gl-matrix";
 import Quaternion from "../../../../../core/geom/Quaternion.js";
+import { GizmoRenderingPlugin } from "../../../render/gizmo/GizmoRenderingPlugin.js";
+import { Gizmo } from "../../../render/gizmo/Gizmo.js";
+import { ForwardPlusRenderingPlugin } from "../../../render/forward_plus/plugin/ForwardPlusRenderingPlugin.js";
+import { TaskLoadingScreen } from "../../../../../view/task/TaskLoadingScreen.js";
 
 const decal_urls = `data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/staff_13_t.png
 data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_01_t.png
@@ -371,18 +375,87 @@ function makeNormalTestDecal() {
     return entity;
 }
 
+function sample_grid(ecd) {
+    const q_down = new Quaternion();
+    q_down.lookRotation(Vector3.down)
+
+    makeNormalTestGridDecal(ecd, Transform.fromJSON({
+        position: new Vector3(5, 0, 5),
+        rotation: q_down
+    }));
+
+
+    const q_forward = new Quaternion();
+    q_forward.lookRotation(Vector3.forward)
+
+    const t_forward_grid = Transform.fromJSON({
+        position: new Vector3(5, 4, 5),
+        rotation: q_forward
+    });
+    makeNormalTestGridDecal(ecd, t_forward_grid);
+
+    new EntityBuilder()
+        .add(SGMesh.fromURL('data/models/snaps/cube_white.gltf'))
+        .add(Transform.fromJSON({
+            position: new Vector3(14, 1, 4.8),
+            rotation: t_forward_grid.rotation,
+            scale: new Vector3(25, 25, 0.1)
+        }))
+        .build(ecd);
+}
+
+function raycast_tool(engine) {
+    let hits = [];
+
+    engine.graphics.on.preRender.add(() => {
+
+        hits.forEach(hit => {
+
+            Gizmo.draw_solid_sphere(hit.contact.position.asArray(), 0.1);
+
+        });
+
+    });
+
+    engine.devices.pointer.position.onChanged.add(() => {
+        const ray_origin = new Vector3();
+        const ray_direction = new Vector3();
+
+
+        const pointer = engine.devices.pointer.position;
+
+        const ndc = new Vector2();
+
+        engine.graphics.normalizeViewportPoint(pointer, ndc);
+        engine.graphics.viewportProjectionRay(ndc.x, ndc.y, ray_origin, ray_direction);
+
+        hits = engine.entityManager.getSystem(FPDecalSystem)?.raycast(
+            ray_origin.x, ray_origin.y, ray_origin.z,
+            ray_direction.x, ray_direction.y, ray_direction.z
+        );
+
+        console.warn(hits);
+
+    });
+}
+
 /**
  *
  * @param {Engine} engine
  */
 async function main(engine) {
 
+    const fpp = engine.plugins.getPlugin(ForwardPlusRenderingPlugin);
+    fpp.setClusterResolution(12, 8, 1);
+
+    const TERRAIN_SIZE = 1000;
+
     await EngineHarness.buildBasics({
         engine,
         enableWater: false,
         cameraFarDistance: 300,
         terrainResolution: 1,
-        terrainSize: new Vector2(1000, 1000)
+        terrainSize: new Vector2(TERRAIN_SIZE, TERRAIN_SIZE)
     });
 
     new EntityBuilder()
@@ -396,10 +469,12 @@ async function main(engine) {
 
     const random = seededRandom();
 
-    const ENTITY_COUNT = 1;
+    const ENTITY_COUNT = 100000;
 
     const ecd = engine.entityManager.dataset;
 
+    console.log('Decal image pool size:', decal_urls.length);
+
     function makeOne() {
         const decal = new Decal();
 
@@ -411,17 +486,17 @@ async function main(engine) {
 
         const transform = new Transform();
         transform.position.set(
-            randomFloatBetween(random, -400, 400),
+            randomFloatBetween(random, 0, TERRAIN_SIZE),
             randomFloatBetween(random, 0, 0),
-            randomFloatBetween(random, -400, 400)
+            randomFloatBetween(random, 0, TERRAIN_SIZE)
         );
-        transform.rotation.random(random);
-        transform.scale.setScalar(0.5);
+        transform.rotation._lookRotation(0, -1, 0, 0, 1, 0);
+        transform.scale.set(1,1,0.5);
 
         entity
             .add(transform)
             .add(decal)
-            .add(BehaviorComponent.fromOne(RotationBehavior.fromJSON({ speed: 1 })))
+        // .add(BehaviorComponent.fromOne(RotationBehavior.fromJSON({ speed: 1 })))
 
         entity.build(ecd);
     }
@@ -433,34 +508,9 @@ async function main(engine) {
 
     const task = countTask(0, ENTITY_COUNT, makeOne);
 
-    const q_down = new Quaternion();
-    q_down.lookRotation(Vector3.down)
-
-    makeNormalTestGridDecal(ecd, Transform.fromJSON({
-        position: new Vector3(5, 0, 5),
-        rotation: q_down
-    }));
-
-
-    const q_forward = new Quaternion();
-    q_forward.lookRotation(Vector3.forward)
-
-    const t_forward_grid = Transform.fromJSON({
-        position: new Vector3(5, 4, 5),
-        rotation: q_forward
-    });
-    makeNormalTestGridDecal(ecd, t_forward_grid);
-
-    new EntityBuilder()
-        .add(SGMesh.fromURL('data/models/snaps/cube_white.gltf'))
-        .add(Transform.fromJSON({
-            position: new Vector3(14, 1, 4.8),
-            rotation: t_forward_grid.rotation,
-            scale: new Vector3(25, 25, 0.1)
-        }))
-        .build(ecd);
+    //sample_grid(ecd);
 
-    // TaskLoadingScreen.instance.load(engine, task);
+    TaskLoadingScreen.instance.load(engine, task);
 
     // console.profile('spawn');
 
@@ -468,34 +518,14 @@ async function main(engine) {
         // console.profileEnd('spawn');
     });
 
-    // engine.executor.run(task);
+    engine.executor.run(task);
 
 
     //grid(engine.entityManager.dataset, 20,10,80, 25, .4, .6, .1, decal_urls.slice(105, 105+3));
 
     //grid(engine.entityManager.dataset, 20,30,80, 25, .4, .6, .1, decal_urls.slice(105, 105+3));
     // await promise_time_out(10);
-
-    engine.devices.pointer.position.onChanged.add(() => {
-        const ray_origin = new Vector3();
-        const ray_direction = new Vector3();
-
-
-        const pointer = engine.devices.pointer.position;
-
-        const ndc = new Vector2();
-
-        engine.graphics.normalizeViewportPoint(pointer,ndc);
-        engine.graphics.viewportProjectionRay(ndc.x, ndc.y, ray_origin, ray_direction);
-
-        const hits = engine.entityManager.getSystem(FPDecalSystem)?.raycast(
-            ray_origin.x, ray_origin.y, ray_origin.z,
-            ray_direction.x, ray_direction.y, ray_direction.z
-        );
-
-        console.warn(hits);
-
-    });
+    // raycast_tool(engine);
 
 }
 
@@ -504,6 +534,8 @@ new EngineHarness()
         configuration(config, engine) {
             const gltfAssetLoader = new GLTFAssetLoader();
 
+            config.addPlugin(GizmoRenderingPlugin);
+
             config.addLoader(GameAssetType.ModelGLTF_JSON, gltfAssetLoader);
             config.addLoader(GameAssetType.ModelGLTF, gltfAssetLoader);
 

package/src/engine/graphics/geometry/buffered/query/ClippingPlaneContainmentComputingVisitor.js

@@ -1,4 +1,4 @@
-import { computeAABB3PlaneSide } from "../../../../../core/geom/3d/aabb/computeAABB3PlaneSide.js";
+import { aabb3_compute_plane_side } from "../../../../../core/geom/3d/aabb/aabb3_compute_plane_side.js";
 import { NodeType } from "../../../../../core/bvh2/binary/NodeType.js";
 import { computeTrianglePlaneSide } from "../../../../../core/geom/3d/triangle/computeTrianglePlaneSide.js";
 import { GeometrySpatialAcceleratorVisitor } from "./GeometryVisitor.js";
@@ -162,7 +162,7 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
                 const plane_normal_z = plane.normal.z;
                 const plane_constant = plane.constant;
 
-                const side = computeAABB3PlaneSide(
+                const side = aabb3_compute_plane_side(
                     plane_normal_x,
                     plane_normal_y,
                     plane_normal_z,

package/src/engine/graphics/geometry/buffered/query/RaycastNearestHitComputingVisitor.js

@@ -3,7 +3,7 @@ import { NodeType } from "../../../../../core/bvh2/binary/NodeType.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
 import { computeTriangleRayIntersection } from "../../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import { GeometrySpatialAcceleratorVisitor } from "./GeometryVisitor.js";
-import { aabb3_intersects_ray } from "../../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
+import { aabb3_intersects_ray } from "../../../../../core/geom/3d/aabb/aabb3_intersects_ray.js";
 import { assert } from "../../../../../core/assert.js";
 
 export class RaycastNearestHitComputingVisitor extends GeometrySpatialAcceleratorVisitor {

package/src/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -17,6 +17,7 @@ import { rewriteMaterial } from "./rewriteMaterial.js";
 import { max3 } from "../../../../core/math/max3.js";
 import { min2 } from "../../../../core/math/min2.js";
 import { DrawMode } from "../../ecs/mesh-v2/DrawMode.js";
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
 
 export class InstancedMeshGroup {
     /**
@@ -316,7 +317,7 @@ export class InstancedMeshGroup {
      * @param {number[]|ArrayLike<number>|Float32Array} transform 4x4 transform matrix of the instance
      */
     setTransformAt(index, transform) {
-        this.__attributeTransformArray.set(transform, index * 16);
+        array_copy(transform,0,this.__attributeTransformArray,index*16,16);
     }
 
     /**
@@ -325,7 +326,7 @@ export class InstancedMeshGroup {
      * @param {number[]|ArrayLike<number>|Float32Array} color RGBA color in uint8 format (0...255), LDR
      */
     setColorAt(index, color) {
-        this.__attributeColorArray.set(color, index * 4);
+        array_copy(color,0,this.__attributeColorArray,index*4,4);
     }
 
     /**