@woosh/meep-engine 2.34.47 → 2.35.0

package/engine/graphics/material/optimization/UvContext.js

@@ -0,0 +1,18 @@
+import Vector2 from "../../../../core/geom/Vector2.js";
+import AABB2 from "../../../../core/geom/AABB2.js";
+
+export class UvContext {
+    constructor() {
+        /**
+         * Resolution of texture
+         * @type {Vector2}
+         */
+        this.resolution = new Vector2(1, 1);
+
+        /**
+         *
+         * @type {AABB2}
+         */
+        this.atlas_patch = new AABB2();
+    }
+}

package/engine/graphics/material/optimization/is_compliant_mesh.js

@@ -0,0 +1,71 @@
+import { TextureAttachmentsByMaterialType } from "../../../asset/loaders/material/TextureAttachmensByMaterialType.js";
+import { max2 } from "../../../../core/math/max2.js";
+import { BUFFER_GEOMETRY_UVS } from "./BUFFER_GEOMETRY_UVS.js";
+
+/**
+ * Is this mesh qualified to be optimized?
+ * @param {THREE.Mesh} mesh
+ * @returns {boolean}
+ */
+export function is_compliant_mesh(mesh) {
+    const material = mesh.material;
+
+    const attachments = TextureAttachmentsByMaterialType[material.type];
+
+    const uv_scales = [1, 1, 1, 1];
+
+    const texture_attachment_count = attachments.length;
+
+    for (let i = 0; i < texture_attachment_count; i++) {
+        const attachment = attachments[i];
+
+        const texture = attachment.read(material);
+        if (texture === undefined || texture === null) {
+            continue;
+        }
+
+        const uv_index = attachment.uv_index;
+
+        uv_scales[uv_index * 2] = max2(uv_scales[uv_index * 2], texture.repeat.x)
+        uv_scales[uv_index * 2 + 1] = max2(uv_scales[uv_index * 2 + 1], texture.repeat.y)
+    }
+
+    const geometry = mesh.geometry;
+
+    for (let i = 0; i < BUFFER_GEOMETRY_UVS.length; i++) {
+        const uv_metadata = BUFFER_GEOMETRY_UVS[i];
+
+        /**
+         *
+         * @type {THREE.BufferAttribute }
+         */
+        const attribute = geometry.attributes[uv_metadata.name];
+
+        if (attribute === undefined) {
+            continue;
+        }
+
+        const attribute_data = attribute.array;
+        const n = attribute_data.length;
+
+        const uv_index = uv_metadata.index;
+        const uv_index_2 = uv_index * 2;
+
+        for (let j = 0; j < n; j += 2) {
+            const x = attribute_data[j];
+            const y = attribute_data[j + 1];
+
+            const scaled_u = x * uv_scales[uv_index_2];
+            const scaled_v = y * uv_scales[uv_index_2 + 1];
+
+            if (scaled_u > 1 || scaled_u < 0 || scaled_v > 1 || scaled_v < 0) {
+                // repeating/negative UV value
+                return false;
+            }
+
+        }
+
+    }
+
+    return true;
+}

package/engine/graphics/material/optimization/prepare_atlas_texture.js

@@ -0,0 +1,23 @@
+import { LinearEncoding, LinearFilter, LinearMipmapLinearFilter, sRGBEncoding } from "three";
+
+/**
+ *
+ * @param {Texture} texture
+ * @param {string} attachment_name
+ */
+export function prepare_atlas_texture(texture, attachment_name) {
+
+    switch (attachment_name) {
+        case 'diffuse':
+            texture.encoding = sRGBEncoding;
+            break;
+        default:
+            texture.encoding = LinearEncoding;
+    }
+
+    texture.anisotropy = 4;
+    texture.minFilter = LinearMipmapLinearFilter;
+    texture.magFilter = LinearFilter;
+
+    texture.generateMipmaps = true;
+}

package/engine/graphics/material/optimization/prototypeMaterialOptimizer.js

