@woosh/meep-engine 2.43.6 → 2.43.8

package/core/geom/3d/SurfacePoint3.js

@@ -8,6 +8,13 @@ export class SurfacePoint3 {
     constructor() {
         this.normal = new Vector3(0, 1, 0);
         this.position = new Vector3(0, 0, 0);
+
+        /**
+         * Primitive index, such as triangle/point/line from the source geometry
+         * optional
+         * @type {number}
+         */
+        this.index = -1;
     }
 
     /**
@@ -70,6 +77,7 @@ export class SurfacePoint3 {
     copy(other) {
         this.position.copy(other.position);
         this.normal.copy(other.normal);
+        this.index = other.index;
     }
 
     /**

package/core/geom/3d/aabb/compute_aabb_from_points.js

@@ -19,7 +19,7 @@ export function compute_aabb_from_points(result, input, input_count, d) {
 
     for (i = 0; i < input_count; i++) {
         for (j = 0; j < d; j++) {
-            const v = input[j];
+            const v = input[i*d + j];
 
             result[j] = min2(result[j], v);
             result[j + d] = max2(result[j + d], v);

package/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -71,8 +71,8 @@ function Kml(m, l) {
 
 /**
  * compute Index of spherical harmonics coefficient
- * @param {number} m
- * @param {number} l
+ * @param {number} m signed offset from zonal harmonic
+ * @param {number} l band
  * @return {number}
  */
 function SHindex(m, l) {
@@ -239,7 +239,7 @@ function rotateShericalHarmonicBand1(band1, M) {
     mat3.scale(invA1TimesK, invA1TimesK, band1);
 
 
-    mat3.multiply(R1OverK, R1OverK, invA1TimesK );
+    mat3.multiply(R1OverK, R1OverK, invA1TimesK);
 
     return R1OverK;
 }
@@ -568,6 +568,7 @@ function windowSH(output, output_offset, input, input_offset, numBands, channel_
         for (let channel = 0; channel < channel_count; channel++) {
 
             for (let i = 0; i < numBands * numBands; i++) {
+                // copy this channel
                 SH[i] = output[output_offset + i * channel_count + channel];
             }
 
@@ -583,19 +584,24 @@ function windowSH(output, output_offset, input, input_offset, numBands, channel_
                 }
             }
 
+            // record minimum cutoff
             cutoff = min2(cutoff, l);
         }
     }
 
     array_copy(input, input_offset, output, output_offset, numBands * numBands * channel_count);
 
+
     for (let l = 0; l < numBands; l++) {
+        // scale each band individually
         let w = sincWindow(l, cutoff);
 
+        // write zonal harmonic
         for (let i = 0; i < channel_count; i++) {
-            output[output_offset + SHindex(0, l) * channel_count + i] = w;
+            output[output_offset + SHindex(0, l) * channel_count + i] *= w;
         }
 
+        // write the rest of the band
         for (let m = 1; m <= l; m++) {
             for (let i = 0; i < channel_count; i++) {
                 output[output_offset + SHindex(-m, l) * channel_count + i] *= w;

package/core/geom/3d/topology/samples/sampleFloodFill.js

@@ -0,0 +1,275 @@
+import { EngineHarness } from "../../../../../engine/EngineHarness.js";
+import { MeshBasicMaterial, MeshStandardMaterial, OctahedronBufferGeometry } from "three";
+import EntityBuilder from "../../../../../engine/ecs/EntityBuilder.js";
+import { ShadedGeometry } from "../../../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { Transform } from "../../../../../engine/ecs/transform/Transform.js";
+import Vector3 from "../../../Vector3.js";
+import { ShadedGeometrySystem } from "../../../../../engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
+import { SurfacePoint3 } from "../../SurfacePoint3.js";
+import { topo_mesh_to_three_buffer_geometry } from "../topo_mesh_to_three_buffer_geometry.js";
+import { three_buffer_geometry_to_topo_mesh } from "../three_buffer_geometry_to_topo_mesh.js";
+import { mesh_flood_fill } from "../util/mesh_flood_fill.js";
+import { compute_aabb_from_points } from "../../aabb/compute_aabb_from_points.js";
+import { AABB3 } from "../../../../bvh2/aabb3/AABB3.js";
+import { mergeVertices } from "three/examples/jsm/utils/BufferGeometryUtils.js";
+import { makeGeometryIndexed } from "../../../../../engine/graphics/geometry/buffered/makeGeometryIndexed.js";
+import { v3_dot } from "../../../v3_dot.js";
+import { TopoMesh } from "../struct/TopoMesh.js";
+import { SGMeshSystem } from "../../../../../engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js";
+import { SGMesh } from "../../../../../engine/graphics/ecs/mesh-v2/aggregate/SGMesh.js";
+import { GameAssetType } from "../../../../../engine/asset/GameAssetType.js";
+import { GLTFAssetLoader } from "../../../../../engine/asset/loaders/GLTFAssetLoader.js";
+import { computeTriangleSurfaceArea } from "../../../../../engine/graphics/geometry/computeMeshSurfaceArea.js";
+import { SGMeshEvents } from "../../../../../engine/graphics/ecs/mesh-v2/aggregate/SGMeshEvents.js";
+import { Color } from "../../../../color/Color.js";
+import { seededRandom } from "../../../../math/random/seededRandom.js";
+import { expandConnectivityByLocality } from "../expandConnectivityByLocality.js";
+import { buildCubeURLs } from "../../../../../engine/graphics/texture/cubemap/buildCubeURLs.js";
+import { EntityNode } from "../../../../../engine/ecs/parent/EntityNode.js";
+import { TransformAttachmentSystem } from "../../../../../engine/ecs/transform-attachment/TransformAttachmentSystem.js";
+
+const harness = new EngineHarness();
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoTriangle[]} faces
+ * @param {EntityNode} entity
+ */
+function set_highlight({
+                           mesh,
+                           faces,
+                           entity
+                       }) {
+
+    entity.children.slice().forEach(e => {
+        entity.removeChild(e);
+
+        e.destroy();
+    });
+
+
+    const m = new TopoMesh();
+
+    const vertex_map = new Map();
+
+    faces.forEach(f => {
+        m.addFaceCopy(f, vertex_map);
+    });
+
+    const selected_geo = topo_mesh_to_three_buffer_geometry(m);
+
+    entity.addChild(EntityNode.fromComponents(
+        new Transform(),
+        ShadedGeometry.from(selected_geo, new MeshBasicMaterial({
+            transparent: true,
+            opacity: 0.7,
+            color: '#00c4ff',
+            depthTest: true
+        }))
+    ));
+
+    entity.addChild(EntityNode.fromComponents(
+        new Transform(),
+        ShadedGeometry.from(selected_geo,new MeshBasicMaterial({
+            wireframe: true,
+            transparent: true,
+            opacity: 0.7,
+            color: '#ffffff',
+            depthTest: false
+        }))
+    ))
+
+}
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+async function main(engine) {
+    await EngineHarness.buildBasics({
+        engine,
+        focus: { x: -10.283977088703375, y: 1.7301942199921359, z: -0.3232510720362 },
+        pitch: 0.2700000000000029,
+        distance: 17,
+        yaw: -Math.PI / 2,
+        cameraFarDistance: 100,
+        enableTerrain: false
+    });
+
+    engine.graphics.loadEnvironmentMap(buildCubeURLs('data/textures/cubemaps/hip_miramar/32/', '.png'));
+
+    const path = 'data/models/sponza-pbr/gltf/sponza.glb';
+
+    const ecd = engine.entityManager.dataset;
+
+    const entityBuilder = new EntityBuilder();
+    entityBuilder
+        .add(SGMesh.fromURL(path))
+        .add(Transform.fromJSON({}))
+        .build(ecd);
+
+    const random = seededRandom();
+
+    entityBuilder.addEventListener(SGMeshEvents.AssetLoaded, () => {
+        /**
+         *
+         * @type {EntityNode}
+         */
+        const node = entityBuilder.getComponent(SGMesh).__node;
+
+        node.traverse(n => {
+
+            const sg = n.entity.getComponent(ShadedGeometry);
+
+            if (sg === null) {
+                return;
+            }
+
+            n.entity.removeComponent(ShadedGeometry);
+
+            let hue =0;
+
+            do {
+                hue = random();
+
+            }while(Math.abs(hue -  0.53855555555) < 0.11); // shift away from hue of selection mask
+
+            sg.material = new MeshStandardMaterial({
+                color: Color.fromHSV(hue, 0.9, 0.9).toHex()
+            });
+
+            n.entity.add(sg);
+
+        });
+    });
+
+    // create a mesh
+    let source_geo = new OctahedronBufferGeometry(5, 3);
+
+    makeGeometryIndexed(source_geo);
+    source_geo = mergeVertices(source_geo, 0.002);
+
+    const entity_source = new EntityBuilder();
+    entity_source
+        .add(ShadedGeometry.from(source_geo, new MeshStandardMaterial({
+            color: '#b60000'
+        })))
+        .add(Transform.fromJSON({
+            position: {
+                x: 10, y: 6, z: 15
+            }
+        }))
+        .build(ecd);
+
+    const highlight = new EntityNode();
+    highlight.entity.add(new Transform());
+
+
+    engine.devices.pointer.on.tap.add(
+        /**
+         *
+         * @param {Vector2} position
+         * @param {MouseEvent|TouchEvent} event
+         */
+        (position, event) => {
+            if (event instanceof MouseEvent) {
+                if ((event.buttons & (1)) !== 0) {
+                    return;
+                }
+            }
+
+            /**
+             *
+             * @type {ShadedGeometrySystem}
+             */
+            const sgs = engine.entityManager.getSystem(ShadedGeometrySystem);
+
+            const contact = new SurfacePoint3();
+
+            const ray_origin = new Vector3();
+            const ray_direction = new Vector3();
+
+            engine.graphics.normalizeViewportPoint(position, position);
+            engine.graphics.viewportProjectionRay(position.x, position.y, ray_origin, ray_direction);
+
+            highlight.destroy();
+
+            const raycast_result = sgs.raycastNearest(contact, ray_origin.x, ray_origin.y, ray_origin.z, ray_direction.x, ray_direction.y, ray_direction.z);
+
+            if (raycast_result !== undefined) {
+                //got a hit
+
+                const sg = raycast_result.mesh;
+                makeGeometryIndexed(sg.geometry);
+                const geometry = mergeVertices(sg.geometry);
+                // console.warn(raycast_result, contact, geometry);
+
+
+                const topo = three_buffer_geometry_to_topo_mesh(geometry);
+
+                const aabb_array = [];
+                const position_attribute = geometry.getAttribute('position');
+                compute_aabb_from_points(aabb_array, position_attribute.array, position_attribute.count, 3);
+                const aabb3 = new AABB3(...aabb_array);
+                //
+                // weld_duplicate_vertices(topo, aabb3);
+                expandConnectivityByLocality(topo, aabb3);
+
+                // identify triangle that was clicked
+                const face = topo.getFaceByIndex(contact.index);
+
+                const selection = mesh_flood_fill({
+                    mesh: topo,
+                    initial_set: [face],
+                    filter(current, prev) {
+                        current.computeNormal();
+
+                        const area = computeTriangleSurfaceArea(
+                            current.vertices[0].x,
+                            current.vertices[0].z,
+                            current.vertices[0].y,
+
+                            current.vertices[1].x,
+                            current.vertices[1].z,
+                            current.vertices[1].y,
+
+                            current.vertices[2].x,
+                            current.vertices[2].z,
+                            current.vertices[2].y,
+                        );
+
+                        if (area < 0.0003) {
+                            // area very small, allow jumping across
+                            return true;
+                        }
+
+                        return v3_dot(current.normal[0], current.normal[1], current.normal[2], contact.normal.x, contact.normal.y, contact.normal.z) >= 0.8;
+                        // return true;
+                    }
+                });
+
+                // console.log(`selection: ${selection.length}`, selection);
+
+                highlight.transform.copy(ecd.getComponent(raycast_result.entity, Transform));
+                set_highlight({
+                    mesh: topo, faces: selection, entity: highlight
+                });
+
+                highlight.build(ecd);
+            }
+        });
+}
+
+harness.initialize({
+    configuration(config, engine) {
+        config.addSystem(new ShadedGeometrySystem(engine));
+        config.addSystem(new TransformAttachmentSystem());
+        config.addSystem(new SGMeshSystem(engine));
+
+        const loader = new GLTFAssetLoader();
+        config.addLoader(GameAssetType.ModelGLTF_JSON, loader)
+        config.addLoader(GameAssetType.ModelGLTF, loader)
+    }
+}).then(main);

package/core/geom/3d/topology/simplify/prototypeMeshSimplification.js

@@ -24,7 +24,7 @@ import { mergeVertices } from "three/examples/jsm/utils/BufferGeometryUtils.js";
 import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
 import Stats from "three/examples/jsm/libs/stats.module.js";
 import { PLYLoader } from "three/examples/jsm/loaders/PLYLoader.js";
-import { topoMeshToBufferGeometry } from "../topoMeshToBufferGeometry.js";
+import { topo_mesh_to_three_buffer_geometry } from "../topo_mesh_to_three_buffer_geometry.js";
 import { TopoMesh } from "../struct/TopoMesh.js";
 import {
     deinterleaveBufferGeometry
@@ -36,6 +36,7 @@ import { computeTopoMeshBoundiningBox } from "../bounds/computeTopoMeshBoundinin
 import { AABB3 } from "../../../../bvh2/aabb3/AABB3.js";
 import { Color } from "../../../../color/Color.js";
 import { clamp } from "../../../../math/clamp.js";
+import { three_buffer_geometry_to_topo_mesh } from "../three_buffer_geometry_to_topo_mesh.js";
 
 
 /**
@@ -290,15 +291,13 @@ function init() {
                                           label_steps = true
                                       }) {
 
-        const topology = new TopoMesh();
-        const faces_array = geo.getIndex().array;
-        topology.build(geo.getAttribute('position').array, faces_array);
+        const topology = three_buffer_geometry_to_topo_mesh(geo);
 
         for (let i = 0; i < steps; i++) {
             if (i === 11) debugger;
             simplifyTopoMesh2(topology, 1);
 
-            const simplified_bg = topoMeshToBufferGeometry(topology);
+            const simplified_bg = topo_mesh_to_three_buffer_geometry(topology);
             simplified_bg.computeVertexNormals();
 
             const proxy = build_preview_object({ geometry: simplified_bg, color: 'rgb(255,90,90)' });
@@ -372,7 +371,7 @@ function init() {
         console.timeEnd('simplification');
 
         console.time('topo -> buffer geo');
-        const simplified_bg = topoMeshToBufferGeometry(mesh);
+        const simplified_bg = topo_mesh_to_three_buffer_geometry(mesh);
         console.timeEnd('topo -> buffer geo');
 
         simplified_bg.computeVertexNormals();

package/core/geom/3d/topology/struct/TopoMesh.js

@@ -51,6 +51,23 @@ export class TopoMesh {
         return this.__faces;
     }
 
+    /**
+     *
+     * @param {number} index
+     * @return {undefined|TopoTriangle}
+     */
+    getFaceByIndex(index) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        for (const face of this.__faces) {
+            if (face.index === index) {
+                return face;
+            }
+        }
+
+        return undefined;
+    }
+
     /**
      *
      * @param {function(reason:string)} error_consumer

package/core/geom/3d/topology/three_buffer_geometry_to_topo_mesh.js

@@ -0,0 +1,30 @@
+import { TopoMesh } from "./struct/TopoMesh.js";
+
+/**
+ *
+ * @param {THREE.BufferGeometry} geo
+ * @return {TopoMesh}
+ */
+export function three_buffer_geometry_to_topo_mesh(geo) {
+    const topology = new TopoMesh();
+    let faces_array;
+
+
+    const position_attribute = geo.getAttribute('position');
+
+    const geo_index = geo.getIndex();
+
+    if (geo_index !== null) {
+        faces_array = geo_index.array;
+    } else {
+        faces_array = new Uint32Array(position_attribute.count );
+
+        for (let i = 0; i < faces_array.length; i++) {
+            faces_array[i] = i;
+        }
+    }
+
+    topology.build(position_attribute.array, faces_array);
+
+    return topology;
+}

package/core/geom/3d/topology/{topoMeshToBufferGeometry.js → topo_mesh_to_three_buffer_geometry.js}

@@ -5,7 +5,7 @@ import { BufferAttribute, BufferGeometry } from "three";
  * @param {TopoMesh} mesh
  * @returns {THREE.BufferGeometry}
  */
-export function topoMeshToBufferGeometry(mesh) {
+export function topo_mesh_to_three_buffer_geometry(mesh) {
     const vertices_lookup = new Map();
 
     // build vertices array

package/core/geom/3d/topology/util/mesh_flood_fill.js

@@ -0,0 +1,61 @@
+import { BitSet } from "../../../../binary/BitSet.js";
+
+/**
+ *
+ * @type {TopoTriangle[]}
+ */
+const neighbours = [];
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoTriangle[]} initial_set indices of triangles that make up initial set, these are triangles that we start from, they will also be included in the resulting set
+ * @param {function(tri:TopoTriangle, prev:TopoTriangle):boolean} filter decides whether a triangle should be included or not
+ * @returns {TopoTriangle[]} set of selected triangles, will include initial set as well
+ */
+export function mesh_flood_fill({
+                                    mesh,
+                                    initial_set,
+                                    filter
+                                }) {
+
+    const closed = new BitSet();
+    const open = [...initial_set];
+
+    const result_set = [];
+
+    while (open.length > 0) {
+        const current = open.pop();
+
+        closed.set(current.index, true);
+
+        result_set.push(current);
+
+        // get neighbours
+
+        const neighbour_count = current.getEdgeNeighbours(neighbours, 0);
+
+        for (let i = 0; i < neighbour_count; i++) {
+            const neighbour_face = neighbours[i];
+
+            if (closed.get(neighbour_face.index)) {
+                continue;
+            }
+
+            if (!filter(neighbour_face, current)) {
+                // rejected by filter
+                continue;
+            }
+
+            if (open.includes(neighbour_face)) {
+                // already included
+                continue;
+            }
+
+            open.push(neighbour_face);
+        }
+
+    }
+
+    return result_set;
+}

package/engine/Engine.js

@@ -305,7 +305,7 @@ class Engine {
         gameView.addChild(viewport);
 
         this.viewStack = new ViewStack();
-        this.viewStack.push(gameView);
+        this.viewStack.push(gameView,'game-view');
 
         //bind size of renderer viewport to game view
         viewport.bindSignal(gameView.size.onChanged, viewport.size.set.bind(viewport.size));

package/engine/EngineHarness.js

@@ -260,7 +260,7 @@ export class EngineHarness {
                              }) {
 
         if (enableLights) {
-            EngineHarness.buildLights({ engine: engine, shadowmapResolution });
+            await EngineHarness.buildLights({ engine: engine, shadowmapResolution });
         }
 
         const camera = EngineHarness.buildCamera({
@@ -307,11 +307,11 @@ export class EngineHarness {
      * @param {EntityComponentDataset} ecd
      * @param shadowmapResolution
      */
-    static buildLights({ engine, ecd = engine.entityManager.dataset, shadowmapResolution = 1024 }) {
+    static async buildLights({ engine, ecd = engine.entityManager.dataset, shadowmapResolution = 1024 }) {
         const em = engine.entityManager;
 
-        if (em.getSystem(LightSystem) === null) {
-            em.addSystem(new LightSystem(engine, {
+        if (!em.hasSystem(LightSystem)) {
+            await em.addSystem(new LightSystem(engine, {
                 shadowResolution: shadowmapResolution
             }));
         }
@@ -345,7 +345,7 @@ export class EngineHarness {
         const fill = new Light();
         fill.type.set(Light.Type.AMBIENT);
         fill.color.setRGB(1, 1, 1);
-        fill.intensity.set(0.4);
+        fill.intensity.set(0.1);
 
 
         new EntityBuilder()

package/engine/ecs/parent/EntityNode.js

@@ -233,7 +233,7 @@ export class EntityNode {
 
         // live mode
         if (this.__entity.isBuilt) {
-            // TODO attach node live
+            node.build(this.__entity.dataset);
         }
 
         return true;
@@ -256,7 +256,6 @@ export class EntityNode {
 
         node.parent = null;
 
-
         return true;
     }
 

package/engine/graphics/GraphicsEngine.js

@@ -486,8 +486,11 @@ GraphicsEngine.prototype.normalizeViewportPoint = function (input, result) {
 
     const viewportSize = this.viewport.size;
 
-    result.x = (input.x / viewportSize.x) * 2 - 1;
-    result.y = -(input.y / viewportSize.y) * 2 + 1;
+    const _x = input.x;
+    const _y = input.y;
+
+    result.x = (_x / viewportSize.x) * 2 - 1;
+    result.y = -(_y / viewportSize.y) * 2 + 1;
 };
 
 /**

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

@@ -324,7 +324,7 @@ export class ShadedGeometry {
      *
      * @param {SurfacePoint3} contact if found, contact is written here
      * @param {ArrayLike<number>|number[]|Float32Array} ray 6-tuple: [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
-     * @param {ArrayLike<number>|number[]|Float32Array} transform_matrix4
+     * @param {ArrayLike<number>|number[]|Float32Array} transform_matrix4 transform applied to the geometry
      * @returns {boolean}
      */
     query_raycast_nearest(contact, ray, transform_matrix4) {

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js

@@ -9,6 +9,7 @@ import { SGMeshEvents } from "./SGMeshEvents.js";
 import { ParentEntity } from "../../../../ecs/parent/ParentEntity.js";
 import { EntityNode } from "../../../../ecs/parent/EntityNode.js";
 import { min2 } from "../../../../../core/math/min2.js";
+import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
 
 
 /**
@@ -69,6 +70,15 @@ export class SGMeshSystem extends System {
         this.__asset_object_cache = new Map();
     }
 
+    async startup(em, ready_callback, error_callback) {
+
+        if (!em.hasSystem(TransformAttachmentSystem)) {
+            await em.addSystem(new TransformAttachmentSystem());
+        }
+
+        super.startup(em, ready_callback, error_callback);
+    }
+
     /**
      *
      * @param {number} entity

package/engine/graphics/geometry/buffered/makeGeometryIndexed.js

@@ -1,4 +1,4 @@
-import { Float32BufferAttribute } from "three";
+import { Uint32BufferAttribute } from "three";
 
 /**
  *
@@ -10,13 +10,14 @@ export function makeGeometryIndexed(geometry) {
     if (index_attribute === null || index_attribute === undefined) {
         const position_attribute = geometry.getAttribute('position');
         // non-indexed geometry, build index
-        const array = new Float32Array(position_attribute.count * 3);
+        const size = position_attribute.count;
+        const array = new Uint32Array(size);
 
-        for (let i = 0; i < array.length; i++) {
+        for (let i = 0; i < size; i++) {
             array[i] = i;
         }
 
-        index_attribute = new Float32BufferAttribute(array, 1, false);
+        index_attribute = new Uint32BufferAttribute(array, 1, false);
 
         geometry.setIndex(index_attribute);
     }