@woosh/meep-engine 2.43.3 → 2.43.4

package/samples/terrain/from_image_2.js

@@ -7,7 +7,6 @@ import EntityBuilder from "../../engine/ecs/EntityBuilder.js";
 import Terrain from "../../engine/ecs/terrain/ecs/Terrain.js";
 import { ImageRGBADataLoader } from "../../engine/asset/loaders/image/ImageRGBADataLoader.js";
 import TerrainSystem from "../../engine/ecs/terrain/ecs/TerrainSystem.js";
-import WaterSystem from "../../engine/graphics/ecs/water/WaterSystem.js";
 import Water from "../../engine/graphics/ecs/water/Water.js";
 import {
     AmbientOcclusionPostProcessEffect
@@ -16,73 +15,42 @@ import { TerrainLayer } from "../../engine/ecs/terrain/ecs/layers/TerrainLayer.j
 import Mesh from "../../engine/graphics/ecs/mesh/Mesh.js";
 import { Transform } from "../../engine/ecs/transform/Transform.js";
 import { MeshSystem } from "../../engine/graphics/ecs/mesh/MeshSystem.js";
-import { enableEditor } from "../../editor/enableEditor.js";
-import "../../../../../css/main.scss";
-import '../../../../../css/editor/EntityEditorView.scss';
-import '../../../../../css/editor/EditorView.scss';
-import { initializeEditor } from "../../../model/game/initializeEditor.js";
+import ButtonView from "../../view/elements/button/ButtonView.js";
+import { downloadAsFile } from "../../core/binary/ByteArrayTools.js";
 
 const HEIGHT_RANGE = 64;
 
 const eh = new EngineHarness();
 
-/**
- *
- * @param {Engine} engine
- * @return {EngineConfiguration}
- */
-function makeConfig(engine) {
-    const r = new EngineConfiguration();
-
-    // configure engine here, add systems, loaders etc.
-    r.addLoader(GameAssetType.Texture, new TextureAssetLoader());
-    r.addLoader(GameAssetType.Image, new ImageRGBADataLoader());
-
-
-    r.addSystem(new TerrainSystem(engine.graphics, engine.assetManager));
-    r.addSystem(new WaterSystem(engine.graphics));
-    r.addSystem(new MeshSystem(engine));
-
-    r.addPlugin(AmbientOcclusionPostProcessEffect);
-
-    return r;
-}
 
 /**
  *
- * @param {string} path
- * @param {AssetManager} am
+ * @param {Sampler2D} source
+ * @param {Terrain} terrain
  */
-async function load_sampler(path, am) {
-
-    const asset = await am.promise(path, 'image');
+function scale_terrain_heights(source, terrain) {
+    const source_height_data = source.data;
+    const sampler_pixel_count = source_height_data.length;
+    const terrain_height_data = terrain.samplerHeight.data;
 
-    /**
-     *
-     * @type {Sampler2D}
-     */
-    const sampler = asset.create();
+    let divisor;
+    if (source_height_data instanceof Uint8Array) {
+        divisor = 255;
+    } else if (source_height_data instanceof Uint16Array) {
+        divisor = 65536 - 1;
+    }
 
-    return sampler;
-}
+    for (let i = 0; i < sampler_pixel_count; i++) {
+        const source_v = source_height_data[i];
 
-/**
- *
- * @param {string} path
- * @param {Engine} engine
- * @param {Transform} transform
- */
-async function load_gltf(path, engine, transform) {
-    const em = engine.entityManager;
+        const b0 = source_v & 0xFF;
+        const b1 = (source_v >> 8) & 0xFF;
 
-    const ecd = em.dataset;
+        let rotated_v;
+        rotated_v = b1 | (b0 << 8);
 
-    new EntityBuilder()
-        .add(Mesh.fromJSON({
-            url: path
-        }))
-        .add(transform)
-        .build(ecd);
+        terrain_height_data[i] = (rotated_v / divisor) * HEIGHT_RANGE
+    }
 }
 
 /**
@@ -139,43 +107,22 @@ async function main(engine) {
     await load_splat_layer("moicon/23_Nov_21_Skogplanter/01/splat_stone.png", 2);
 
     terrain.samplerHeight.resize(sampler.width, sampler.height);
-    const source_height_data = sampler.data;
-    const sampler_pixel_count = source_height_data.length;
-    const terrain_height_data = terrain.samplerHeight.data;
-
-    let divisor;
-    if (source_height_data instanceof Uint8Array) {
-        divisor = 255;
-    } else if (source_height_data instanceof Uint16Array) {
-        divisor = 65536 - 1;
-    }
-
-    for (let i = 0; i < sampler_pixel_count; i++) {
-        const source_v = source_height_data[i];
-
-        const b0 = source_v & 0xFF;
-        const b1 = (source_v >> 8) & 0xFF;
-
-        let rotated_v;
-        rotated_v = b1 | (b0 << 8);
-
-        terrain_height_data[i] = (rotated_v / divisor) * HEIGHT_RANGE
-    }
+    scale_terrain_heights(sampler, terrain);
 
     terrain.layers.resolution.set(1024, 1024);
 
     terrain.layers.addLayer(TerrainLayer.from(
-        "data/textures/materials/terrain_township_set/Grass_2.png",
+        "moicon/23_Nov_21_Skogplanter/01/textures/Grass_2.png",
         20,
         20
     ));
     terrain.layers.addLayer(TerrainLayer.from(
-        "data/textures/materials/terrain_township_set/1024/Ground_1_dark.png",
+        "moicon/23_Nov_21_Skogplanter/01/textures/Ground_1_dark.png",
         20,
         20
     ));
     terrain.layers.addLayer(TerrainLayer.from(
-        "data/textures/materials/Sci-Fi Planet/Sand_01.png",
+        "moicon/23_Nov_21_Skogplanter/01/textures/Sand_01.png",
         20,
         20
     ));
@@ -188,7 +135,8 @@ async function main(engine) {
     water.shoreDepthTransition.set(0.1, 0.3);
     water.scattering.set(3);
 
-    new EntityBuilder()
+    const terrain_builder = new EntityBuilder();
+    terrain_builder
         .add(terrain)
         // .add(water)
         .build(ecd);
@@ -204,6 +152,47 @@ async function main(engine) {
     load_gltf("moicon/23_Nov_21_Skogplanter/02/model.gltf", engine, transform);
     // load_gltf("moicon/23_Nov_21_Skogplanter/03/model.gltf", engine, transform);
     // load_gltf("moicon/23_Nov_21_Skogplanter/04/model.gltf", engine, transform);
+
+    engine.gui.view.addChild(new ButtonView({
+        name: 'Download',
+        action() {
+            // we wrap the terrain data into "component json" format that meep editor recognizes to make this compatible with the standalone terrain editor
+            const json_payload = {
+                type: "Terrain",
+                data: terrain.toJSON()
+            };
+
+            downloadAsFile(
+                JSON.stringify(json_payload),
+                'terrain.json'
+            );
+        },
+        css: {
+            bottom: '4px',
+            left: '4px',
+            position: 'absolute',
+            background: 'white',
+            border: '1px solid black',
+            padding: '2px',
+            pointerEvents: 'auto'
+        }
+    }));
+
+    engine.gui.view.addChild(new ButtonView({
+        name: 'Remove',
+        action() {
+           engine.entityManager.dataset.removeEntity(terrain_builder.entity);
+        },
+        css: {
+            bottom: '4px',
+            left: '104px',
+            position: 'absolute',
+            background: 'white',
+            border: '1px solid black',
+            padding: '2px',
+            pointerEvents: 'auto'
+        }
+    }));
 }
 
 /**
@@ -215,11 +204,67 @@ async function init(harness) {
 
     await makeConfig(engine).apply(engine);
 
-    enableEditor(engine,initializeEditor);
-
     await eh.initialize();
 
     main(engine);
 }
 
 init(eh);
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {EngineConfiguration}
+ */
+function makeConfig(engine) {
+    const r = new EngineConfiguration();
+
+    // configure engine here, add systems, loaders etc.
+    r.addLoader(GameAssetType.Texture, new TextureAssetLoader());
+    r.addLoader(GameAssetType.Image, new ImageRGBADataLoader());
+
+
+    r.addSystem(new TerrainSystem(engine.graphics, engine.assetManager));
+    r.addSystem(new MeshSystem(engine));
+
+    r.addPlugin(AmbientOcclusionPostProcessEffect);
+
+    return r;
+}
+
+/**
+ *
+ * @param {string} path
+ * @param {AssetManager} am
+ */
+async function load_sampler(path, am) {
+
+    const asset = await am.promise(path, 'image');
+
+    /**
+     *
+     * @type {Sampler2D}
+     */
+    const sampler = asset.create();
+
+    return sampler;
+}
+
+/**
+ *
+ * @param {string} path
+ * @param {Engine} engine
+ * @param {Transform} transform
+ */
+async function load_gltf(path, engine, transform) {
+    const em = engine.entityManager;
+
+    const ecd = em.dataset;
+
+    new EntityBuilder()
+        .add(Mesh.fromJSON({
+            url: path
+        }))
+        .add(transform)
+        .build(ecd);
+}

package/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_compute_cavity2.js

@@ -1,224 +0,0 @@
-import { assert } from "../../../../assert.js";
-import { point_in_tetrahedron_circumsphere } from "../point_in_tetrahedron_circumsphere.js";
-import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
-
-
-/**
- *
- * @param {Cavity} cavity
- * @param {TetrahedralMesh} mesh
- * @param {number} tet
- * @param {number} point_index
- * @param {number} k0
- * @param {number} k1
- * @param {number} k2
- * @param {number} k3
- */
-function store_special(cavity, mesh, tet, point_index, k0, k1, k2, k3) {
-
-    const node_0 = mesh.getVertexIndex(tet, k0);
-    const node_1 = mesh.getVertexIndex(tet, k1);
-    const node_2 = mesh.getVertexIndex(tet, k2);
-
-    cavity.push_boundary(
-        point_index,
-        node_0,
-        node_1,
-        node_2,
-        mesh.getNeighbour(tet, k3),
-    );
-}
-
-/**
- *
- * @param {TetrahedralMesh} mesh
- * @param {Cavity} cavity
- * @param {number[]|Float32Array} points
- * @param {Float32Array} subdets
- * @param {number} containing_tetra tetrahedron that contains point
- * @param {number} point_index point that forms the cavity
- */
-export function tetrahedral_mesh_compute_cavity3(
-    mesh,
-    points,
-    subdets,
-    cavity,
-    containing_tetra,
-    point_index
-) {
-    assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
-
-    // add the tet to cavity
-    cavity.push_deleted(containing_tetra);
-    subdets[containing_tetra * 4 + 3] = -1;
-
-    for (let start = cavity.__deleted_size - 1; start < cavity.__deleted_size; start++) {
-        const cur_tet = cavity.__deleted[start];
-
-        for (let i = 0; i < 4; i++) {
-            const encoded_neighbour = mesh.getNeighbour(cur_tet, i);
-
-            const k0 = (1 << i) & 3;
-            const k1 = (i + 2) % 3;
-            const k2 = (~((i + 1) >> 1) & 2) + 1;
-            const k3 = i;
-
-            if (encoded_neighbour === INVALID_NEIGHBOUR) {
-                // no neighbour, include this side into boundary
-
-                const node_0 = mesh.getVertexIndex(cur_tet, k0);
-                const node_1 = mesh.getVertexIndex(cur_tet, k1);
-                const node_2 = mesh.getVertexIndex(cur_tet, k2);
-
-                if(i === 3 || node_2 >= node_1) {
-                    cavity.push_boundary(
-                        point_index,
-                        node_2,
-                        node_0,
-                        node_1,
-                        mesh.getNeighbour(cur_tet, k3),
-                    );
-                }else{
-                    cavity.push_boundary(
-                        point_index,
-                        node_0,
-                        node_1,
-                        node_2,
-                        mesh.getNeighbour(cur_tet, k3),
-                    );
-                }
-
-                continue;
-            }
-
-            const neighbour_index = encoded_neighbour >> 2;
-
-            if (subdets[neighbour_index * 4 + 3] === -1) {
-                // already visited
-                continue;
-            }
-
-            if (point_in_tetrahedron_circumsphere(
-                points,
-                mesh.getVertexIndex(neighbour_index, 0),
-                mesh.getVertexIndex(neighbour_index, 1),
-                mesh.getVertexIndex(neighbour_index, 2),
-                mesh.getVertexIndex(neighbour_index, 3),
-                point_index
-            ) < 0) {
-                // outside the cavity, meaning it defines boundary
-
-                const node_0 = mesh.getVertexIndex(cur_tet, k0);
-                const node_1 = mesh.getVertexIndex(cur_tet, k1);
-                const node_2 = mesh.getVertexIndex(cur_tet, k2);
-
-                if(i === 3 || node_2 >= node_1) {
-                    cavity.push_boundary(
-                        point_index,
-                        node_2,
-                        node_0,
-                        node_1,
-                        mesh.getNeighbour(cur_tet, k3),
-                    );
-                }else{
-                    cavity.push_boundary(
-                        point_index,
-                        node_0,
-                        node_1,
-                        node_2,
-                        mesh.getNeighbour(cur_tet, k3),
-                    );
-                }
-            } else {
-                //part of the cavity, remove
-                cavity.push_deleted(neighbour_index);
-                subdets[neighbour_index * 4 + 3] = -1;
-            }
-        }
-
-    }
-}
-
-
-/**
- *
- * @param {TetrahedralMesh} mesh
- * @param {Cavity} cavity
- * @param {number[]|Float32Array} points
- * @param {Float32Array} subdets
- * @param {number} containing_tetra tetrahedron that contains point
- * @param {number} point_index point that forms the cavity
- */
-export function tetrahedral_mesh_compute_cavity2(
-    mesh,
-    points,
-    subdets,
-    cavity,
-    containing_tetra,
-    point_index
-) {
-    assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
-
-    // add the tet to cavity
-    cavity.push_deleted(containing_tetra);
-    subdets[containing_tetra * 4 + 3] = -1;
-
-    for (let start = cavity.__deleted_size - 1; start < cavity.__deleted_size; start++) {
-        const cur_tet = cavity.__deleted[start];
-
-        for (let i = 0; i < 4; i++) {
-            const encoded_neighbour = mesh.getNeighbour(cur_tet, i);
-
-            const k0 = (1 << i) & 3;
-            const k1 = (i + 2) % 3;
-            const k2 = (~((i + 1) >> 1) & 2) + 1;
-            const k3 = i;
-
-            if (encoded_neighbour === INVALID_NEIGHBOUR) {
-                // no neighbour, include this side into boundary
-
-                cavity.push_boundary(
-                    point_index,
-                    mesh.getVertexIndex(cur_tet, k0),
-                    mesh.getVertexIndex(cur_tet, k1),
-                    mesh.getVertexIndex(cur_tet, k2),
-                    mesh.getNeighbour(cur_tet, k3),
-                );
-
-                continue;
-            }
-
-            const neighbour_index = encoded_neighbour >> 2;
-
-            if (subdets[neighbour_index * 4 + 3] === -1) {
-                // already visited
-                continue;
-            }
-
-            if (point_in_tetrahedron_circumsphere(
-                points,
-                mesh.getVertexIndex(neighbour_index, 0),
-                mesh.getVertexIndex(neighbour_index, 1),
-                mesh.getVertexIndex(neighbour_index, 2),
-                mesh.getVertexIndex(neighbour_index, 3),
-                point_index
-            ) < 0) {
-                // outside the cavity, meaning it defines boundary
-
-                cavity.push_boundary(
-                    point_index,
-                    mesh.getVertexIndex(cur_tet, k0),
-                    mesh.getVertexIndex(cur_tet, k1),
-                    mesh.getVertexIndex(cur_tet, k2),
-                    mesh.getNeighbour(cur_tet, k3),
-                );
-
-            } else {
-                //part of the cavity, remove
-                cavity.push_deleted(neighbour_index);
-                subdets[neighbour_index * 4 + 3] = -1;
-            }
-        }
-
-    }
-}

package/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_insert_point.js

@@ -1,98 +0,0 @@
-import { tetrahedral_mesh_compute_cavity } from "./tetrahedral_mesh_compute_cavity.js";
-import { assert } from "../../../../assert.js";
-import { Cavity } from "./Cavity.js";
-import { INVALID_NEIGHBOUR, LAYOUT_TETRA_BYTE_SIZE } from "../TetrahedralMesh.js";
-
-const SCRATCH_CAVITY = new Cavity();
-
-/**
- *
- * @param {TetrahedralMesh} mesh
- * @param {number[]|Float32Array} points
- * @param {number} index
- */
-export function tetrahedral_mesh_insert_point(mesh, points, index) {
-    const debug_length_initial = mesh.__length;
-
-    // Compute the cavity, that is the set of tetrahedra that need to be removed and rebuilt
-    tetrahedral_mesh_compute_cavity(mesh, SCRATCH_CAVITY, points, index);
-
-
-    // identify cavity "edge" - the set of tetras that are neighbours of the tetras that form the cavity
-    const cavity_size = SCRATCH_CAVITY.__deleted_size;
-    const cavity_indices = SCRATCH_CAVITY.__deleted;
-
-    for (let i = 0; i < cavity_size; i++) {
-        const data = mesh.__view;
-
-        const cavity_index = cavity_indices[i];
-
-        // take each side of the tetra
-        const tetra_address = cavity_index * LAYOUT_TETRA_BYTE_SIZE;
-
-        const a = data.getUint32(tetra_address);
-        const b = data.getUint32(tetra_address + 4);
-        const c = data.getUint32(tetra_address + 8);
-        const d = data.getUint32(tetra_address + 12);
-
-        // attempt to form 4 tetras using the sides of the cavity
-        const a_neighbour = data.getUint32(tetra_address + 16);
-        const a_neighbour_index = a_neighbour >> 2;
-
-        const b_neighbour = data.getUint32(tetra_address + 20);
-        const b_neighbour_index = b_neighbour >> 2;
-
-        const c_neighbour = data.getUint32(tetra_address + 24);
-        const c_neighbour_index = c_neighbour >> 2;
-
-        const d_neighbour = data.getUint32(tetra_address + 28);
-        const d_neighbour_index = d_neighbour >> 2;
-
-
-        if (a_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(a_neighbour_index) === 0) {
-            // ABC is a valid side
-            const tet = mesh.append(points, b, d, c, index);
-            // patch in neighbours
-            if (a_neighbour !== INVALID_NEIGHBOUR) {
-                mesh.setNeighbour(tet, 3, a_neighbour);
-                mesh.setNeighbour(a_neighbour_index, a_neighbour & 3, tet);
-            }
-        }
-        if (b_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(b_neighbour_index) === 0) {
-            // ABC is a valid side
-            const tet = mesh.append(points, c, d, a, index);
-            if (b_neighbour !== INVALID_NEIGHBOUR) {
-                mesh.setNeighbour(tet, 3, b_neighbour);
-                mesh.setNeighbour(b_neighbour_index, b_neighbour & 3, tet);
-            }
-        }
-        if (c_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(c_neighbour_index) === 0) {
-            // ABC is a valid side
-            const tet = mesh.append(points, d, b, a, index);
-            if (c_neighbour !== INVALID_NEIGHBOUR) {
-                mesh.setNeighbour(tet, 3, c_neighbour);
-                mesh.setNeighbour(c_neighbour_index, c_neighbour & 3, tet);
-            }
-        }
-        if (d_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(d_neighbour_index) === 0) {
-            // ABC is a valid side
-            const tet = mesh.append(points, a, b, c, index);
-            if (d_neighbour !== INVALID_NEIGHBOUR) {
-                mesh.setNeighbour(tet, 3, d_neighbour);
-                mesh.setNeighbour(d_neighbour_index, d_neighbour & 3, tet);
-            }
-        }
-    }
-
-
-    // 3. remove the cavity tetrahedrons
-    for (let i = 0; i < cavity_size; i++) {
-        const cavity_index = cavity_indices[i];
-
-        // clear out cavity, connectivity was already patched in the previous step
-        mesh.__occupancy.set(cavity_index, false);
-        mesh.__length--;
-    }
-
-    assert.greaterThan(mesh.__length, debug_length_initial, 'after insertion number of tetrahedra must grow, not shrink');
-}