@@ -0,0 +1,127 @@
+import { EngineHarness } from "../../../EngineHarness.js";
+import { EngineConfiguration } from "../../../EngineConfiguration.js";
+import { ShadedGeometrySystem } from "../../ecs/mesh-v2/ShadedGeometrySystem.js";
+import { AttachmentSystem } from "../../../ecs/attachment/AttachmentSystem.js";
+import { TransformAttachmentSystem } from "../../../ecs/transform-attachment/TransformAttachmentSystem.js";
+import { GameAssetType } from "../../../asset/GameAssetType.js";
+import { GLTFAssetLoader } from "../../../asset/loaders/GLTFAssetLoader.js";
+import { three_object_to_entity_composition } from "../../ecs/mesh-v2/three_object_to_entity_composition.js";
+import { MaterialOptimizationContext } from "./MaterialOptimizationContext.js";
+import { bvh_traverse_pre_order_using_stack } from "../../../../core/bvh2/traversal/bvh_traverse_pre_order_using_stack.js";
+
+const eh = new EngineHarness();
+
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function optimize(engine) {
+    MaterialOptimizationContext.MAX_TEXTURE_SIZE = engine.graphics.renderer.capabilities.maxTextureSize;
+
+    const optimizer = new MaterialOptimizationContext();
+
+    engine.graphics.layers.layers.forEach(l => {
+        bvh_traverse_pre_order_using_stack(l.bvh, node => {
+            if (node.isLeafNode) {
+                const object = l.extractRenderable(node.object);
+
+                if (object) {
+                    optimizer.addObject(object);
+                }
+            }
+        });
+    });
+
+    optimizer.update();
+
+    console.log(optimizer);
+
+    // drawSamplerHTML(document.body, optimizer.atlases.get('roughness'), 20, 20, 1, 0, 512);
+    // drawSamplerHTML(document.body, optimizer.atlases.get('metalness'), 532, 20, 1, 0, 512);
+    // drawSamplerHTML(document.body, optimizer.atlases.get('ao'), 20, 532, 1, 0, 512);
+    // drawSamplerHTML(document.body, optimizer.atlases.get('normal'), 532, 20, 1, 0, 512);
+    // drawSamplerHTML(document.body, optimizer.atlases.get('diffuse'), 20, 20, 1, 0, 1024);
+    // drawSamplerHTML(document.body, optimizer.atlases.get('normal'), 552, 20, 1, 0, 512);
+}
+
+/**
+ *
+ * @param {EngineHarness} harness
+ * @return {Promise<void>}
+ */
+async function init(harness) {
+    const engine = harness.engine;
+
+    const config = new EngineConfiguration();
+
+    config.addSystem(new ShadedGeometrySystem(engine));
+    config.addSystem(new AttachmentSystem());
+    config.addSystem(new TransformAttachmentSystem());
+
+    const gltf_loader = new GLTFAssetLoader();
+
+    config.addLoader(GameAssetType.ModelGLTF_JSON, gltf_loader);
+
+    await config.apply(engine);
+
+    eh.initialize().then(main);
+}
+
+/**
+ *
+ * @param {string} path
+ * @param {Engine} engine
+ */
+async function load_gltf(path, engine) {
+    const em = engine.entityManager;
+
+    const ecd = em.dataset;
+
+    const asset = await engine.assetManager.promise(path, GameAssetType.ModelGLTF_JSON);
+
+    const three_object = asset.create();
+
+    console.time('composition conversion');
+    const composition = three_object_to_entity_composition(three_object);
+    console.timeEnd('composition conversion');
+
+    console.time('composition build');
+    // console.profile('composition build');
+    composition.build(ecd);
+    // console.profileEnd('composition build');
+    console.timeEnd('composition build');
+}
+
+async function timeout(t = 1) {
+    await new Promise((resolve, reject) => setTimeout(resolve, t));
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+
+    EngineHarness.buildBasics({
+        engine,
+        enableWater: false,
+        enableTerrain: true
+    });
+
+    // a small delay to let background tasks finish, so we can get better performance reading later on
+    timeout(2000);
+
+    await load_gltf('moicon/06_04_hapro/08-clickable-assets-new/model.gltf', engine);
+    // await load_gltf('moicon/06_04_hapro/05-ground-floor/model.gltf', engine);
+
+    optimize(engine);
+
+    // load_gltf('moicon/06_04_hapro/07-1st-basement/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/06-lower-ground/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/05-ground-floor/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/04-1st-floor/model.gltf', engine);
+    // load_gltf('moicon/06_04_hapro/03-2nd-floor/model.gltf', engine);
+}
+
+init(eh);

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -76,8 +76,6 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
 
         await micron_cache.set(g, micron_geometry);
 
-        // console.log(micron_geometry);
-
         return micron_geometry;
     }
 

package/engine/graphics/micron/format/MicronGeometry.js

@@ -226,11 +226,9 @@ export class MicronGeometry {
                     }
 
                     // push to stack
