@woosh/meep-engine 2.36.23 → 2.36.26

package/engine/ecs/EntityComponentDataset.js

@@ -1216,6 +1216,20 @@ export class EntityComponentDataset {
         }
     }
 
+    /**
+     *
+     * @returns {Generator<number>}
+     */
+    * createEntityIterator() {
+
+        const eo = this.entityOccupancy;
+
+        for (let i = eo.nextSetBit(0); i !== -1; i = eo.nextSetBit(i + 1)) {
+            yield i;
+        }
+
+    }
+
     /**
      * @template T
      * @param {Class<T>} klass

package/engine/graphics/ecs/highlight/renderer/OutlineRenderer.js

@@ -84,6 +84,39 @@ function makeIdMaterialStatic() {
 
 const material_id_unskinned = makeIdMaterialStatic();
 
+/**
+ *
+ * @type {WeakMap<Object3D, Object3D>}
+ */
+const object_id_cache = new WeakMap();
+
+/**
+ *
+ * @param {Mesh|SkinnedMesh} object
+ */
+function obtain_id_mesh(object) {
+    const existing = object_id_cache.get(object);
+
+    if (existing !== undefined) {
+        return existing;
+    }
+
+    let material, mesh;
+    if (object.isSkinnedMesh) {
+        material = makeIdMaterialSkinned();
+        mesh = new SkinnedMesh(object.geometry, material);
+        mesh.bindMatrix.copy(object.bindMatrix);
+        mesh.bindMatrixInverse.copy(object.bindMatrixInverse);
+        mesh.skeleton = object.skeleton;
+    } else {
+        material = makeIdMaterialStatic();
+        mesh = new Mesh(object.geometry, material);
+    }
+
+    object_id_cache.set(object, mesh);
+
+    return mesh;
+}
 
 function makeIdMaterialSkinned() {
     return new ShaderMaterial({
@@ -99,8 +132,6 @@ const material_id_skinned = makeIdMaterialSkinned();
 material_id_skinned.skinning = true;
 
 
-const PARAMETER_COUNT = 5;
-const PARAMETER_PER_OBJECT_SLOTS = 4;
 const OBJECT_MAX_COUNT = 256;
 
 
@@ -373,22 +404,10 @@ export class OutlineRenderer {
     __append_to_id_scene(object) {
         if (object.isMesh) {
 
-            let material;
-            let mesh;
-
-            if (object.isSkinnedMesh) {
-                material = makeIdMaterialSkinned();
-                mesh = new SkinnedMesh(object.geometry, material);
-                mesh.bindMatrix.copy(object.bindMatrix);
-                mesh.bindMatrixInverse.copy(object.bindMatrixInverse);
-                mesh.skeleton = object.skeleton;
-            } else {
-                material = makeIdMaterialStatic();
-                mesh = new Mesh(object.geometry, material);
-            }
+            const mesh = obtain_id_mesh(object);
 
             const parameter_set_id = this.__definition_dictionary.get(this.__active_definition);
-            material.uniforms.id.value = parameter_set_id;
+            mesh.material.uniforms.id.value = parameter_set_id;
 
             mesh.matrixAutoUpdate = false;
             mesh.matrixWorldNeedsUpdate = false;
@@ -399,6 +418,7 @@ export class OutlineRenderer {
             mesh.modelViewMatrix.copy(object.modelViewMatrix);
 
             this.__id_scene.children.push(mesh);
+
         }
     }
 

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

@@ -15,6 +15,10 @@ import {
 } from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
 import { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/bvh_query_leaves_generic.js";
 import { BVHQueryIntersectsRay } from "../../../../core/bvh2/bvh3/query/BVHQueryIntersectsRay.js";
+import Task from "../../../../core/process/task/Task.js";
+import { RuntimeDrawMethodOptimizer } from "./render/optimization/RuntimeDrawMethodOptimizer.js";
+import TaskSignal from "../../../../core/process/task/TaskSignal.js";
+import TaskState from "../../../../core/process/task/TaskState.js";
 
 
 /**
@@ -81,6 +85,30 @@ export class ShadedGeometrySystem extends System {
          * @private
          */
         this.__bvh_binary = new ExplicitBinaryBoundingVolumeHierarchy();
+
+        const optimizer = new RuntimeDrawMethodOptimizer();
+
+        this.__optimization_task = new Task({
+            name: 'ShadedGeometry Draw Method optimizer',
+            initializer: () => {
+                optimizer.__system = this;
+            },
+            cycleFunction() {
+                if (optimizer.step()) {
+                    return TaskSignal.Continue;
+                } else {
+                    return TaskSignal.Yield;
+                }
+            }
+        });
+    }
+
+    /**
+     * NOTE: DO NOT MODIFY RESULTS
+     * @returns {Map<number,number>}
+     */
+    getGeometryUsageCounters() {
+        return this.__geometry_usage_counters;
     }
 
     /**
@@ -184,6 +212,9 @@ export class ShadedGeometrySystem extends System {
             return ctx.collect(destination, destination_offset, graphics.renderer, view, this.__bvh_binary, ecd);
         });
 
+        this.__optimization_task.state.set(TaskState.INITIAL);
+        engine.executor.run(this.__optimization_task);
+
         readyCallback();
     }
 
@@ -194,6 +225,8 @@ export class ShadedGeometrySystem extends System {
 
         const view_list = graphics.views.elements;
 
+        engine.executor.removeTask(this.__optimization_task);
+
         view_list.forEach(this.__handle_view_removed, this);
         view_list.on.added.remove(this.__handle_view_added, this);
         view_list.on.removed.remove(this.__handle_view_removed, this);

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

@@ -20,9 +20,10 @@ export class AbstractRenderAdapter {
      *
      * @param {THREE.BufferGeometry} geometry
      * @param {THREE.Material} material
+     * @param {number} instance_count
      * @returns {number}
      */
-    score(geometry, material) {
+    score(geometry, material, instance_count) {
         return 0;
     }
 

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

@@ -14,11 +14,6 @@ export class GenericRendererAdapter extends AbstractRenderAdapter {
         this.__cache = SGThreeObjectCache.INSTANCE;
     }
 
-
-    score(geometry, material) {
-        return 0;
-    }
-
     /**
      *
      * @param {THREE.WebGLRenderer} renderer

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

@@ -69,6 +69,16 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
         this.__active_meshes = new Set();
     }
 
+    score(geometry, material, instance_count) {
+        if (instance_count > 16) {
+            return 1;
+        } else if (instance_count < 4) {
+            return -1;
+        } else {
+            return 0;
+        }
+    }
+
     /**
      *
      * @param {ShadedGeometry} sg

package/engine/graphics/ecs/mesh-v2/render/optimization/RuntimeDrawMethodOptimizer.js

@@ -0,0 +1,109 @@
+import { ShadedGeometry } from "../../ShadedGeometry.js";
+
+export class RuntimeDrawMethodOptimizer {
+    constructor() {
+
+        /**
+         *
+         * @type {ShadedGeometrySystem|null}
+         * @private
+         */
+        this.__system = null;
+
+        /**
+         *
+         * @type {Generator<number>}
+         * @private
+         */
+        this.__entity_iterator = null;
+    }
+
+    /**
+     *
+     * @returns {boolean} true if a change was made, false otherwise
+     */
+    step() {
+        const system = this.__system;
+
+        if (system === null) {
+            return false;
+        }
+
+        const ecd = system.entityManager.dataset;
+
+        if (ecd === null) {
+            // no dataset attached
+            return false;
+        }
+
+        if (!ecd.isComponentTypeRegistered(ShadedGeometry)) {
+            // component not registered
+            return false;
+        }
+
+        if (this.__entity_iterator === null) {
+            this.__entity_iterator = ecd.createEntityIterator();
+        }
+
+        const next = this.__entity_iterator.next();
+
+        if (next.done) {
+            this.__entity_iterator = ecd.createEntityIterator();
+            return false;
+        }
+
+        const entity = next.value;
+
+        /**
+         *
+         * @type {ShadedGeometry}
+         */
+        const sg = ecd.getComponent(entity, ShadedGeometry);
+
+        if (sg === undefined) {
+            return false;
+        }
+
+        const use_count = system.getGeometryUsageCounters().get(sg.geometry.id);
+
+        /**
+         *
+         * @type {ShadedGeometryRendererContext|undefined}
+         */
+        const first_context = system.__view_contexts.values().next().value;
+
+        if (first_context === undefined) {
+            return false;
+        }
+
+        const adapters = first_context.adapters;
+        const adapter_count = adapters.length;
+
+        let best_score = Number.NEGATIVE_INFINITY;
+        let best_adapter = -1;
+
+        for (let i = 0; i < adapter_count; i++) {
+            const adapter = adapters[i];
+
+            const score = adapter.score(sg.geometry, sg.material, use_count);
+
+            if (score > best_score) {
+                best_score = score;
+                best_adapter = i;
+            }
+        }
+
+        if (best_adapter === -1) {
+            // not found
+            return false;
+        }
+
+        if (sg.draw_method === best_adapter) {
+            return false;
+        }
+
+        sg.draw_method = best_adapter;
+
+        return true;
+    }
+}

package/engine/graphics/micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js

@@ -3,6 +3,8 @@ import Vector2 from "../../../../../core/geom/Vector2.js";
 import { buildMicronGeometryFromBufferGeometry } from "../../build/buildMicronGeometryFromBufferGeometry.js";
 import { ShadedGeometryFlags } from "../../../ecs/mesh-v2/ShadedGeometryFlags.js";
 import { MaterialVertexSpec, MaterialVertexSpecFlags } from "../../render/v1/MaterialVertexSpec.js";
+import { compute_geometry_polycount } from "../../../geometry/compute_geometry_polycount.js";
+import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
 
 /**
  *
@@ -10,6 +12,18 @@ import { MaterialVertexSpec, MaterialVertexSpecFlags } from "../../render/v1/Mat
  */
 const scratch_mvc = new MaterialVertexSpec();
 
+/**
+ * @readonly
+ * @type {number}
+ */
+const MICRON_POLYCOUNT_THRESHOLD_MIN = 4096;
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const MICRON_POLYCOUNT_THRESHOLD_MAX = 10000;
+
 export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
     constructor() {
@@ -36,6 +50,12 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
         this.__geometry_building_promises = new Map();
     }
 
+    score(geometry, material, instance_count) {
+        const polycount = compute_geometry_polycount(geometry);
+
+        return inverseLerp(MICRON_POLYCOUNT_THRESHOLD_MIN, MICRON_POLYCOUNT_THRESHOLD_MAX, polycount);
+    }
+
     add(sg) {
 
         const geometry_id = sg.geometry.id;

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.36.23",
+  "version": "2.36.26",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",