@woosh/meep-engine 2.36.24 → 2.36.27

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/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,12 +20,22 @@ 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;
     }
 
+    /**
+     * Express intent to draw
+     * @param {ShadedGeometry} sg
+     * @returns {boolean} true if able to draw immediately, false otherwise
+     */
+    intend_draw(sg) {
+        return true;
+    }
+
     /**
      *
      * @param {ShadedGeometry} sg

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,114 @@
+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;
+        }
+
+        if (!adapters[best_adapter].intend_draw(sg)) {
+            // unable to draw, don't do anything
+            return false;
+        }
+
+        sg.draw_method = best_adapter;
+
+        return true;
+    }
+}

package/engine/graphics/ecs/mesh-v2/sample/load_gltf.js

@@ -7,6 +7,7 @@ import { three_object_to_entity_composition } from "../three_object_to_entity_co
 import { AttachmentSystem } from "../../../../ecs/attachment/AttachmentSystem.js";
 import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
 import { Camera } from "../../camera/Camera.js";
+import { MicronRenderPlugin } from "../../../micron/plugin/MicronRenderPlugin.js";
 
 const eh = new EngineHarness();
 
@@ -25,6 +26,8 @@ async function init(harness) {
     config.addSystem(new TransformAttachmentSystem());
     config.addLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
 
+    config.addPlugin( MicronRenderPlugin);
+
     await config.apply(engine);
 
     eh.initialize().then(main);

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -37,13 +37,6 @@ export class MicronRenderPlugin extends EnginePlugin {
         layer.managed = true;
         layer.renderPass = RenderPassType.Opaque;
 
-        /**
-         *
-         * @type {RenderLayer|null}
-         * @private
-         */
-        this.__micron_render_layer = layer;
-
         this.__vgtr.on.contextAdded.add(ctx => {
             const visibleSet = layer.visibleSet;
 
@@ -54,8 +47,6 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         });
 
-        this.__view_observers = new Map();
-
         /**
          *
          * @type {AsyncRemoteHashMap}
@@ -97,55 +88,6 @@ export class MicronRenderPlugin extends EnginePlugin {
         this.__sg_system = null;
     }
 
-    /**
-     *
-     * @param {THREE.WebGLRenderer} renderer
-     * @param {THREE.Camera} camera
-     * @param {THREE.Object3D[]} elements
-     * @param element_count
-     */
-    render(renderer, camera, elements, element_count = elements.length) {
-        const vgtr = this.__vgtr;
-
-        vgtr.clear();
-
-        vgtr.attachMany(elements, element_count);
-
-        vgtr.update(renderer, camera);
-        vgtr.render();
-    }
-
-    /**
-     *
-     * @param {CameraView} view
-     * @private
-     */
-    __handle_view_added(view) {
-        const observer = () => {
-            const ge = this.engine.graphics;
-
-            this.render(ge.renderer, view.camera, view.visible_objects.elements, view.visible_objects.size);
-        };
-
-        this.__view_observers.set(view, observer);
-
-
-        view.on.preRender.add(observer);
-    }
-
-    /**
-     *
-     * @param {CameraView} view
-     * @private
-     */
-    __handle_view_removed(view) {
-        const observer = this.__view_observers.get(view);
-
-        this.__view_observers.delete(view);
-
-        view.on.preRender.remove(observer);
-    }
-
     /**
      *
      * @param {System} system
@@ -214,20 +156,6 @@ export class MicronRenderPlugin extends EnginePlugin {
         am.registerTransformer("model/gltf", this.__asset_transformer);
         am.registerTransformer("model/gltf+json", this.__asset_transformer);
 
-        /**
-         *
-         * @type {GraphicsEngine}
-         */
-        const ge = engine.graphics;
-
-        ge.layers.add(this.__micron_render_layer);
-
-        ge.views.elements.on.added.add(this.__handle_view_added, this);
-        ge.views.elements.on.removed.add(this.__handle_view_removed, this);
-
-        // link all views
-        ge.views.elements.forEach(this.__handle_view_added, this);
-
         this.__persisted_geometry.attach_storage(engine.storage);
 
         engine.entityManager.on.systemAdded.add(this.__handle_system_added, this);
@@ -250,16 +178,6 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         this.__asset_transformer.assetManager = null;
 
-        const ge = engine.graphics;
-
-        ge.layers.remove(this.__micron_render_layer);
-
-        ge.views.elements.on.added.remove(this.__handle_view_added, this);
-        ge.views.elements.on.removed.remove(this.__handle_view_removed, this);
-
-        // clear all observer
-        ge.views.elements.forEach(this.__handle_view_removed, this);
-
         engine.entityManager.on.systemAdded.remove(this.__handle_system_added, this);
         engine.entityManager.on.systemRemoved.remove(this.__handle_system_removed, this);
 

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,13 +50,28 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
         this.__geometry_building_promises = new Map();
     }
 
-    add(sg) {
+    score(geometry, material, instance_count) {
+        const polycount = compute_geometry_polycount(geometry);
 
+        return inverseLerp(MICRON_POLYCOUNT_THRESHOLD_MIN, MICRON_POLYCOUNT_THRESHOLD_MAX, polycount);
+    }
+
+    /**
+     *
+     * @param {ShadedGeometry} sg
+     * @returns {MicronGeometry}
+     * @private
+     */
+    __obtain_micron_geometry(sg) {
         const geometry_id = sg.geometry.id;
 
         const micron_geometry = this.__geometry_map.get(geometry_id);
 
-        if (micron_geometry === undefined) {
+        if (micron_geometry !== undefined) {
+
+            return micron_geometry;
+
+        } else {
             // no micron geometry
             if (!this.__geometry_building_promises.has(geometry_id)) {
                 const p = buildMicronGeometryFromBufferGeometry(sg.geometry);
@@ -51,6 +80,20 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
 
                 p.then(mg => this.__geometry_map.set(geometry_id, mg));
             }
+            return undefined;
+        }
+
+    }
+
+    intend_draw(sg) {
+        return this.__obtain_micron_geometry(sg) !== undefined;
+    }
+
+    add(sg) {
+        const micron_geometry = this.__obtain_micron_geometry(sg);
+
+        if (micron_geometry === undefined) {
+            // no micron geometry
             return;
         }
 
@@ -74,6 +117,8 @@ export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
      * @param {CameraView} view
      */
     build_start(renderer, view) {
+        this.__object_count = 0;
+
         const resolution = new Vector2();
         let pixelRatio = 1;
 

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