@woosh/meep-engine 2.34.49 → 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/format/MicronGeometryPatch.js

@@ -23,7 +23,7 @@ export class MicronGeometryPatch {
          *
          * @type {vec4|number[]}
          */
-        this.bounding_sphere = vec4.create()
+        this.bounding_sphere = vec4.create();
 
         /**
          *

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,6 +77,10 @@ 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
@@ -94,14 +98,26 @@ export class MicronGeometryBinarySerializationAdapter extends BinaryClassSeriali
             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

@@ -481,8 +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/ztest_object_many_pieces/model.gltf');
-    // gltf_grid('moicon/ztest_object_many_pieces/model.gltf', 10, 10);
+    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

@@ -157,19 +157,17 @@ export class VirtualGeometryBuilder {
         output.stats_source_triangle_count += geometry.source_triangle_count;
         output.stats_source_vertex_count += geometry.source_vertex_count;
 
-        // build up occurances
-        const output_patches = output.patches;
+        output.loolup_geometries[geometry.id] = geometry;
+        output.lookup_instance_transforms[instance_id] = transform;
 
-        const added_patch_count = get_geometry_patch_cut(
-            output_patches,
-            output.patch_count,
+        // build up occurances
+        get_geometry_patch_cut(
+            output,
             refinement_spec,
             geometry,
             instance_id,
             transform
         );
-
-        output.patch_count += added_patch_count;
     }
 
     clearScene() {

package/engine/graphics/micron/render/instanced/AttributeDataTexture.js

@@ -3,55 +3,11 @@ import { MICRON_PATCH_SIZE_MAX } from "../../build/MICRON_PATCH_SIZE_MAX.js";
 import { typed_array_copy } from "../../../../../core/collection/array/typed/typed_array_copy.js";
 import { channelCountToThreeTextureFormat } from "../../../texture/channelCountToThreeTextureFormat.js";
 import { DataTexture, NearestFilter } from "three";
-import { DataType } from "../../../../../core/collection/table/DataType.js";
 import { compute_micron_buffer_array_constructor } from "../../build/compute_micron_buffer_array_constructor.js";
 import { computeThreeTextureTypeFromDataType } from "../../../render/forward_plus/data/computeThreeTextureTypeFromDataType.js";
 import { computeThreeTextureInternalFormatFromDataType } from "../../../render/forward_plus/data/computeThreeTextureInternalFormatFromDataType.js";
 import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
-
-/**
- *
- * @returns {string}
- * @param {DataType} dt
- * @param {number} channel_count
- */
-function normalized_internal_format(dt, channel_count) {
-    let suffix = '';
-    switch (dt) {
-        case DataType.Uint8:
-            suffix = '8';
-            break;
-        case DataType.Int8:
-            suffix = '8_SNORM';
-            break;
-        case DataType.Uint16:
-            suffix = '16UI';
-            break;
-        default:
-            throw new Error(`Unsupported data type '${dt}'`);
-    }
-
-    let prefix = '';
-
-    switch (channel_count) {
-        case 1:
-            prefix = 'R';
-            break;
-        case 2:
-            prefix = 'RG';
-            break;
-        case 3:
-            prefix = 'RGB';
-            break;
-        case 4:
-            prefix = 'RGBA';
-            break;
-        default:
-            throw new Error(`Unsupported channel count '${channel_count}'`);
-    }
-
-    return prefix + suffix;
-}
+import { normalized_internal_format } from "../../../texture/normalized_internal_format.js";
 
 export class AttributeDataTexture {
     /**

package/engine/graphics/micron/render/instanced/ThreeInstancedAdapter.js

@@ -132,15 +132,16 @@ export class ThreeInstancedAdapter {
 
     /**
      *
-     * @param {MicronGeometryPatchOccurrence[]} patches
+     * @param {Uint32Array[]} patches
      * @param {number} patch_count
+     * @param {VirtualGeometry} virtual_geometry
      */
-    build(patches, patch_count) {
+    build(patches, patch_count, virtual_geometry) {
         this.__prepare_capacity(patch_count);
 
         const geo = this.__buffer_geometry;
 
-        const patch_transform_attribute = geo.getAttribute(ATTRIBUTE_NAME_TRANSFORM);
+        const patch_transform_attribute = geo.attributes[ATTRIBUTE_NAME_TRANSFORM];
         /**
          *
          * @type {Float32Array}
@@ -149,21 +150,31 @@ export class ThreeInstancedAdapter {
 
         patch_transform_attribute.needsUpdate = true;
 
-        const patch_address_attribute = geo.getAttribute(ATTRIBUTE_NAME_ADDRESS);
+        const patch_address_attribute = geo.attributes[ATTRIBUTE_NAME_ADDRESS];
         const patch_address_array = patch_address_attribute.array;
 
         patch_address_attribute.needsUpdate = true;
 
         const patch_data = this.__patch_data;
+        const transforms = virtual_geometry.lookup_instance_transforms;
+        const geometries = virtual_geometry.loolup_geometries;
 
         for (let i = 0; i < patch_count; i++) {
-            const occurrence = patches[i];
+            const i3 = i * 3;
+
+            const instance_id = patches[i3];
+            const geometry_id = patches[i3 + 1];
+            const patch_id = patches[i3 + 2];
+
+            const transform = transforms[instance_id];
+            const micron_geometry = geometries[geometry_id];
+            const patch = micron_geometry.patches[patch_id];
 
             const i16 = i * 16;
 
-            patch_transform_array.set(occurrence.transform, i16);
+            patch_transform_array.set(transform, i16);
 
-            const patch_slot_id = patch_data.ensure(occurrence.patch);
+            const patch_slot_id = patch_data.ensure(patch);
 
             patch_address_array[i] = patch_slot_id;
         }

package/engine/graphics/micron/render/refinement/RefinementSpec.js

@@ -37,7 +37,6 @@ export class RefinementSpec {
          */
         const array_buffer = new ArrayBuffer(160);
 
-
         /**
          * Contains transformation from camera space to object space
          * @type {Float32Array|number[]|mat4}

package/engine/graphics/micron/render/refinement/get_geometry_patch_cut.js

@@ -1,6 +1,5 @@
 import { BitSet } from "../../../../../core/binary/BitSet.js";
 import { aabb3_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum_array.js";
-import { MicronGeometryPatchOccurrence } from "../../format/MicronGeometryPatchOccurance.js";
 import { aabb3_estimate_projected_area2 } from "../../../../../core/geom/3d/aabb/aabb3_estimate_projected_area2.js";
 
 
@@ -12,24 +11,22 @@ const scratch_traversal_bitset = new BitSet();
 scratch_traversal_bitset.preventShrink();
 
 /**
+ * Using a pre-allocated continuous chunk of memory gets us better cache coherence
  * @readonly
- * @type {MicronGeometryPatch[]}
+ * @type {number[]}
  */
-const scratch_traversal_stack = [];
+const scratch_traversal_stack = new Uint32Array(781250);
 
 /**
  *
- * @param {MicronGeometryPatchOccurrence[]} destination
- * @param {number} destination_offset
+ * @param {VirtualGeometry} destination
  * @param {RefinementSpec} spec
  * @param {MicronGeometry} geometry
  * @param instance_id
  * @param transform
- * @returns {number}
  */
 export function get_geometry_patch_cut(
     destination,
-    destination_offset,
     spec,
     geometry,
     instance_id,
@@ -42,26 +39,29 @@ export function get_geometry_patch_cut(
 
     const geometry_id = geometry.id;
 
-    let output_patch_cursor = destination_offset;
+    let output_patch_cursor = destination.patch_count;
 
     let i;
     let stack_cursor = 1;
-    let patch_instance;
 
     // initialize stack
     const stack = scratch_traversal_stack;
     const root = geometry.root;
-    stack[0] = root;
+    stack[0] = root.id;
 
     const included_set = scratch_traversal_bitset;
     included_set.reset();
 
     included_set.set(root.id, true);
 
+    const patches = geometry.patches;
+    const destination_patches = destination.patches;
+
     while (stack_cursor > 0) {
         stack_cursor--;
 
-        const patch = stack[stack_cursor];
+        const patch_id = stack[stack_cursor];
+        const patch = patches[patch_id];
 
         /*
          check if node is in view frustum
@@ -96,7 +96,7 @@ export function get_geometry_patch_cut(
                         continue;
                     }
 
-                    stack[stack_cursor++] = child;
+                    stack[stack_cursor++] = child.id;
                 }
 
                 continue;
@@ -104,22 +104,15 @@ export function get_geometry_patch_cut(
         }
 
 
-        patch_instance = destination[output_patch_cursor];
-
-        if (patch_instance === undefined) {
-            // no instance available for reuse - create a new one
-            patch_instance = new MicronGeometryPatchOccurrence();
-            destination[output_patch_cursor] = patch_instance;
-        }
+        const target_address = output_patch_cursor * 3;
 
-        patch_instance.instance_id = instance_id;
-        patch_instance.geometry_id = geometry_id;
-        patch_instance.patch = patch;
-        patch_instance.transform = transform;
+        destination_patches[target_address] = instance_id;
+        destination_patches[target_address + 1] = geometry_id;
+        destination_patches[target_address + 2] = patch_id;
 
         output_patch_cursor++;
 
     }
 
-    return output_patch_cursor - destination_offset;
+    destination.patch_count = output_patch_cursor;
 }

package/engine/graphics/micron/render/v1/MaterialContext.js

@@ -144,8 +144,9 @@ export class MaterialContext {
 
     /**
      *
+     * @param {VirtualGeometry} virtual_geometry
      */
-    build() {
+    build(virtual_geometry) {
 
         if (this.__patch_count === 0) {
             this.mesh.visible = false;
@@ -154,7 +155,7 @@ export class MaterialContext {
             this.mesh.visible = true;
         }
 
-        this.adapter.build(this.__patches, this.__patch_count);
+        this.adapter.build(this.__patches, this.__patch_count, virtual_geometry);
 
     }
 }