@woosh/meep-engine 2.39.36 → 2.39.39

package/engine/ecs/EntityComponentDataset.js

@@ -949,11 +949,9 @@ export class EntityComponentDataset {
      */
     addComponentToEntity(entityIndex, componentInstance) {
 
-        if (!ENV_PRODUCTION) {
-            assert.notNull(componentInstance, "componentInstance");
+        assert.notNull(componentInstance, "componentInstance");
 
-            assert.defined(componentInstance, "componentInstance");
-        }
+        assert.defined(componentInstance, "componentInstance");
 
         const klass = componentInstance.constructor;
 
@@ -976,15 +974,13 @@ export class EntityComponentDataset {
      */
     addComponentToEntityByIndex(entityIndex, componentIndex, componentInstance) {
 
-        if (!ENV_PRODUCTION) {
+        assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
+        assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
 
-            assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
-            assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
+        assert.notEqual(componentInstance, undefined, "componentInstance is undefined");
 
-            assert.notEqual(componentInstance, undefined, "componentInstance is undefined");
+        assert.equal(this.getComponentByIndex(entityIndex, componentIndex), undefined, `entity ${entityIndex} already has component ${componentIndex}`);
 
-            assert.equal(this.getComponentByIndex(entityIndex, componentIndex), undefined, `entity ${entityIndex} already has component ${componentIndex}`);
-        }
 
         const componentOccupancyIndex = entityIndex * this.componentTypeCount + componentIndex;
 
@@ -1011,10 +1007,10 @@ export class EntityComponentDataset {
      * @returns {C|undefined}
      */
     getComponentByIndex(entityIndex, componentIndex) {
-        if (!ENV_PRODUCTION) {
-            assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
-            assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
-        }
+
+        assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
+        assert.ok(this.componentIndexExists(componentIndex), `componentIndex ${componentIndex} is out of bounds`);
+
 
         return this.components[componentIndex][entityIndex];
     }
@@ -1037,10 +1033,8 @@ export class EntityComponentDataset {
      * @returns {T|undefined}
      */
     getComponent(entityIndex, klass) {
-        if (!ENV_PRODUCTION) {
-            assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
-            assert.defined(klass, "klass");
-        }
+        assert.ok(this.entityExists(entityIndex), `entity ${entityIndex} does not exist`);
+        assert.defined(klass, "klass");
 
         const componentIndex = this.computeComponentTypeIndex(klass);
 
@@ -1078,11 +1072,9 @@ export class EntityComponentDataset {
      */
     traverseEntities(classes, visitor, thisArg) {
 
-        if (!ENV_PRODUCTION) {
-            assert.isArray(classes, "classes");
-            // assert.notOk(classes.some((c, i) => classes.indexOf(c) !== i), 'classes contains duplicates');
-            assert.isFunction(visitor, "visitor");
-        }
+        assert.isArray(classes, "classes");
+        // assert.notOk(classes.some((c, i) => classes.indexOf(c) !== i), 'classes contains duplicates');
+        assert.isFunction(visitor, "visitor");
 
         let entityIndex, i;
 
@@ -1152,7 +1144,7 @@ export class EntityComponentDataset {
     }
 
     /**
-     * does traversal on a subset of entities which have only the specified components.
+     * does traversal on a subset of entities which have only the specified components and no others
      * @example traverseEntitiesExact([Transform,Renderable,Tag],function(transform, renderable, tag, entity){ ... }, this);
      * @param {Array.<class>} classes
      * @param {Function} visitor
@@ -1472,10 +1464,8 @@ export class EntityComponentDataset {
      */
     addEntityEventListener(entity, eventName, listener, thisArg) {
 
-        if (!ENV_PRODUCTION) {
-            assert.isString(eventName,  "eventName");
-            assert.isFunction(listener,  "listener");
-        }
+        assert.isString(eventName, "eventName");
+        assert.isFunction(listener, "listener");
 
         if (!this.entityExists(entity)) {
             throw new Error(`Entity '${entity}' does not exist`);

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

@@ -8,6 +8,7 @@ import { scaleSampler2D } from "../../../../graphics/texture/sampler/scaleSample
 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";
+import { Base64 } from "../../../../../core/binary/Base64.js";
 
 
 /**
@@ -52,20 +53,42 @@ export class SplatMapping {
     }
 
     toJSON() {
+        const encoded = Base64.encode(this.weightData.buffer);
+
         return {
             size: this.size.toJSON(),
             depth: this.depth,
-            data: Array.from(this.weightData)
+            data: encoded
         };
     }
 
     fromJSON({
                  size = { x: 1, y: 1 },
                  depth = 0,
-                 data = []
-    } = {}) {
+                 data
+             } = {}) {
         this.resize(size.x, size.y, depth);
-        array_copy(data, 0, this.weightData, 0, data.length);
+
+        let uint_data;
+
+        if (typeof data === "string") {
+
+            const decoded_data = Base64.decode(data);
+            uint_data = new Uint8Array(decoded_data);
+
+        } else if (Array.isArray(data)) {
+
+            // deprecated
+            console.warn('Array JSON format is deprecated, please upgrade your data as soon as possible');
+            uint_data = data;
+
+        } else {
+
+            throw new Error('Unsupported data format');
+
+        }
+
+        array_copy(uint_data, 0, this.weightData, 0, data.length);
 
         this.weightTexture.needsUpdate = true;
     }

package/engine/graphics/GraphicsEngine.d.ts

@@ -1,4 +1,4 @@
-import {PerspectiveCamera, Scene, WebGLRenderer, WebGLRenderTarget} from "three";
+import {PerspectiveCamera, Scene, WebGLRenderer} from "three";
 import {RenderLayerManager} from "./render/layers/RenderLayerManager";
 import Vector3 from "../../core/geom/Vector3";
 import Vector2 from "../../core/geom/Vector2";
@@ -28,7 +28,7 @@ export class GraphicsEngine {
     public needDraw: boolean
     public autoDraw: boolean
 
-    render(renderTarget?: WebGLRenderTarget): void
+    render(): void
 
     normalizeViewportPoint(input: Vector3 | Vector2, result: Vector2 | Vector3): void
 

package/engine/graphics/GraphicsEngine.js

@@ -11,8 +11,7 @@ import {
     Scene as ThreeScene,
     Vector3 as ThreeVector3,
     VSMShadowMap,
-    WebGLRenderer,
-    WebGLRenderTarget
+    WebGLRenderer
 } from "three";
 
 import Signal from "../../core/events/signal/Signal.js";
@@ -232,6 +231,12 @@ function GraphicsEngine(camera, entityManger) {
      * @type {boolean}
      */
     this.autoDraw = true;
+
+    /**
+     * Monotonically increasing rendered-frame counter
+     * @type {number}
+     */
+    this.frameIndex = 0;
 }
 
 /**
@@ -625,14 +630,14 @@ GraphicsEngine.prototype.renderTransparent = function () {
 
 /**
  *
- * @param {WebGLRenderTarget} [renderTarget] if not present - renders to screen
  */
-GraphicsEngine.prototype.render = function (renderTarget) {
-
+GraphicsEngine.prototype.render = function () {
     if (this.needDraw && !this.autoDraw) {
         this.needDraw = false;
     }
 
+    this.frameIndex++;
+
     const renderer = this.renderer;
 
     //reset renderer statistics (used for debug)
@@ -653,14 +658,10 @@ GraphicsEngine.prototype.render = function (renderTarget) {
 
     this.constructVisibleScene(renderer, camera, scene);
 
-    if (renderTarget !== undefined) {
-        renderer.setRenderTarget(renderTarget);
-    }
-
     //dispatch pre-render event
     this.on.preRender.send3(renderer, camera, scene);
 
-    this.main_view.on.preRender.send0();
+    this.main_view.on.preRender.send1(this.main_view);
 
     //do the opaque pass
     this.renderOpaque();
@@ -674,12 +675,7 @@ GraphicsEngine.prototype.render = function (renderTarget) {
 
     this.layerComposer.composite(renderer, CompositingStages.POST_TRANSPARENT);
 
-
     //dispatch post-render event
     this.on.postRender.send3(renderer, camera, scene);
-
-    if (renderTarget !== undefined) {
-        renderer.setRenderTarget(null);
-    }
 };
 export { GraphicsEngine };

package/engine/graphics/composit/LayerCompositer.js

@@ -50,6 +50,7 @@ class LayerCompositer {
 
         this.layerTargets.splice(i, 1);
 
+        // cleanup memory
         layer.renderTarget.dispose();
 
         return true;

package/engine/graphics/ecs/camera/Camera.js

@@ -8,11 +8,11 @@ import ObservedEnum from "../../../../core/model/ObservedEnum.js";
 import { Frustum } from 'three';
 import { assert } from "../../../../core/assert.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
-import { computePointDistanceToPlane } from "../../../../core/geom/Plane.js";
 import { unprojectPoint } from "./unprojectPoint.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { frustum_from_camera } from "./frustum_from_camera.js";
 import { invertQuaternionOrientation } from "./InvertQuaternionOrientation.js";
+import { v3_distance_above_plane } from "../../../../core/geom/v3_distance_above_plane.js";
 
 /**
  *
@@ -248,7 +248,7 @@ export class Camera {
 
         const normal = near.normal;
 
-        const distance_to_plane = computePointDistanceToPlane(x, y, z, normal.x, normal.y, normal.z, near.constant);
+        const distance_to_plane = v3_distance_above_plane(x, y, z, normal.x, normal.y, normal.z, near.constant);
 
         const negative_distance_to_plane = -distance_to_plane;
 

package/engine/graphics/ecs/camera/CameraSystem.js

@@ -212,6 +212,12 @@ export class CameraSystem extends System {
                     return;
                 }
 
+                if(c.object.updateProjectionMatrix !== undefined) {
+                    c.object.updateProjectionMatrix();
+                    c.object.updateMatrix();
+                    c.object.updateMatrixWorld(true);
+                }
+
                 if (c.autoClip === true) {
                     auto_set_camera_clipping_planes(c, layers);
                 } else {

package/engine/graphics/ecs/light/binding/three/ThreeLightBinding.js

@@ -239,7 +239,7 @@ export class ThreeLightBinding extends LightBinding {
         const cameraView = this.__shadow_map.views[0];
 
         // signal that we're about to render this view
-        cameraView.on.preRender.send0();
+        cameraView.on.preRender.send1(cameraView);
 
         /**
          *

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -281,15 +281,23 @@ export class ShadedGeometry {
 
         const min = gbb.min;
 
-        scratch_aabb3_array[0] = min.x;
-        scratch_aabb3_array[1] = min.y;
-        scratch_aabb3_array[2] = min.z;
+        const x0 = min.x;
+        const y0 = min.y;
+        const z0 = min.z;
 
         const max = gbb.max;
 
-        scratch_aabb3_array[3] = max.x;
-        scratch_aabb3_array[4] = max.y;
-        scratch_aabb3_array[5] = max.z;
+        const x1 = max.x;
+        const y1 = max.y;
+        const z1 = max.z;
+
+        scratch_aabb3_array[0] = x0;
+        scratch_aabb3_array[1] = y0;
+        scratch_aabb3_array[2] = z0;
+
+        scratch_aabb3_array[3] = x1;
+        scratch_aabb3_array[4] = y1;
+        scratch_aabb3_array[5] = z1;
 
         aabb3_matrix4_project(this.__bvh_aabb, scratch_aabb3_array, this.transform);
     }

package/engine/graphics/ecs/mesh-v2/aggregate/SGMesh.js

@@ -3,7 +3,8 @@ import { AABB3 } from "../../../../../core/bvh2/aabb3/AABB3.js";
 
 export const SGMeshFlags = {
     CastShadow: 1,
-    ReceiveShadow: 2
+    ReceiveShadow: 2,
+    Loaded: 4
 };
 
 export class SGMesh {

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js

@@ -17,6 +17,13 @@ import { min2 } from "../../../../../core/math/min2.js";
  */
 const MAX_CYCLE_COUNT = 128;
 
+/**
+ * In milliseconds
+ * @readonly
+ * @type {number}
+ */
+const MAX_CYCLE_TIME = 40;
+
 export class SGMeshSystem extends System {
     /**
      *
@@ -235,10 +242,11 @@ export class SGMeshSystem extends System {
 
         if (l > 0) {
 
-            let pointer = this.__wait_queue_process_index;
+            const time_0 = performance.now();
 
+            let pointer = this.__wait_queue_process_index;
 
-            let pointer_limit = pointer + min2(l, MAX_CYCLE_COUNT);
+            const pointer_limit = pointer + min2(l, MAX_CYCLE_COUNT);
 
             while (pointer < pointer_limit) {
 
@@ -260,6 +268,13 @@ export class SGMeshSystem extends System {
 
                 this.process(entity, mesh, transform);
 
+                const time_1 = performance.now();
+
+                if ((time_1 - time_0) > MAX_CYCLE_TIME) {
+                    // too much time has passed
+                    break;
+                }
+
             }
 
             this.__wait_queue_process_index = pointer;

package/engine/graphics/ecs/mesh-v2/aggregate/prototypeSGMesh.js

@@ -20,10 +20,7 @@ import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/OrbitingBehavior.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
-import { GizmoRenderingPlugin } from "../../../render/gizmo/GizmoRenderingPlugin.js";
-import { Gizmo } from "../../../render/gizmo/Gizmo.js";
 import { AABB3 } from "../../../../../core/bvh2/aabb3/AABB3.js";
-import { MicronRenderPlugin } from "../../../micron/plugin/MicronRenderPlugin.js";
 import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
 
 new EngineHarness().initialize({
@@ -38,8 +35,8 @@ new EngineHarness().initialize({
             new ShadedGeometryHighlightSystem(engine)
         );
 
-        config.addPlugin(GizmoRenderingPlugin);
-        config.addPlugin(MicronRenderPlugin);
+        // config.addPlugin(GizmoRenderingPlugin);
+        // config.addPlugin(MicronRenderPlugin);
 
         const gltfAssetLoader = new GLTFAssetLoader();
 
@@ -79,11 +76,11 @@ function make_grid(ecd, engine) {
                 radius: 5
             });
 
-            const ctx = {
-                time: Math.sin(i * Math.PI / (GRID_FREQUENCY_SIZE - 1)) + Math.cos(j * Math.PI / (GRID_FREQUENCY_SIZE - 1))
-            };
-
-            const color = [random(), random(), random(), 1];
+            // const ctx = {
+            //     time: Math.sin(i * Math.PI / (GRID_FREQUENCY_SIZE - 1)) + Math.cos(j * Math.PI / (GRID_FREQUENCY_SIZE - 1))
+            // };
+            //
+            // const color = [random(), random(), random(), 1];
 
             engine.graphics.on.preRender.add(() => {
 
@@ -93,16 +90,16 @@ function make_grid(ecd, engine) {
 
                 // mesh.getBoundingBox(bounds);
 
-                Gizmo.color = color;
-
-                Gizmo.draw_wire_cube(
-                    [
-                        bounds.getCenterX(), bounds.getCenterY(), bounds.getCenterZ()
-                    ],
-                    [
-                        bounds.getExtentsX(), bounds.getExtentsY(), bounds.getExtentsZ()
-                    ]
-                );
+                // Gizmo.color = color;
+                //
+                // Gizmo.draw_wire_cube(
+                //     [
+                //         bounds.getCenterX(), bounds.getCenterY(), bounds.getCenterZ()
+                //     ],
+                //     [
+                //         bounds.getExtentsX(), bounds.getExtentsY(), bounds.getExtentsZ()
+                //     ]
+                // );
             });
 
 

package/engine/graphics/filter/FlipArrayInPlace.js

@@ -5,21 +5,26 @@
  * @param {number} channel_count
  */
 export function flipArrayInPlace(input, width, height, channel_count = 4) {
-    const rowLength = width * channel_count;
+    const row_size = width * channel_count;
     let t, x0, x1;
     let i = 0;
-    const l = height >> 1;
+    const column_count = height >> 1;
+
+    for (; i < column_count; i++) {
 
-    for (; i < l; i++) {
         //swap lines
-        const k = (height - i - 1) * rowLength;
-        const m = i * rowLength;
-        for (let j = 0; j < rowLength; j++) {
+        const k = (height - i - 1) * row_size;
+        const m = i * row_size;
+
+        for (let j = 0; j < row_size; j++) {
             x0 = m + j;
             x1 = k + j;
+
             t = input[x0];
+
             input[x0] = input[x1];
             input[x1] = t;
         }
+
     }
 }

package/engine/graphics/geometry/clipping/ClippedGeometry.js

@@ -1,4 +1,4 @@
-import { computePointDistanceToPlane } from "../../../../core/geom/Plane.js";
+import { v3_distance_above_plane } from "../../../../core/geom/v3_distance_above_plane.js";
 
 
 // TODO incomplete
@@ -107,9 +107,9 @@ export class ClippedGeometry {
 
         const plane_constant = plane.constant;
 
-        const a_distance = computePointDistanceToPlane(a_x, a_y, a_z, normal_x, normal_y, normal_z, plane_constant);
-        const b_distance = computePointDistanceToPlane(b_x, b_y, b_z, normal_x, normal_y, normal_z, plane_constant);
-        const c_distance = computePointDistanceToPlane(c_x, c_y, c_z, normal_x, normal_y, normal_z, plane_constant);
+        const a_distance = v3_distance_above_plane(a_x, a_y, a_z, normal_x, normal_y, normal_z, plane_constant);
+        const b_distance = v3_distance_above_plane(b_x, b_y, b_z, normal_x, normal_y, normal_z, plane_constant);
+        const c_distance = v3_distance_above_plane(c_x, c_y, c_z, normal_x, normal_y, normal_z, plane_constant);
 
         const a_out = a_distance <= 0;
         const b_out = b_distance <= 0;

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -516,7 +516,9 @@ function init() {
     // gltf_sample('moicon/A4/A4/model.gltf');
     // gltf_sample('moicon/06_04_hapro/08-clickable-assets-new/model.gltf');
     // gltf_grid('moicon/ztest_object_many_pieces/model.gltf', 3, 3);
-    gltf_sample('moicon/ztest_object_many_pieces/model.gltf');
+    // gltf_sample('moicon/ztest_object_many_pieces/model.gltf');
+    // gltf_sample('moicon/62cf22227f7b8f0012ca5988/model.gltf');
+    gltf_sample('moicon/gnutti_not_optimized/model.gltf');
     // gltf_grid('data/models/moicon/Kople/EVCharger1.gltf');
     // gltf_sample('data/models/moicon/Kople/EVCharger1.gltf');
     // gltf_sample('data/models/moicon/isiflow_Oct_15_21/0/model.gltf');

package/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js

@@ -356,7 +356,9 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         this.__composit_layer.on.preRender.remove(this.__render, this);
         graphics.viewport.size.onChanged.add(this.__update_render_target_size, this);
 
+        // release memory
         this.__blur.dispose();
+        this.__render_target.dispose();
 
         return super.shutdown();
     }

package/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.js

@@ -0,0 +1,95 @@
+import { EnginePlugin } from "../../../../../plugin/EnginePlugin.js";
+import { halton_sequence } from "../../../../../../core/math/statistics/halton_sequence.js";
+import { array_copy } from "../../../../../../core/collection/array/copyArray.js";
+
+/**
+ * Generates a number of 2d jitter offsets in range -1...1
+ * @param {number} point_count
+ * @return {Float32Array}
+ */
+function generate_jitter(point_count) {
+    const result = new Float32Array(point_count * 2);
+
+    for (let i = 0; i < point_count; i++) {
+        const i2 = i * 2;
+        result[i2] = halton_sequence(2, i) * 2 - 1;
+        result[i2 + 1] = halton_sequence(3, i) * 2 - 1;
+    }
+
+    return result;
+}
+
+export class TemporalSupersamplingRenderPlugin extends EnginePlugin {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__frame_index = 0;
+
+        this.__sample_count = 16;
+        this.__jitter_offset = generate_jitter(this.__sample_count);
+
+
+        this.__projection_modifier = {
+            /**
+             *
+             * @param {number[]} input
+             * @param {number[]} output
+             */
+            transform: (input, output) => {
+
+                const viewport_width = this.engine.graphics.viewport.size.x;
+                const viewport_height = this.engine.graphics.viewport.size.y;
+
+                // apply jitter to projection matrix
+                const jitter_index = this.__frame_index % this.__sample_count;
+
+                const jitter_offset_x = this.__jitter_offset[jitter_index * 2];
+                const jitter_offset_y = this.__jitter_offset[jitter_index * 2 + 1];
+
+                array_copy(input, 0, output, 0, 16);
+
+                output[8] = jitter_offset_x / viewport_width;
+                output[9] = jitter_offset_y / viewport_height;
+            }
+        };
+    }
+
+    __hook_post_render() {
+
+        // increment frame index
+        this.__frame_index++;
+    }
+
+    initialize(engine) {
+        super.initialize(engine);
+    }
+
+    finalize() {
+        super.finalize();
+    }
+
+    async startup() {
+        // modify projection matrix
+        this.engine.graphics.main_view.addProjectionModifier(this.__projection_modifier);
+
+
+        this.engine.graphics.on.postRender.add(this.__hook_post_render, this);
+
+        // reset frame counter
+        this.__frame_index = 0;
+
+        return super.startup();
+    }
+
+    async shutdown() {
+        this.engine.graphics.main_view.removeProjectionModifier(this.__projection_modifier);
+        this.engine.graphics.on.postRender.remove(this.__hook_post_render, this);
+
+        return super.shutdown();
+    }
+}