@woosh/meep-engine 2.35.13 → 2.35.16

package/core/collection/array/typed/uint_array_for_count.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} count
+ * @returns {function}
+ */
+export function UintArrayForCount(count) {
+
+    if (count <= 256) {
+        return Uint8Array;
+    } else if (count <= 65536) {
+        return Uint16Array;
+    } else if (count <= 4294967295) {
+        return Uint32Array;
+    } else {
+        throw new Error(`Unsupported size ${count}`)
+    }
+}

package/core/geom/3d/ray/ray3_array_apply_matrix4.js

@@ -0,0 +1,42 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number[]|ArrayLike<number>|Float32Array} input 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number[]|ArrayLike<number>|Float32Array} m4 4x4 matrix
+ */
+export function ray3_array_apply_matrix4(output, input, m4) {
+    const origin_x = input[0];
+    const origin_y = input[1];
+    const origin_z = input[2];
+
+    const direction_x = input[3];
+    const direction_y = input[4];
+    const direction_z = input[5];
+
+    // transform ray to local space (inlined for speed)
+    const inv_w = 1 / (m4[3] * origin_x + m4[7] * origin_y + m4[11] * origin_z + m4[15]);
+
+    const out_origin_x = (m4[0] * origin_x + m4[4] * origin_y + m4[8] * origin_z + m4[12]) * inv_w;
+    const out_origin_y = (m4[1] * origin_x + m4[5] * origin_y + m4[9] * origin_z + m4[13]) * inv_w;
+    const out_origin_z = (m4[2] * origin_x + m4[6] * origin_y + m4[10] * origin_z + m4[14]) * inv_w;
+
+    const out_direction_x = m4[0] * direction_x + m4[4] * direction_y + m4[8] * direction_z;
+    const out_direction_y = m4[1] * direction_x + m4[5] * direction_y + m4[9] * direction_z;
+    const out_direction_z = m4[2] * direction_x + m4[6] * direction_y + m4[10] * direction_z;
+
+    // normalize direction
+    const out_direction_magnitude = Math.hypot(out_direction_x, out_direction_y, out_direction_z);
+    const out_direction_magnitude_inverse = 1 / out_direction_magnitude;
+
+    const out_direction_normalized_x = out_direction_x * out_direction_magnitude_inverse;
+    const out_direction_normalized_y = out_direction_y * out_direction_magnitude_inverse;
+    const out_direction_normalized_z = out_direction_z * out_direction_magnitude_inverse;
+
+    output[0] = out_origin_x;
+    output[1] = out_origin_y;
+    output[2] = out_origin_z;
+
+    output[3] = out_direction_normalized_x;
+    output[4] = out_direction_normalized_y;
+    output[5] = out_direction_normalized_z;
+}

package/core/geom/3d/ray/ray3_array_compose.js

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ */
+export function ray3_array_compose(output, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z) {
+    output[0] = origin_x;
+    output[1] = origin_y;
+    output[2] = origin_z;
+
+    output[3] = direction_x;
+    output[4] = direction_y;
+    output[5] = direction_z;
+}

package/core/geom/3d/ray/ray3_array_compose.spec.js

@@ -0,0 +1,14 @@
+import { ray3_array_compose } from "./ray3_array_compose.js";
+
+test('correctness', () => {
+    const result = [];
+    ray3_array_compose(result, 1, -3, 7, -11, 13, -17);
+
+    expect(result[0]).toBe(1);
+    expect(result[1]).toBe(-3);
+    expect(result[2]).toBe(7);
+
+    expect(result[3]).toBe(-11);
+    expect(result[4]).toBe(13);
+    expect(result[5]).toBe(-17);
+});

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

