@woosh/meep-engine 2.39.38 → 2.39.41

package/engine/graphics/geometry/optimization/merge/prototypeGeometryMerge.js

@@ -0,0 +1,176 @@
+import { EngineHarness } from "../../../../EngineHarness.js";
+import RenderSystem from "../../../../ecs/systems/RenderSystem.js";
+
+import '../../../../../../../../css/main.scss';
+import { GameAssetType } from "../../../../asset/GameAssetType.js";
+import { TextureAssetLoader } from "../../../../asset/loaders/texture/TextureAssetLoader.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import Vector2 from "../../../../../core/geom/Vector2.js";
+import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
+import EntityBuilder from "../../../../ecs/EntityBuilder.js";
+import Renderable from "../../../../ecs/components/Renderable.js";
+import { Transform } from "../../../../ecs/transform/Transform.js";
+import { merge_geometry_hierarchy } from "./merge_geometry_hierarchy.js";
+import {
+    AmbientOcclusionPostProcessEffect
+} from "../../../render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
+import GUIElementSystem from "../../../../ecs/gui/GUIElementSystem.js";
+import ViewportPositionSystem from "../../../../ecs/gui/position/ViewportPositionSystem.js";
+import HeadsUpDisplaySystem from "../../../../ecs/gui/hud/HeadsUpDisplaySystem.js";
+import HeadsUpDisplay from "../../../../ecs/gui/hud/HeadsUpDisplay.js";
+import ViewportPosition from "../../../../ecs/gui/position/ViewportPosition.js";
+import GUIElement from "../../../../ecs/gui/GUIElement.js";
+import LabelView from "../../../../../view/common/LabelView.js";
+import { halton_sequence } from "../../../../../core/math/statistics/halton_sequence.js";
+import { Color } from "../../../../../core/color/Color.js";
+import { MeshStandardMaterial } from 'three';
+import { lerp } from "../../../../../core/math/lerp.js";
+import { cloneObject3D } from "../../../three/cloneObject3D.js";
+
+function apply_random_coloring(object) {
+    const result = cloneObject3D(object);
+
+    const material_set = new Map();
+
+    result.traverse(o => {
+        if (o.isMesh) {
+            let objects = material_set.get(o.geometry);
+
+            if (objects === undefined) {
+                objects = [];
+                material_set.set(o.geometry, objects);
+            }
+
+            objects.push(o);
+        }
+    });
+
+    const material_array = Array.from(material_set.keys());
+
+    const material_count = material_array.length;
+    for (let i = 0; i < material_count; i++) {
+
+        const key_0 = i % 32;
+        const key_1 = Math.ceil(i / 64)
+
+        const h = halton_sequence(32, key_0);
+        const s = halton_sequence(Math.ceil(material_count / 64), key_1)
+
+        const material = material_array[i];
+
+        const objects = material_set.get(material);
+
+        const m = new MeshStandardMaterial({ color: Color.fromHSV(h, lerp(0.6, 1, s), 1).toUint() });
+
+
+        objects.forEach(o => {
+            o.material = m;
+        });
+    }
+
+    return result;
+}
+
+function compute_meshes(o) {
+    let r = 0;
+    o.traverse(obj => {
+        if (obj.isMesh) {
+
+            r++;
+
+        }
+    });
+
+    return r;
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+    await EngineHarness.buildBasics({
+        engine,
+        yaw: 0,
+        pitch: 1,
+        focus: new Vector3(138, 0, 125),
+        distance: 30,
+        terrainResolution: 1,
+        terrainSize: new Vector2(128, 128),
+        enableWater: false
+    });
+
+    const gltf = await engine.assetManager.promise("moicon/gnutti_not_optimized/model.gltf", GameAssetType.ModelGLTF_JSON);
+
+    const hierarchy = gltf.create();
+
+    const optimized_hierarchy = merge_geometry_hierarchy(hierarchy);
+
+    const css = {
+        background: "rgba(0,0,0,0.5)",
+        color: "white",
+        border: "1px solid black",
+        width: "min-content",
+        padding: "4px",
+        borderRadius: "4px",
+        whiteSpace: "pre"
+    };
+
+    new EntityBuilder()
+        .add(new Renderable(apply_random_coloring(optimized_hierarchy)))
+        .add(Transform.fromJSON({
+            position: new Vector3(128, 2, 128)
+        }))
+        .add(HeadsUpDisplay.fromJSON({
+            worldOffset: new Vector3(0, 2, 0)
+        }))
+        .add(new ViewportPosition())
+        .add(GUIElement.fromView(new LabelView(`optimized\ninstances: ${compute_meshes(optimized_hierarchy)}`, {
+            css
+        })))
+        .build(engine.entityManager.dataset);
+
+    new EntityBuilder()
+        .add(new Renderable(apply_random_coloring(hierarchy)))
+        .add(Transform.fromJSON({
+            position: new Vector3(138, 2, 128)
+        }))
+        .add(HeadsUpDisplay.fromJSON({
+            worldOffset: new Vector3(0, 2, 0)
+        }))
+        .add(new ViewportPosition())
+        .add(GUIElement.fromView(new LabelView(`original\ninstances: ${compute_meshes(hierarchy)}`, {
+            css
+        })))
+        .build(engine.entityManager.dataset);
+
+
+    new EntityBuilder()
+        .add(new Renderable(optimized_hierarchy))
+        .add(Transform.fromJSON({
+            position: new Vector3(148, 2, 128)
+        }))
+        .add(HeadsUpDisplay.fromJSON({
+            worldOffset: new Vector3(0, 2, 0)
+        }))
+        .add(new ViewportPosition())
+        .add(GUIElement.fromView(new LabelView(`original look`, {
+            css
+        })))
+        .build(engine.entityManager.dataset);
+
+}
+
+new EngineHarness().initialize({
+    configuration(config, engine) {
+        config.addSystem(new RenderSystem(engine.graphics));
+        config.addSystem(new GUIElementSystem(engine.gameView, engine));
+        config.addSystem(new ViewportPositionSystem(engine.graphics.viewport.size));
+        config.addSystem(new HeadsUpDisplaySystem(engine.graphics));
+
+        config.addLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
+        config.addLoader(GameAssetType.Texture, new TextureAssetLoader());
+
+        config.addPlugin(AmbientOcclusionPostProcessEffect);
+    }
+}).then(main)