-                    stack[stack_cursor] = child;
+                    stack[stack_cursor++] = child;
 
                     included_set.set(child.id, true);
-
-                    stack_cursor++;
                 }
             }
         }

package/engine/graphics/micron/format/MicronGeometryPatch.js

@@ -1,6 +1,6 @@
-import { squirrel3 } from "../../../../core/math/hash/squirrel3.js";
 import { ConicRay } from "../../../../core/geom/ConicRay.js";
 import { vec4 } from "gl-matrix";
+import { assert } from "../../../../core/assert.js";
 
 /**
  * Patches are organized into a tree hierarchy
@@ -13,36 +13,37 @@ export class MicronGeometryPatch {
          */
         this.id = 0;
 
-        /**
-         * Continuous memory region for various pieces of data to get better memory access patterns
-         * All pieces of data end up in a continuous piece of memory, resulting in better cache coherence
-         * @type {ArrayBuffer}
-         */
-        const array_buffer = new ArrayBuffer((6 + 6 + 24) * 4);
-
         /**
          * Bounds are used to determine screen error and whether a patch should be subdivided or not for rendering
          * @type {number[]}
          */
-        this.bounding_box = new Float32Array(array_buffer, 0, 6);
+        this.bounding_box = null;
 
         /**
          *
          * @type {vec4|number[]}
          */
-        this.bounding_sphere = vec4.create()
+        this.bounding_sphere = vec4.create();
 
         /**
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box = new Float32Array(array_buffer, 6 * 4, 6);
+        this.group_bounding_box = null;
 
         /**
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box_corners = new Float32Array(array_buffer, 12 * 4, 24);
+        this.group_bounding_box_corners = null;
+
+        /**
+         * Continuous memory region for various pieces of data to get better memory access patterns
+         * All pieces of data end up in a continuous piece of memory, resulting in better cache coherence
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer(144);
+        this.allocate_metadata(array_buffer, 0);
 
         /**
          *
@@ -114,21 +115,25 @@ export class MicronGeometryPatch {
     }
 
     /**
-     * @deprecated
+     *
+     * @param {ArrayBuffer} buffer
+     * @param {number} offset
+     * @returns {number}
      */