@@ -10,6 +10,8 @@ import { aabb3_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_intersec
 import { ShadedGeometryRendererContext } from "./render/ShadedGeometryRendererContext.js";
 import { BinaryNode } from "../../../../core/bvh2/BinaryNode.js";
 import { assert } from "../../../../core/assert.js";
+import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
+import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
 
 /**
  *
@@ -35,6 +37,9 @@ const scratch_point = new SurfacePoint3();
  */
 const scratch_m4 = new Float32Array(16);
 
+const scratch_ray_0 = new Float32Array(6);
+const scratch_ray_1 = new Float32Array(6);
+
 export class ShadedGeometrySystem extends System {
     /**
      *
@@ -332,29 +337,19 @@ export class ShadedGeometrySystem extends System {
                 // get transform in local space
                 mat4.invert(scratch_m4, m4);
 
-                // transform ray to local space
-                const inv_w = 1 / (scratch_m4[3] * origin_x + scratch_m4[7] * origin_y + scratch_m4[11] * origin_z + scratch_m4[15]);
-
-                const local_origin_x = (scratch_m4[0] * origin_x + scratch_m4[4] * origin_y + scratch_m4[8] * origin_z + scratch_m4[12]) * inv_w;
-                const local_origin_y = (scratch_m4[1] * origin_x + scratch_m4[5] * origin_y + scratch_m4[9] * origin_z + scratch_m4[13]) * inv_w;
-                const local_origin_z = (scratch_m4[2] * origin_x + scratch_m4[6] * origin_y + scratch_m4[10] * origin_z + scratch_m4[14]) * inv_w;
-
-                const local_direction_x = scratch_m4[0] * direction_x + scratch_m4[4] * direction_y + scratch_m4[8] * direction_z;
-                const local_direction_y = scratch_m4[1] * direction_x + scratch_m4[5] * direction_y + scratch_m4[9] * direction_z;
-                const local_direction_z = scratch_m4[2] * direction_x + scratch_m4[6] * direction_y + scratch_m4[10] * direction_z;
-
-                const local_direction_magnitude = Math.hypot(local_direction_x, local_direction_y, local_direction_z);
-                const local_direction_magnitude_inverse = 1 / local_direction_magnitude;
+                ray3_array_compose(
+                    scratch_ray_0,
+                    origin_x, origin_y, origin_z,
+                    direction_x, direction_y, direction_z
+                );
 
-                const local_direction_normalized_x = local_direction_x * local_direction_magnitude_inverse;
-                const local_direction_normalized_y = local_direction_y * local_direction_magnitude_inverse;
-                const local_direction_normalized_z = local_direction_z * local_direction_magnitude_inverse;
+                // transform ray to local space
+                ray3_array_apply_matrix4(scratch_ray_0, scratch_ray_0, scratch_m4);
 
-                const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_primitive(
+                const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_array(
                     scratch_point,
                     sg.geometry,
-                    local_origin_x, local_origin_y, local_origin_z,
-                    local_direction_normalized_x, local_direction_normalized_y, local_direction_normalized_z
+                    scratch_ray_0
                 );
 
                 if (!geometry_hit_found) {
@@ -373,13 +368,12 @@ export class ShadedGeometrySystem extends System {
                     origin_x, origin_y, origin_z
                 );
 
-                if (distance_sqr >= best_distance) {
-                    // further than best found
-                    continue;
+                if (distance_sqr < best_distance) {
+                    contact.copy(scratch_point);
+                    best_result = sg;
+                    best_distance = distance_sqr;
                 }
 
-                contact.copy(scratch_point);
-                best_result = sg;
             }
         }
 

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

@@ -0,0 +1,212 @@
+import { EngineHarness } from "../../../../EngineHarness.js";
+import { ShadedGeometrySystem } from "../ShadedGeometrySystem.js";
+import EntityBuilder from "../../../../ecs/EntityBuilder.js";
+import { Transform } from "../../../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "../ShadedGeometry.js";
+import {
+    BoxBufferGeometry,
+    MeshBasicMaterial,
+    MeshStandardMaterial,
+    OctahedronGeometry,
+    SphereBufferGeometry
+} from "three";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
+import ViewportPosition from "../../../../ecs/gui/position/ViewportPosition.js";
+import GUIElement from "../../../../ecs/gui/GUIElement.js";
+import ButtonView from "../../../../../view/elements/button/ButtonView.js";
+import { downloadAsFile } from "../../../../../core/binary/ByteArrayTools.js";
+import { convert_bvh_to_dot_format_string } from "../../../../../core/bvh2/visual/convert_bvh_to_dot_format_string.js";
+import ViewportPositionSystem from "../../../../ecs/gui/position/ViewportPositionSystem.js";
+import GUIElementSystem from "../../../../ecs/gui/GUIElementSystem.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import Quaternion from "../../../../../core/geom/Quaternion.js";
+import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
+import { randomFromArray } from "../../../../../core/math/random/randomFromArray.js";
+import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
+import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/OrbitingBehavior.js";
+import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { MicronShadedGeometryRenderAdapter } from "../../../micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js";
+import { MicronRenderContext } from "../../../micron/render/v1/MicronRenderContext.js";
+import { randomIntegerBetween } from "../../../../../core/math/random/randomIntegerBetween.js";
+import Vector2 from "../../../../../core/geom/Vector2.js";
+import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
+
+const eh = new EngineHarness();
+
+const DRAW_METHOD_PLAIN = 0;
+const DRAW_METHOD_INSTANCED = 1;
+
+function makeMovingShadedGeometry() {
+    const b = new OrbitingBehavior();
+    b.offset.set(4, 1, 4);
+    b.radius = 2;
+    b.rate = 1;
+
+    const sg = ShadedGeometry.from(new OctahedronGeometry(0.5, 5), new MeshStandardMaterial({ color: 0xFF0000 }));
+
+    sg.draw_method = DRAW_METHOD_INSTANCED;
+
+    return new EntityBuilder()
+        .add(new Transform())
+        .add(sg)
+        .add(BehaviorComponent.fromOne(b));
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+
+    const em = engine.entityManager;
+
+    const sgs = new ShadedGeometrySystem(engine);
+
+    const mrc = new MicronRenderContext();
+    sgs.register_render_adapter(2, () => {
+        const adapter = new MicronShadedGeometryRenderAdapter();
+        adapter.ctx = mrc;
+
+        return adapter;
+    });
+
+    await em.addSystem(sgs);
+    await em.addSystem(new BehaviorSystem(engine));
+
+    EngineHarness.buildBasics({
+        engine,
+        yaw: -0.8,
+        pitch: 1,
+        distance: 46,
+        focus: new Vector3(10, 0, 10)
+    });
+
+
+    const ecd = em.dataset;
+
+    const material = new MeshStandardMaterial({
+        color: 0xFFFFFF,
+        transparent: true,
+        opacity: 0.5
+    });
+
+    // material.visible = false;
+
+    window.material = material;
+
+    const random = seededRandom(0);
+
+    const INSTANCE_COUNT = 100;
+
+    const geometries = [];
+
+    for (let i = 0; i < 1; i++) {
+        geometries.push(new BoxBufferGeometry());
+    }
+
+    for (let i = 0; i < INSTANCE_COUNT; i++) {
+        const geometry = randomFromArray(random, geometries);
+        const sg = ShadedGeometry.from(geometry, material);
+
+        // sg.draw_method = DRAW_METHOD_PLAIN;
+        // sg.draw_method = DRAW_METHOD_INSTANCED;
+        // sg.draw_method = 2;
+        sg.draw_method = randomIntegerBetween(random, 0, 2);
+        // sg.draw_method = random() > 0.01 ? DRAW_METHOD_INSTANCED : DRAW_METHOD_PLAIN;
+        sg.clearFlag(ShadedGeometryFlags.CastShadow | ShadedGeometryFlags.ReceiveShadow);
+
+        new EntityBuilder()
+            .add(Transform.fromJSON({
+                position: {
+                    x: randomFloatBetween(random, 0, 20),
+                    y: randomFloatBetween(random, 0, 10),
+                    z: randomFloatBetween(random, 0, 20)
+                },
+                rotation: Quaternion.random(random),
+                scale: 1
+            }))
+            .add(sg)
+            .build(ecd);
+    }
+
+    // makeMovingShadedGeometry().build(ecd);
+
+    debug_button(engine, () => {
+        const dot = convert_bvh_to_dot_format_string(engine.graphics.layers.getLayerByName('shaded-geometry').bvh);
+        downloadAsFile(dot, 'bvh.dot', 'text');
+
+    }, 'save dot file');
+
+    const raycast_marker = new EntityBuilder()
+        .add(ShadedGeometry.from(new SphereBufferGeometry(1), new MeshBasicMaterial({
+            color: 0xFF0000
+        })))
+        .add(Transform.fromJSON({
+            scale: 0.07
+        }));
+
+    raycast_marker.build(engine.entityManager.dataset);
+
+    engine.devices.pointer.position.onChanged.add((p_x, p_y) => {
+        const p = new Vector2(p_x, p_y);
+        const ndc = new Vector2();
+        const ray_origin = new Vector3();
+        const ray_direction = new Vector3();
+
+        engine.graphics.normalizeViewportPoint(p, ndc);
+        engine.graphics.viewportProjectionRay(ndc.x, ndc.y, ray_origin, ray_direction);
+
+        /**
+         *
+         * @type {ShadedGeometrySystem}
+         */
+        const sgm = engine.entityManager.getSystem(ShadedGeometrySystem);
+
+        const sp = new SurfacePoint3();
+
+        sgm.raycastNearest(sp, ray_origin.x, ray_origin.y, ray_origin.z, ray_direction.x, ray_direction.y, ray_direction.z, ((entity, mesh) => {
+            return (entity !== raycast_marker.entity);
+        }));
+
+        const t = raycast_marker.getComponent(Transform);
+
+        t.position.copy(sp.position);
+    });
+}
+
+
+const entityManager = engine.entityManager;
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {function} action
+ * @param {string} [name]
+ * @param {EntityComponentDataset} ecd
+ */
+function debug_button(engine, action, name = "Button", ecd = entityManager.dataset) {
+    if (entityManager.getSystem(ViewportPositionSystem) === null) {
+        entityManager.addSystem(new ViewportPositionSystem(engine.graphics.viewport.size));
+    }
+
+    if (entityManager.getSystem(GUIElementSystem) === null) {
+        entityManager.addSystem(new GUIElementSystem(engine.gui.view, engine));
+    }
+
+    new EntityBuilder()
+        .add(ViewportPosition.fromJSON({}))
+        .add(GUIElement.fromView(new ButtonView({
+            action,
+            name,
+            css: {
+                background: 'rgba(255,255,255,0.8)',
+                border: '1px solid black',
+                borderRadius: '4px',
+                padding: '2px',
+            }
+        })))
+        .build(ecd);
+}
+
+eh.initialize().then(main);

