@woosh/meep-engine 2.43.23 → 2.43.25

package/core/geom/3d/topology/struct/prototypeBinaryTopology.js

@@ -29,12 +29,12 @@ async function main() {
     const index_array = lucy_geom.getIndex().array;
 
 
+
     console.time('topo build - bin');
     // console.profile('topo build - bin');
     bt_index_geometry_to_topology(mesh, index_array, positions_array);
     // console.profileEnd('topo build - bin');
     console.timeEnd('topo build - bin');
-
     //
     // console.time('topo build - obj');
     // topoMesh.build(positions_array, index_array);

package/editor/Editor.js

@@ -71,8 +71,8 @@ import { ObservedIntegerEditor } from "./ecs/component/editors/ObservedIntegerEd
 
 import '../../../../css/editor/EntityEditorView.scss';
 import '../../../../css/editor/EditorView.scss';
-import {ParameterTrackSet} from "../engine/graphics/particles/particular/engine/parameter/ParameterTrackSet.js";
-import {ParameterTrackSetEditor} from "./ecs/component/editors/ecs/ParameterTrackSetEditor.js";
+import { ParameterTrackSet } from "../engine/graphics/particles/particular/engine/parameter/ParameterTrackSet.js";
+import { ParameterTrackSetEditor } from "./ecs/component/editors/ecs/ParameterTrackSetEditor.js";
 
 /**
  * @template T
@@ -485,6 +485,7 @@ function Editor() {
             resetSoundEmitterTracks(dataset);
 
             const serializer = new BinaryBufferSerializer();
+            serializer.engine = self.engine;
             serializer.registry = engine.binarySerializationRegistry;
 
             const state = new EncodingBinaryBuffer();

package/engine/EngineHarness.js

@@ -29,6 +29,8 @@ import { noop } from "../core/function/Functions.js";
 import SoundListenerSystem from "./sound/ecs/SoundListenerSystem.js";
 import SoundListener from "./sound/ecs/SoundListener.js";
 import { getURLHash } from "./platform/GetURLHash.js";
+import Stats from "three/examples/jsm/libs/stats.module.js";
+import EmptyView from "../view/elements/EmptyView.js";
 
 /**
  *
@@ -68,6 +70,22 @@ export class EngineHarness {
         this.p = null;
     }
 
+    /**
+     *
+     * @param {Engine} engine
+     */
+    static addFpsCounter(engine) {
+        const stats = new Stats();
+
+        engine.graphics.on.postRender.add(stats.update, stats);
+
+        const view = new EmptyView({
+            el: stats.domElement
+        });
+
+        engine.viewStack.addChild(view);
+    }
+
     /**
      * @param {(config:EngineConfiguration,engine:Engine)=>*} configuration
      * @param {boolean} [enable_localization] Whether or not to load localization data
@@ -228,6 +246,7 @@ export class EngineHarness {
      * @param {boolean} [cameraController=true]
      * @param {boolean} [cameraAutoClip]
      * @param shadowmapResolution
+     * @param showFps
      */
     static async buildBasics({
                                  engine,
@@ -246,9 +265,14 @@ export class EngineHarness {
                                  cameraFarDistance,
                                  cameraController = true,
                                  cameraAutoClip = false,
-                                 shadowmapResolution
+                                 shadowmapResolution,
+                                 showFps = true
                              }) {
 
+        if (showFps) {
+            EngineHarness.addFpsCounter(engine);
+        }
+
         if (enableLights) {
             await EngineHarness.buildLights({ engine: engine, shadowmapResolution });
         }

package/engine/graphics/camera/camera_compute_distance_to_fit_length.js

@@ -7,10 +7,16 @@ import { assert } from "../../../core/assert.js";
  * @returns {number}
  */
 export function camera_compute_distance_to_fit_length(length, fov) {
+    // @see https://docs.unity3d.com/Manual/FrustumSizeAtDistance.html
+
     assert.isNumber(length, 'length');
+    assert.greaterThanOrEqual(length, 0, 'length < 0');
+
     assert.isNumber(fov, 'fov');
     assert.greaterThan(fov, 0, 'fov <= 0');
     assert.lessThan(fov, Math.PI, 'fov >= pi');
 
-    return Math.abs((length / 2) / Math.sin(fov / 2));
+    const signed_distance = (length * 0.5) / Math.tan(fov * 0.5);
+
+    return Math.abs(signed_distance);
 }

package/engine/graphics/ecs/mesh-v2/render/adapters/AbstractRenderAdapter.js

@@ -1,3 +1,29 @@
+import { array_quick_sort_by_comparator } from "../../../../../../core/collection/array/arrayQuickSort.js";
+
+/**
+ *
+ * @param {THREE.Object3D} a
+ * @param {THREE.Object3D} b
+ * @returns {number}
+ */
+function compare_by_material(a, b) {
+
+    const a_mat = a.material;
+    const b_mat = b.material;
+
+    if (a_mat === b_mat) {
+        return 0;
+    }
+
+    if (a_mat === undefined) {
+        return 1;
+    } else if (b_mat === undefined) {
+        return -1;
+    }
+
+    return a_mat.id - b_mat.id;
+}
+
 export class AbstractRenderAdapter {
     constructor() {
 
@@ -16,6 +42,13 @@ export class AbstractRenderAdapter {
         this.__objects = [];
     }
 
+    /**
+     * Sorting objects by material will help reduce context switching and number of graphics API calls
+     */
+    sort_by_material() {
+        array_quick_sort_by_comparator(this.__objects, compare_by_material, null, 0, this.__object_count - 1);
+    }
+
     /**
      *
      * @param {THREE.BufferGeometry} geometry

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

@@ -1,5 +1,8 @@
 import {EnginePlugin} from "../../../../../plugin/EnginePlugin";
 
 export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
-
+    /**
+     * Higher value will make AO appear darker, lower values will make it lighter
+     */
+    public intensity: number
 }

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

@@ -114,6 +114,22 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         this.__blur = new DepthLimitedBlur({ format: RedFormat, clear_color: 0xFFFFFF });
     }
 
+    /**
+     * Higher value will make AO appear darker, lower values will make it lighter
+     * @param {number} v
+     */
+    set intensity(v) {
+        this.__material.uniforms.intensity.value = v;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get intensity() {
+        return this.__material.uniforms.intensity.value;
+    }
+
     /**
      *
      * @param {Camera} camera

package/engine/graphics/render/visibility/hiz/buffer/HierarchicalZBuffer.js

@@ -91,7 +91,7 @@ export class HierarchicalZBuffer {
 
             for (let i = existing_mip_depth; i < mip_depth; i++) {
 
-                mips[i] = new WebGLRenderTarget(1, 1, {
+                const renderTarget = new WebGLRenderTarget(1, 1, {
                     minFilter: NearestFilter,
                     magFilter: NearestFilter,
                     format: RedFormat,
@@ -104,6 +104,10 @@ export class HierarchicalZBuffer {
                     generateMipmaps: false
                 });
 
+                renderTarget.texture.name = `Hierarchical Z buffer MIP ${i}`;
+
+                mips[i] = renderTarget;
+
             }
 
         }

package/engine/graphics/render/visibility/hiz/buildCanvasViewFromTexture.js

@@ -58,7 +58,7 @@ function makeShader({ texture, alpha_override, swizzle }) {
 
     if (texture_channel_count < 4) {
         // no override specified, and alpha would be 0, force it to one to make image visible
-        _swizzle[4] = 1;
+        _swizzle[3] = 1;
     }
 
     return new ShaderMaterial({
@@ -83,7 +83,7 @@ function makeShader({ texture, alpha_override, swizzle }) {
 		void main() {
 
 			vec4 texel = ${sampleTexel(texture, 'tDiffuse', 'vUv')};
-			gl_FragColor = ${glsl_gen_swizzled_read('texel', swizzle)};
+			gl_FragColor = ${glsl_gen_swizzled_read('texel', _swizzle)};
 		}`,
         uniforms: {
 
@@ -163,7 +163,6 @@ export function renderSamplerFromTexture({
     }
 
     const render = () => {
-
         const shader = getShader();
 
         shader.uniforms.tDiffuse.value = texture;
@@ -186,10 +185,12 @@ export function renderSamplerFromTexture({
         destination,
         render,
         set texture(v) {
+            if (v !== texture) {
 
-            texture = v;
+                texture = v;
 
-            getShader().uniforms.tDiffuse.value = v;
+                getShader().uniforms.tDiffuse.value = v;
+            }
         }
     }
 }

package/engine/graphics/render/visibility/hiz/prototypeHiZ.js

@@ -203,13 +203,17 @@ function print_perf_stats() {
 function prepare_query_test(hiz, graphics, ecd) {
 
     const query = new BatchOcclusionQuery();
-    query.setSize(64);
+    query.setSize(100);
 
 
     const random = seededRandom(42);
 
     const row_count = 8;
 
+    /**
+     *
+     * @type {EntityBuilder[]}
+     */
     const entities = [];
     const labels = [];
 
@@ -224,8 +228,11 @@ function prepare_query_test(hiz, graphics, ecd) {
 
         mat4.copy(projection, world_inverse);
         mat4.multiply(projection, camera_projection, projection);
+        const aabb = new Float32Array(6);
+
+        const query_size = query.getSize();
 
-        for (let i = 0; i < query.getSize(); i++) {
+        for (let i = 0; i < query_size; i++) {
             const entity = entities[i];
 
             if (entity === undefined) {
@@ -236,7 +243,6 @@ function prepare_query_test(hiz, graphics, ecd) {
              * @type {Mesh}
              */
             const mesh = entity.getComponent(Mesh);
-            const aabb = new Float32Array(6);
 
             mesh.bvh.writeToArray(aabb, 0);
 

package/engine/network/RemoteController.js

@@ -1,7 +1,6 @@
 import { BinaryBuffer } from "../../core/binary/BinaryBuffer.js";
 import BinaryBufferDeSerializer from "../ecs/storage/BinaryBufferDeSerializer.js";
-
-const scratch_buffer = new BinaryBuffer();
+import { BinaryObjectSerializationAdapter } from "../ecs/storage/binary/object/BinaryObjectSerializationAdapter.js";
 
 class LocalAPI {
     /**
@@ -10,8 +9,23 @@ class LocalAPI {
      */
     engine = null;
 
+    _object_serde = new BinaryObjectSerializationAdapter();
+
+    get _registry() {
+        return this.engine.binarySerializationRegistry;
+    }
+
     /**
      *
+     * @return {EntityComponentDataset}
+     * @private
+     */
+    get _current_dataset() {
+        return this.engine.entityManager.dataset;
+    }
+
+    /**
+     * Server sent us a new world state
      * @param {BinaryBuffer} buffer
      */
     async writeCurrentSceneDataset(buffer) {
@@ -19,7 +33,9 @@ class LocalAPI {
 
         const engine = this.engine;
 
-        const ecd = engine.entityManager.dataset;
+        deSerializer.registry = this._registry;
+
+        const ecd = this._current_dataset;
 
         ecd.clear();
 
@@ -31,6 +47,30 @@ class LocalAPI {
 
         await p;
     }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @return {Promise<void>}
+     */
+    async createEntity(buffer) {
+        // create entity on the current scene with a given ID
+
+        const entity_id = buffer.readUintVar();
+
+        this._current_dataset.createEntitySpecific(entity_id);
+    }
+
+    async addComponentToEntity(buffer) {
+        const entity_id = buffer.readUintVar();
+
+        this._object_serde.registry = this._registry;
+        const component_instance = this._object_serde.deserialize(buffer);
+
+        this._current_dataset.addComponentToEntity(entity_id, component_instance);
+
+    }
+
 }
 
 export class RemoteController {
@@ -59,10 +99,10 @@ export class RemoteController {
     async __handle_message(data) {
         // console.log(`received message `, data);
 
-        scratch_buffer.fromArrayBuffer(data);
+        const buffer =  BinaryBuffer.fromArrayBuffer(data);
 
         // read packet ID
-        const packet_id = scratch_buffer.readUTF8String();
+        const packet_id = buffer.readUTF8String();
 
         console.log(`packet ID: ${packet_id}`);
 
@@ -72,7 +112,7 @@ export class RemoteController {
         }
 
         try {
-            await this.localAPI[packet_id](scratch_buffer);
+            await this.localAPI[packet_id](buffer);
         } catch (e) {
             //
             console.error(`Failed to process remote call to '${packet_id}':`, e);

package/engine/network/remoteEditor.js

@@ -1,6 +1,7 @@
 import { EngineHarness } from "../EngineHarness.js";
 import { RemoteController } from "./RemoteController.js";
 import { ShadedGeometrySystem } from "../graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
+import { initializeGameBinarySerializationRegistry } from "../../../model/game/GameBinarySerializationRegistry.js";
 
 const harness = new EngineHarness();
 
@@ -15,6 +16,8 @@ async function main(engine) {
         engine
     });
 
+    initializeGameBinarySerializationRegistry(engine.binarySerializationRegistry);
+
     const remote = new RemoteController();
 
     remote.attach(engine);

package/generation/filtering/numeric/complex/CellFilterGaussianBlur.js

@@ -4,7 +4,7 @@ import { max2 } from "../../../../core/math/max2.js";
 import { assert } from "../../../../core/assert.js";
 
 /**
- *
+ * Build gaussian 2d kernel
  * @param {number[]} result
  * @param {number} samplesX
  * @param {number} samplesY

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.23",
+  "version": "2.43.25",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",