package/engine/graphics/micron/build/hierarchy/buildAbstractPatchHierarchy.js

@@ -86,8 +86,7 @@ async function assemble_graph(nodes) {
         build_vertex_quadratics({ mesh: patch.topology_snapshot, quadratics: vertex_quadratics });
     }
 
-
-    main_loop: while (__node_count.value > 1) {
+    while (__node_count.value > 1) {
 
         // assemble nodes into a graph
         const leaf_cluster_weight_graph = build_merge_graph(__nodes);
@@ -121,6 +120,7 @@ async function assemble_graph(nodes) {
         await Promise.all(__promises);
 
         if (__node_count.value >= old_node_count) {
+            // new graph has the same number of nodes as the old one
 
             if (leaf_cluster_weight_graph.getNodeCount() <= 1) {
                 // graph is already merged to the maximum level
@@ -131,10 +131,14 @@ async function assemble_graph(nodes) {
                 throw new Error(`Exceeded merge limit(=${LIMIT_MERGE_COUNT}), attempting to merge too many patches together`);
             }
 
+            if (old_node_count <= merge_count) {
+                throw new Error(`Already allowing to merge all of the nodes, yet merge still fails. Allowed patch count = ${merge_count}, Actual patches = ${old_node_count})`);
+            }
+
             // failed to do any merging, increase merge scope
             merge_count *= 2;
 
-            continue main_loop;
+            continue;
         }
 
         // clear existing neighbours for this level

package/engine/graphics/micron/build/hierarchy/merge_patches.js

@@ -415,7 +415,6 @@ async function many_to_many_merge(
         merged_mesh._addWithVertexMap(child.topology_snapshot, vertex_map);
     }
 
-
     /**
      *
      * @type {Set<number>}

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -518,11 +518,11 @@ function init() {
     // gltf_grid('moicon/ztest_object_many_pieces/model.gltf', 3, 3);
     // gltf_sample('moicon/ztest_object_many_pieces/model.gltf');
     // gltf_sample('moicon/62cf22227f7b8f0012ca5988/model.gltf');
-    gltf_sample('moicon/gnutti_not_optimized/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');
-    // sample_lucy();
+    sample_lucy();
     // sample_square();
     // sample_isiflow_floor();
 
@@ -596,7 +596,7 @@ function createScene(geometry, m1, scale) {
     geometry.computeVertexNormals();
 
 
-    const grid_size = 1;
+    const grid_size = 100;
     const grid_spacing = 2000;
 
     for (let i = 0; i < grid_size; i++) {

package/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js

@@ -193,7 +193,7 @@ export class ParameterLookupTable {
 
     /**
      *
-     * @param {number[]|Float64Array|Float32Array} values
+     * @param {number[]|Float64Array|Float32Array|Uint8Array} values
      * @param {number[]|Float64Array|Float32Array} [positions]
      */
     write(values, positions) {
@@ -412,6 +412,37 @@ export class ParameterLookupTable {
 
         return r;
     }
+
+    /**
+     *
+     * @param {Color} colors
+     * @returns {ParameterLookupTable}
+     */
+    static color_uint8_uniform(...colors) {
+        assert.defined(colors, 'colors');
+
+        const r = new ParameterLookupTable(4);
+
+        const length = colors.length;
+        const values = new Uint8Array(length * 4);
+
+        for (let i = 0; i < length; i++) {
+            const color = colors[i];
+
+            const i4 = i * 4;
+
+            values[i4] = Math.round(color.r * 255);
+            values[i4 + 1] = Math.round(color.g * 255);
+            values[i4 + 2] = Math.round(color.b * 255);
+            values[i4 + 3] = Math.round(color.a * 255);
+        }
+
+        r.write(values);
+
+        r.computeUniformPositions();
+
+        return r;
+    }
 }
 
 /**

package/engine/graphics/render/forward_plus/LightManager.js

@@ -111,13 +111,13 @@ function encode_light_type(light) {
 
 /**
  *
- * @param {number} index
+ * @param {number} address
  * @param {AbstractLight} light
  * @returns {number}
  */
-function encode_light_descriptor(index, light) {
+function encode_light_descriptor(address, light) {
     const light_type = encode_light_type(light);
-    return light_type | (index << 2);
+    return light_type | (address << 2);
 }
 
 export class LightManager {
@@ -147,7 +147,7 @@ export class LightManager {
         this.__cluster_texture_precision = 8;
         this.__cluster_texture_needs_rebuild = false;
         this.__cluster_texture = new DataTexture3D(
-            new Uint16Array(1),
+            new Uint16Array(3),
             1,
             1,
             1,
@@ -204,12 +204,12 @@ export class LightManager {
 
         /**
          *
-         * @type {CachingTextureAtlas}
+         * @type {AbstractTextureAtlas}
          * @readonly
          * @private
          */
         this.__decal_atlas = new CachingTextureAtlas({
-            atlas: new TextureAtlas(16)
+            atlas: new TextureAtlas(512)
         });
 
         /**
@@ -221,7 +221,7 @@ export class LightManager {
 
         /**
          *
-         * @type {Map<Decal, Reference>}
+         * @type {Map<Decal, Reference<AtlasPatch>>}
          * @private
          */
         this.__decal_references = new Map();
@@ -301,14 +301,16 @@ export class LightManager {
          * @private
          */
         this.__visible_bvh_needs_update = true;
-
-        this.__decal_atlas.atlas.on.painted.add(this.__update_decal_atlas_texture, this);
     }
 
     __update_decal_atlas_texture() {
-        const sampler = this.__decal_atlas.atlas.sampler;
+        const sampler = this.__decal_atlas.sampler;
+
+        if (sampler.version !== this.__decal_atlas_texture.version) {
+            writeSample2DDataToDataTexture(sampler, this.__decal_atlas_texture);
 
-        writeSample2DDataToDataTexture(sampler, this.__decal_atlas_texture);
+            this.__decal_atlas_texture.version = sampler.version;
+        }
     }
 
     /**
@@ -408,7 +410,7 @@ export class LightManager {
     /**
      * @returns {DataTexture}
      */
-    getDecalTexture() {
+    getTextureDecalAtlas() {
         return this.__decal_atlas_texture;
     }
 
@@ -443,6 +445,17 @@ export class LightManager {
         if (light instanceof Decal) {
             const ref = this.__decal_patch_references.acquire(light.texture_diffuse);
 
+            const patch = ref.getValue();
+            const patch_uv = patch.uv;
+
+            patch_uv.position.onChanged.add(light.handleUvPositionChange, light);
+            patch_uv.size.onChanged.add(light.handleUvSizeChange, light);
+
+            light.uv[0] = patch_uv.position.x;
+            light.uv[1] = patch_uv.position.y;
+            light.uv[2] = patch_uv.size.x;
+            light.uv[3] = patch_uv.size.y;
+
             this.__decal_references.set(light, ref);
         }
     }
@@ -461,6 +474,14 @@ export class LightManager {
         if (light instanceof Decal) {
             const ref = this.__decal_references.get(light);
 
+            const patch = ref.getValue();
+            const patch_uv = patch.uv;
+
+            // unsubscribe
+            patch_uv.position.onChanged.remove(light.handleUvPositionChange, light);
+            patch_uv.size.onChanged.remove(light.handleUvSizeChange, light);
+
+
             ref.release();
 
             this.__decal_references.delete(light);
@@ -655,6 +676,8 @@ export class LightManager {
             address += light.ENCODED_SLOT_COUNT;
         }
 
+        const expected_light_data_size = address;
+
 
         const light_data = this.__light_data;
         light_data.resize(Math.ceil(address / 4));
@@ -696,15 +719,24 @@ export class LightManager {
 
             // align address to 4 slot boundary
             if ((address & 3) !== 0) {
+                // not on 4 slot boundary
                 address = ((address >> 2) + 1) << 2;
             }
         }
 
+        if (address !== expected_light_data_size) {
+            throw new Error(`Expected light data size is ${expected_light_data_size}, actual written data is size is ${address}`);
+        }
+
         tx_light.needsUpdate = true;
 
         this.__visible_bvh_needs_update = true;
     }
 
+    /**
+     * Perform cluster assignment where each cluster is filled with overlapping lights
+     * @private
+     */
     __assign_lights_to_clusters() {
 
         const tiles_resolution = this.__tiles_resolution;
@@ -916,6 +948,10 @@ export class LightManager {
         // console.log('Unique assignment count: ', assignment_count, ', Hash reuse:', hash_reuse_count);
     }
 
+    /**
+     *
+     * @private
+     */
     __build_cluster_frustum_planes() {
         const tiles_resolution = this.__tiles_resolution;
 
@@ -928,6 +964,10 @@ export class LightManager {
         compute_cluster_planes_from_points(destination, this.__cluster_frustum_points, tr_x, tr_y, tr_z);
     }
 
+    /**
+     *
+     * @private
+     */
     __build_view_frustum_points() {
 
         const view_frustum = this.__view_frustum;
@@ -937,6 +977,10 @@ export class LightManager {
         computeFrustumCorners(points, view_frustum.planes);
     }
 
+    /**
+     *
+     * @private
+     */
     __build_cluster_frustum_points() {
         const tiles_resolution = this.__tiles_resolution;
 
@@ -1059,7 +1103,8 @@ export class LightManager {
         // console.timeEnd('__build_visible_light_list');
 
         // update decal atlas
-        this.__decal_atlas.atlas.update();
+        this.__decal_atlas.update();
+        this.__update_decal_atlas_texture();
 
         // console.time('__write_light_data_texture');
         if (this.__light_data_needs_update) {