package/engine/graphics/ecs/path/tube/build/TubePathBuilder.js

@@ -124,7 +124,6 @@ export class TubePathBuilder {
         }
 
         material_def.color.set(style.color.toUint());
-        material_def.wireframe = true;
 
         if (style.opacity < 1) {
             material_def.transparent = true;

package/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -56,6 +56,22 @@ export class GeometrySpatialQueryAccelerator {
         return this.__visitor_clip.getContainment();
     }
 
+    /**
+     *
+     * @param {SurfacePoint3} destination
+     * @param {THREE.BufferGeometry} geometry
+     * @param {number[]|ArrayLike<number>|Float32Array} ray 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+     * @return {boolean}
+     */
+    queryRaycastNearest_array(destination, geometry, ray) {
+        return this.queryRaycastNearest_primitive(
+            destination,
+            geometry,
+            ray[0], ray[1], ray[2],
+            ray[3], ray[4], ray[5]
+        );
+    }
+
     /**
      *
      * @param {SurfacePoint3} destination

package/engine/graphics/micron/build/fill_patch_geometry_data.js

@@ -1,10 +1,3 @@
-/**
- *
- * @param {number} count
- * @returns {Function}
- * @constructor
- */
-
 import { DataType } from "../../../../core/collection/table/DataType.js";
 import { passThrough } from "../../../../core/function/Functions.js";
 import { to_half_float_uint16 } from "../../../../core/binary/to_half_float_uint16.js";
@@ -12,17 +5,7 @@ import { compute_micron_buffer_array_constructor } from "./compute_micron_buffer
 import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
 import { dataTypeByteSize } from "../../../../core/collection/table/DataTypeByteSizes.js";
 import { clamp } from "../../../../core/math/clamp.js";
-
-function UintArrayForCount(count) {
-
-    if (count <= 256) {
-        return Uint8Array;
-    } else if (count <= 65536) {
-        return Uint16Array;
-    } else {
-        throw new Error(`Unsupported size ${count}`)
-    }
-}
+import { UintArrayForCount } from "../../../../core/collection/array/typed/uint_array_for_count.js";
 
 /**
  * @param {number} vertex_count

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

@@ -5,6 +5,7 @@ import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { aabb3_array_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_array_intersects_ray.js";
 import { sphere_array_intersects_ray } from "../../../../core/geom/3d/sphere/sphere_array_intersects_ray.js";
 import { BitSet } from "../../../../core/binary/BitSet.js";
+import { micron_build_proxy_geometry } from "./micron_build_proxy_geometry.js";
 
 let id_counter = 0;
 
@@ -286,11 +287,13 @@ export class MicronGeometry {
 
     /**
      * Build geometry proxy from the patches
-     * @param {number} fraction percentage of the original geometry to keep
-     * @param {number} min minimum number of triangles to keep, this will be respected first before percentage value
+     * @param {number} [fraction] percentage of the original geometry to keep
+     * @param {number} [min] minimum number of triangles to keep, this will be respected first before percentage value
      */
-    buildProxy(fraction, min) {
-        throw new Error('Not Implemented');
+    buildProxy(fraction = 0.05, min = 2048) {
+        const bufferGeometry = micron_build_proxy_geometry(this, fraction, min);
+
+        this.__proxy = bufferGeometry;
     }
 
     computeByteSize() {

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

@@ -0,0 +1,203 @@
+//
+
+import BinaryHeap from "../../../navigation/grid/FastBinaryHeap.js";
+import { BufferAttribute, BufferGeometry } from "three";
+import { UintArrayForCount } from "../../../../core/collection/array/typed/uint_array_for_count.js";
+import { compute_typed_array_constructor_from_data_type } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { BitSet } from "../../../../core/binary/BitSet.js";
+import { min2 } from "../../../../core/math/min2.js";
+import { max2 } from "../../../../core/math/max2.js";
+
+/**
+ *
+ * @param {MicronGeometry} micron_geometry
+ * @param {number} fraction
+ * @param {number} min_face_count
+ * @returns {MicronGeometryPatch[]}
+ */
+function collect_patches(micron_geometry, fraction, min_face_count) {
+    /**
+     *
+     * @type {BinaryHeap<MicronGeometryPatch>}
+     */
+    const heap = new BinaryHeap(patch => {
+        // LOD is a good proxy for how much detail there is in a patch
+        return -patch.lod;
+    });
+
+    let closed_set = new BitSet();
+
+    let current_polycount = 0;
+
+    /**
+     *
+     * @param {MicronGeometryPatch} patch
+     */
+    function add(patch) {
+
+        closed_set.set(patch.id, true);
+
+        heap.push(patch);
+
+        current_polycount += patch.polygon_count;
+    }
+
+    /**
+     *
+     * @param {MicronGeometryPatch} patch
+     */
+    function refine(patch) {
+        const children = patch.children;
+        const child_count = children.length;
+
+
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            if (closed_set.get(child.id)) {
+                // already refined
+                continue;
+            }
+
+            add(child);
+
+            const parents = child.parents;
+
+            const parent_count = parents.length;
+            for (let j = 0; j < parent_count; j++) {
+                const parent = parents[j];
+
+                if (parent === parent) {
+                    continue;
+                }
+
+                // remove and refine other patches in the same group
+                if (heap.delete(parent)) {
+                    refine(parent);
+                }
+            }
+        }
+    }
+
+    add(micron_geometry.root);
+
+    const target_polycount_threshold = max2(
+        micron_geometry.source_triangle_count * fraction,
+        min2(
+            min_face_count,
+            micron_geometry.source_triangle_count
+        )
+    );
+
+    while (current_polycount < target_polycount_threshold) {
+        const p = heap.peek();
+
+        if (p === undefined || p.lod === 0) {
+            // no refinement possible
+            break;
+        }
+
+        heap.pop();
+
+        current_polycount -= p.polygon_count;
+
+        refine(p);
+    }
+
+    const result = [];
+
+    // collect
+    while (!heap.isEmpty()) {
+        result.push(heap.pop());
+    }
+
+    return result;
+}
+
+/**
+ *
+ * @param {MicronGeometryPatch[]} patches
+ * @param {VertexDataSpec} vertex_spec
+ * @returns {THREE.BufferGeometry}
+ */
+function assemble_patches_to_geometry(patches, vertex_spec) {
+    const geo = new BufferGeometry();
+
+    //compute total number of vertices and faces
+    let total_faces = 0;
+    let total_vertices = 0;
+
+    for (let i = 0; i < patches.length; i++) {
+        const patch = patches[i];
+
+        total_faces += patch.polygon_count;
+        total_vertices += patch.vertex_count;
+    }
+
+    const index_data = new (UintArrayForCount(total_vertices))(total_faces * 3);
+
+    geo.setIndex(new BufferAttribute(index_data, 1, false));
+
+    const attribute_arrays = [];
+
+    const attribute_specs = vertex_spec.attributes;
+    const attribute_count = attribute_specs.length;
+    for (let i = 0; i < attribute_count; i++) {
+        const attribute = attribute_specs[i];
+
+        const TA = compute_typed_array_constructor_from_data_type(attribute.type);
+
+        const attribute_data = new TA(total_vertices * 3);
+
+        attribute_arrays[i] = attribute_data;
+
+        geo.setAttribute(attribute.name, new BufferAttribute(attribute_data, attribute.itemSize, attribute.normalized));
+    }
+
+    let index_cursor = 0;
+    let vertex_cursor = 0;
+
+    // add patches to resulting geometry
+    for (let i = 0; i < patches.length; i++) {
+        const patch = patches[i];
+
+        const local_index_size = patch.polygon_count * 3;
+
+        // copy transformed indices
+        for (let j = 0; j < local_index_size; j++) {
+            const local_index = patch.face_indices[j];
+
+            index_data[index_cursor + j] = local_index + vertex_cursor;
+        }
+
+        // copy vertex data
+
+        for (let j = 0; j < attribute_count; j++) {
+            const attribute_destination = attribute_arrays[j];
+
+            const attribute_source = patch.vertex_attribute_arrays[j];
+            const destination_offset = vertex_cursor * attribute_specs[j].itemSize;
+
+            attribute_destination.set(attribute_source, destination_offset);
+        }
+
+        vertex_cursor += patch.vertex_count;
+        index_cursor += local_index_size;
+    }
+
+    return geo;
+}
+
+
+/**
+ *
+ * @param {MicronGeometry} micron_geometry
+ * @param {number} fraction
+ * @param {number} [min_face_count]
+ * @returns {THREE.BufferGeometry}
+ */
+export function micron_build_proxy_geometry(micron_geometry, fraction, min_face_count = 128) {
+    const patches = collect_patches(micron_geometry, fraction, min_face_count);
+
+    return assemble_patches_to_geometry(patches, micron_geometry.vertex_spec);
+}

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

@@ -35,6 +35,25 @@ function max_polycount(object) {
     return r;
 }
 
+/**
+ *
+ * @param {THREE.Object3D} object
+ */
+function ensureProxy(object) {
+    if (object.isMicronMesh) {
+
+        /**
+         * @type {MicronGeometry}
+         */
+        const micron_geo = object.geometry;
+
+        if (micron_geo.proxy === null) {
+            // proxy geometry doesn't exist, build one
+            micron_geo.buildProxy();
+        }
+    }
+}
+
 export class GLTFAssetTransformer extends AssetTransformer {
     /**
      *
@@ -171,6 +190,8 @@ export class GLTFAssetTransformer extends AssetTransformer {
 
         source.override_mesh = micron_root;
 
+        traverseThreeObject(micron_root, ensureProxy);
+
         return source;
     }
 }

package/engine/graphics/micron/prototypeMicronProxyBuild.js

@@ -0,0 +1,227 @@
+import { PLYLoader } from "three/examples/jsm/loaders/PLYLoader.js";
+import {
+    AmbientLight,
+    CubeTextureLoader,
+    DirectionalLight,
+    FrontSide,
+    Mesh,
+    MeshBasicMaterial,
+    MeshStandardMaterial,
+    PerspectiveCamera,
+    PointLight,
+    RepeatWrapping,
+    Scene,
+    SphereGeometry,
+    sRGBEncoding,
+    TextureLoader,
+    VSMShadowMap,
+    WebGLRenderer
+} from "three";
+import Stats from "three/examples/jsm/libs/stats.module.js";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
+
+const background = new TextureLoader().load('data/textures/utility/checkers_white_grey_256x256.png');
+background.repeat.set(50, 30);
+background.wrapS = RepeatWrapping;
+background.wrapT = RepeatWrapping;
+
+let container, stats;
+
+let camera, scene, renderer;
+let directionalLight;
+let pointLight;
+
+let windowHalfX = window.innerWidth / 2;
+let windowHalfY = window.innerHeight / 2;
+
+
+function init() {
+
+    container = document.createElement("div");
+    document.body.appendChild(container);
+
+    camera = new PerspectiveCamera(45, window.innerWidth / window.innerHeight, 1, 1000000);
+    camera.position.z = -4000;
+
+    //
+
+
+    scene = new Scene();
+
+    window.scene = scene;
+
+    // LIGHTS
+
+    const ambient = new AmbientLight(0xffffff, 0.1);
+    scene.add(ambient);
+
+    pointLight = new PointLight(0x6666ff, 0.5);
+    pointLight.position.y = 1000;
+    scene.add(pointLight);
+
+    // light representation
+
+    const sphere = new SphereGeometry(100, 16, 8);
+
+    const mesh = new Mesh(sphere, new MeshBasicMaterial({ color: 0xffffff }));
+    mesh.scale.set(0.5, 0.5, 0.5);
+    pointLight.add(mesh);
+
+    // add directional light
+    directionalLight = new DirectionalLight(0xFFAAAA, 0.8);
+    directionalLight.position.set(-500, 1000, 300);
+    directionalLight.castShadow = true;
+    const shadow_camera = directionalLight.shadow.camera;
+    // small bias to prevent shadow acne
+    directionalLight.shadow.bias = -0.0001;
+    // directionalLight.shadow.mapSize.set(4096, 4096);
+    directionalLight.shadow.mapSize.set(1024, 1024);
+    directionalLight.shadow.autoUpdate = false;
+
+    window.light = directionalLight;
+    // directionalLight.shadow.autoUpdate = true;
+
+    shadow_camera.near = 0.1;
+    shadow_camera.far = 2000;
+
+    const shadow_camera_size = 15;
+
+    shadow_camera.left = -shadow_camera_size / 2;
+    shadow_camera.right = shadow_camera_size / 2;
+
+    shadow_camera.bottom = -shadow_camera_size / 2;
+    shadow_camera.top = shadow_camera_size / 2;
+
+    shadow_camera.updateProjectionMatrix();
+
+
+    scene.add(directionalLight);
+    // material samples
+
+    const cubeMaterial1 = new MeshStandardMaterial({
+        wireframe: false,
+        side: FrontSide,
+        color: 0xffffff
+    });
+
+    //
+
+    renderer = new WebGLRenderer({
+        antialias: true,
+        preserveDrawingBuffer: true,
+        stencil: false
+    });
+
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = VSMShadowMap;
+    // renderer.shadowMap.type = BasicShadowMap;
+    renderer.sortObjects = false;
+
+    renderer.setPixelRatio(window.devicePixelRatio);
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    container.appendChild(renderer.domElement);
+
+    stats = new Stats();
+    container.appendChild(stats.dom);
+
+
+    window.addEventListener("resize", onWindowResize);
+
+// envmap
+    const genCubeUrls = function (prefix, postfix) {
+
+        return [
+            prefix + "posx" + postfix, prefix + "negx" + postfix,
+            prefix + "posy" + postfix, prefix + "negy" + postfix,
+            prefix + "posz" + postfix, prefix + "negz" + postfix
+        ];
+
+    };
+
+    const urls = genCubeUrls("data/textures/cubemaps/hip_miramar/32/", ".png");
+
+    new CubeTextureLoader().load(urls, function (cubeTexture) {
+
+        cubeTexture.encoding = sRGBEncoding;
+
+        // scene.background = new Color(0.1, 0.1, 0.1);
+        // scene.background = new ThreeColor(1, 0.3, 0.3);
+        // scene.background = new Color(0.3, 1, 0.3);
+
+        scene.background = background;
+        scene.environment = cubeTexture;
+
+
+        // const lightProbe = new LightProbe();
+        //
+        // lightProbe.copy(LightProbeGenerator.fromCubeTexture(cubeTexture));
+        // lightProbe.intensity = 1.2;
+
+        // scene.add(lightProbe);
+    });
+
+    onWindowResize();
+
+    new PLYLoader().load("data/models/stanford/Lucy100k.ply", async geometry => {
+        geometry.computeVertexNormals();
+
+        const source = new Mesh(geometry, new MeshStandardMaterial({ color: 0xFFFFFF }));
+
+        const micron_g = await buildMicronGeometryFromBufferGeometry(geometry);
+
+        micron_g.buildProxy();
+
+        const proxy = new Mesh(micron_g.proxy, new MeshStandardMaterial({ color: 0xFF0000 }));
+
+        source.position.x += 700;
+        proxy.position.x -= 700;
+
+        console.warn(geometry, micron_g);
+
+        scene.add(source);
+        scene.add(proxy);
+    })
+}
+
+function onWindowResize() {
+
+    const w = window.innerWidth;
+    const h = window.innerHeight;
+
+    windowHalfX = w / 2;
+    windowHalfY = h / 2;
+
+    camera.aspect = w / h;
+    camera.updateProjectionMatrix();
+
+    renderer.setSize(w, h);
+
+    background.repeat.set(w / 20, h / 20);
+}
+
+function animate() {
+
+    requestAnimationFrame(animate);
+
+    render();
+    stats.update();
+
+}
+
+function render() {
+    if (orbitControls !== undefined) {
+        orbitControls.update();
+    }
+
+    const timer = -0.0002 * Date.now();
+
+    pointLight.position.x = 10000 * Math.cos(timer);
+    pointLight.position.z = 10000 * Math.sin(timer);
+
+    renderer.render(scene, camera);
+}
+
+init();
+const orbitControls = new OrbitControls(camera, container);
+animate();

package/engine/graphics/util/composeMatrix4RotationScale.js

@@ -1,3 +1,6 @@
+import { compose_matrix4_array } from "./composeMatrix4.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+
 /**
  *
  * @param {Matrix4} result
@@ -7,31 +10,5 @@
 export function composeMatrix4RotationScale(result, rotation, scale) {
     const te = result.elements;
 
-    const x = rotation.x, y = rotation.y, z = rotation.z, w = rotation.w;
-    const x2 = x + x, y2 = y + y, z2 = z + z;
-    const xx = x * x2, xy = x * y2, xz = x * z2;
-    const yy = y * y2, yz = y * z2, zz = z * z2;
-    const wx = w * x2, wy = w * y2, wz = w * z2;
-
-    const sx = scale.x, sy = scale.y, sz = scale.z;
-
-    te[0] = (1 - (yy + zz)) * sx;
-    te[1] = (xy + wz) * sx;
-    te[2] = (xz - wy) * sx;
-    te[3] = 0;
-
-    te[4] = (xy - wz) * sy;
-    te[5] = (1 - (xx + zz)) * sy;
-    te[6] = (yz + wx) * sy;
-    te[7] = 0;
-
-    te[8] = (xz + wy) * sz;
-    te[9] = (yz - wx) * sz;
-    te[10] = (1 - (xx + yy)) * sz;
-    te[11] = 0;
-
-    te[12] = 0;
-    te[13] = 0;
-    te[14] = 0;
-    te[15] = 1;
+    compose_matrix4_array(te, Vector3.zero, rotation, scale);
 }

package/engine/navigation/grid/FastBinaryHeap.js

@@ -6,12 +6,15 @@ import { assert } from "../../../core/assert.js";
  */
 class BinaryHeap {
     /**
-     * @template T
-     * @param {function(T):number} scoreFunction
+     * @param {(T)=>number} scoreFunction
      * @constructor
      */
     constructor(scoreFunction) {
 
+        /**
+         *
+         * @type {function(T): number}
+         */
         this.scoreFunction = scoreFunction;
 
         /**
@@ -165,6 +168,14 @@ class BinaryHeap {
         }
     }
 
+    /**
+     *
+     * @returns {T|undefined}
+     */
+    peek() {
+        return this.data[0];
+    }
+
     /**
      *
      * @param {T} node

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