-    get parent() {
-        throw new Error('Single parent is no longer supported, use .parents instead');
-    }
+    allocate_metadata(buffer, offset) {
+        assert.greaterThanOrEqual(buffer.byteLength, offset + 144, 'buffer underflow');
 
-    /**
-     * @deprecated
-     */
-    set parent(v) {
-        throw new Error('Single parent is no longer supported, use .parents instead');
+        this.bounding_box = new Float32Array(buffer, offset, 6);
+
+        this.group_bounding_box = new Float32Array(buffer, offset + 24, 6);
+
+        this.group_bounding_box_corners = new Float32Array(buffer, offset + 48, 24);
+
+        return 144;
     }
 
     hash() {
-        return squirrel3(this.id);
+        return this.id;
     }
 
     computeByteSize() {
@@ -136,8 +141,13 @@ export class MicronGeometryPatch {
 
         result += this.face_indices.buffer.byteLength;
 
-        for (let i = 0; i < this.vertex_attribute_arrays.length; i++) {
-            result += this.vertex_attribute_arrays[i].buffer.byteLength;
+        const attribute_arrays = this.vertex_attribute_arrays;
+        const attribute_count = attribute_arrays.length;
+
+        for (let i = 0; i < attribute_count; i++) {
+            const attribute_array = attribute_arrays[i];
+
+            result += attribute_array.buffer.byteLength;
         }
 
         return result;

package/engine/graphics/micron/format/VirtualGeometry.js

@@ -1,12 +1,31 @@
+import { MicronGeometryPatchOccurrence } from "./MicronGeometryPatchOccurance.js";
+
 export class VirtualGeometry {
     constructor() {
+        /**
+         * pack patch instance as [INSTANCE_ID, GEOMETRY_ID, PATCH_ID]
+         * @type {number[]}
+         */
+        this.patches = new Uint32Array(300000);
+
         /**
          *
-         * @type {MicronGeometryPatchOccurrence[]}
+         * @type {number}
          */
-        this.patches = [];
         this.patch_count = 0;
 
+        /**
+         * Lookup table of matrix transforms
+         * @type {number[][]}
+         */
+        this.lookup_instance_transforms = [];
+
+        /**
+         * Lookup table of geometries
+         * @type {MicronGeometry[]}
+         */
+        this.loolup_geometries = [];
+
         /**
          *
          * @type {number}
@@ -30,11 +49,20 @@ export class VirtualGeometry {
      */
     computeFaceCount() {
         let r = 0;
-        const patchCount = this.patch_count;
-        for (let i = 0; i < patchCount; i++) {
-            const occurrence = this.patches[i];
+        const patch_count = this.patch_count;
+        const patches = this.patches;
+
+        for (let i = 0; i < patch_count; i++) {
+            const i3 = i * 3;
+
+            const geometry_id = patches[i3 + 1];
+            const patch_id = patches[i3 + 2];
+
+            const geometry = this.loolup_geometries[geometry_id];
 
-            r += occurrence.patch.polygon_count;
+            const patch = geometry.patches[patch_id];
+
+            r += patch.polygon_count;
         }
 
         return r;
@@ -46,11 +74,19 @@ export class VirtualGeometry {
      */
     computeVertexCount() {
         let r = 0;
-        const patchCount = this.patch_count;
-        for (let i = 0; i < patchCount; i++) {
-            const occurrence = this.patches[i];
+        const patch_count = this.patch_count;
+        const patches = this.patches;
+        for (let i = 0; i < patch_count; i++) {
+            const i3 = i * 3;
+
+            const geometry_id = patches[i3 + 1];
+            const patch_id = patches[i3 + 2];
+
+            const geometry = this.loolup_geometries[geometry_id];
+
+            const patch = geometry.patches[patch_id];
 
-            r += occurrence.patch.vertex_count;
+            r += patch.vertex_count;
         }
 
         return r;
@@ -61,7 +97,7 @@ export class VirtualGeometry {
      * @param {MicronGeometryPatchOccurrence} patch
      */
     add(patch) {
-        this.patches[this.patch_count++] = patch;
+        throw new Error('Deprecated');
     }
 
     clear() {

package/engine/graphics/micron/format/serialization/MicronGeometryBinarySerializationAdapter.js

@@ -77,25 +77,47 @@ export class MicronGeometryBinarySerializationAdapter extends BinaryClassSeriali
 
         const patch_count = buffer.readUintVar();
 
+        /**
+         *
+         * @type {MicronGeometryPatch[]}
+         */
         const patches = [];
 
+        // for the sake of speed, we will allocate all metadata in the same piece of memory to make traversal of patch hierarchy faster
+        const md_buffer = new ArrayBuffer(patch_count * 144);
+        let md_buffer_offset = 0;
+
         // build initial patches
         for (let i = 0; i < patch_count; i++) {
             const patch = new MicronGeometryPatch();
 
             patch.id = i;
 
+            md_buffer_offset += patch.allocate_metadata(md_buffer, md_buffer_offset);
+
             patches[i] = patch;
         }
 
+        let source_triangle_count = 0;
+        // NOTE: we can't easily find out source vertex count as vertices are duplicated across patches
+
+
         //read patches
         for (let i = 0; i < patch_count; i++) {
             const patch = patches[i];
 
             deserialize_patch(buffer, patch, vertex_spec, patches);
+
+            // collect source metadata
+            if (patch.lod === 0) {
+                source_triangle_count += patch.polygon_count;
+            }
         }
 
         value.patches = patches;
         value.root = patches[root_patch_index];
+
+        // write source metadata
+        value.source_triangle_count = source_triangle_count;
     }
 }

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -1,10 +1,8 @@
 import {
     AmbientLight,
     BoxBufferGeometry,
-    CameraHelper,
     CubeTextureLoader,
     DirectionalLight,
-    DirectionalLightHelper,
     FrontSide,
     Matrix4,
     Mesh,
@@ -64,6 +62,10 @@ metrics.create({
     name: 'adapter_update', buffer_size: METRIC_BUFFER_SIZE
 });
 
+metrics.create({
+    name: 'debug_v0', buffer_size: METRIC_BUFFER_SIZE
+});
+
 let container, stats;
 
 let camera, scene, renderer;
@@ -261,8 +263,8 @@ function init() {
 
     // shadow_camera.onBeforeRender = do_vgrt_update;
 
-    scene.add(new CameraHelper(shadow_camera));
-    scene.add(new DirectionalLightHelper(directionalLight));
+    // scene.add(new CameraHelper(shadow_camera));
+    // scene.add(new DirectionalLightHelper(directionalLight));
 
     shadow_camera.updateProjectionMatrix();
 
@@ -459,7 +461,7 @@ function init() {
 
     // sample_gltf_sponza();
     // gltf_sample('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
-    sample_lucy();
+    // sample_lucy();
     // sample_dragon();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
@@ -479,6 +481,9 @@ function init() {
     // gltf_sample('moicon/03_Jan_22_Demo/8-assets/model.gltf');
     // gltf_sample('moicon/03_Jan_22_Demo/worker_test/model.gltf');
     // gltf_sample('moicon/A4/A4/model.gltf');
+    gltf_sample('moicon/06_04_hapro/08-clickable-assets-new/model.gltf');
+    // gltf_sample('moicon/ztest_object_many_pieces/model.gltf');
+    // gltf_grid('moicon/ztest_object_many_pieces/model.gltf', 3, 3);
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 

package/engine/graphics/micron/render/VirtualGeometryBuilder.js

@@ -1,10 +1,10 @@
 import { array_copy } from "../../../../core/collection/array/copyArray.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
-import { MicronGeometryPatchOccurrence } from "../format/MicronGeometryPatchOccurance.js";
 import { RefinementSpec } from "./refinement/RefinementSpec.js";
 import { ActivePatchList } from "./refinement/ActivePatchList.js";
-import { ActivePatchFlags } from "./refinement/ActivePatchFlags.js";
 import { mat4 } from "gl-matrix";
+import { get_geometry_patch_cut } from "./refinement/get_geometry_patch_cut.js";
+import { traverseThreeObject } from "../../ecs/highlight/renderer/traverseThreeObject.js";
 
 /**
  * @readonly
@@ -107,7 +107,7 @@ export class VirtualGeometryBuilder {
     }
 
     /**
-     *
+     * @private
      * @param {THREE.Object3D|ThreeMicronMesh} object
      */
     buildForObject(object) {
@@ -134,15 +134,6 @@ export class VirtualGeometryBuilder {
                 );
             }
         }
-
-        const children = object.children;
-        const children_count = children.length;
-
-        for (let i = 0; i < children_count; i++) {
-            const child = children[i];
-
-            this.buildForObject(child);
-        }
     }
 
     /**
@@ -158,8 +149,6 @@ export class VirtualGeometryBuilder {
         transform,
         apl
     ) {
-        apl.initializeFromGeometry(geometry);
-
         refinement_spec.build(transform, this.view_projection_matrix);
 
         const output = this.output;
@@ -168,48 +157,17 @@ export class VirtualGeometryBuilder {
         output.stats_source_triangle_count += geometry.source_triangle_count;
         output.stats_source_vertex_count += geometry.source_vertex_count;
 
-        // apl.build_from_lod(geometry, 0);
-        apl.refine(refinement_spec);
+        output.loolup_geometries[geometry.id] = geometry;
+        output.lookup_instance_transforms[instance_id] = transform;
 
         // build up occurances
-        const output_patches = output.patches;
-        let output_patch_cursor = output.patch_count;
-        let patch_instance;
-
-        const geometry_id = geometry.id;
-
-        for (
-            let record = apl.records;
-            record !== null;
-            record = record.link_next
-        ) {
-
-            if (!record.getFlag(ActivePatchFlags.Visible)) {
-                // patch is not visible, skip
-                continue;
-            }
-
-            const patch = record.patch;
-            patch_instance = output_patches[output_patch_cursor];
-
-            if (patch_instance === undefined) {
-                // no instance available for reuse - create a new one
-                patch_instance = new MicronGeometryPatchOccurrence();
-                output_patches[output_patch_cursor] = patch_instance;
-            }
-
-            patch_instance.instance_id = instance_id;
-            patch_instance.geometry_id = geometry_id;
-            patch_instance.patch = patch;
-            patch_instance.transform = transform;
-
-            output_patch_cursor++;
-        }
-
-        output.patch_count = output_patch_cursor;
-
-
-        // TODO sort patches based on camera distance to better utilize z-culling in hardware
+        get_geometry_patch_cut(
+            output,
+            refinement_spec,
+            geometry,
+            instance_id,
+            transform
+        );
     }
 
     clearScene() {
@@ -243,10 +201,11 @@ export class VirtualGeometryBuilder {
         const n = this.input_scene_length;
         const input_objects = this.input_scene;
 
+
         for (let i = 0; i < n; i++) {
             const object3D = input_objects[i];
 
-            this.buildForObject(object3D);
+            traverseThreeObject(object3D, this.buildForObject, this);
         }