@woosh/meep-engine 2.43.22 → 2.43.23

package/engine/network/RemoteController.js

@@ -0,0 +1,98 @@
+import { BinaryBuffer } from "../../core/binary/BinaryBuffer.js";
+import BinaryBufferDeSerializer from "../ecs/storage/BinaryBufferDeSerializer.js";
+
+const scratch_buffer = new BinaryBuffer();
+
+class LocalAPI {
+    /**
+     *
+     * @type {Engine|null}
+     */
+    engine = null;
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    async writeCurrentSceneDataset(buffer) {
+        const deSerializer = new BinaryBufferDeSerializer();
+
+        const engine = this.engine;
+
+        const ecd = engine.entityManager.dataset;
+
+        ecd.clear();
+
+        const task = deSerializer.process(buffer, engine, ecd);
+
+        const p = task.promise();
+
+        engine.executor.run(task);
+
+        await p;
+    }
+}
+
+export class RemoteController {
+    /**
+     *
+     * @type {WebSocket|null}
+     */
+    socket = null;
+
+    localAPI = new LocalAPI();
+
+    /**
+     *
+     * @param {Engine} engine
+     */
+    attach(engine) {
+        this.localAPI.engine = engine;
+
+    }
+
+    /**
+     *
+     * @param {ArrayBuffer} data
+     * @private
+     */
+    async __handle_message(data) {
+        // console.log(`received message `, data);
+
+        scratch_buffer.fromArrayBuffer(data);
+
+        // read packet ID
+        const packet_id = scratch_buffer.readUTF8String();
+
+        console.log(`packet ID: ${packet_id}`);
+
+        if (this.localAPI[packet_id] === undefined) {
+            console.error(`Local API does not have method '${packet_id}'`);
+            return;
+        }
+
+        try {
+            await this.localAPI[packet_id](scratch_buffer);
+        } catch (e) {
+            //
+            console.error(`Failed to process remote call to '${packet_id}':`, e);
+        }
+    }
+
+
+    startup() {
+        this.socket = new WebSocket('ws://localhost:9020');
+
+        this.socket.binaryType = "arraybuffer";
+
+        this.socket.addEventListener('open', () => {
+            console.log('socket connection open');
+        });
+
+        this.socket.addEventListener('message', (event) => {
+
+
+            this.__handle_message(event.data);
+        });
+    }
+}

package/engine/network/remoteEditor.js

@@ -0,0 +1,33 @@
+import { EngineHarness } from "../EngineHarness.js";
+import { RemoteController } from "./RemoteController.js";
+import { ShadedGeometrySystem } from "../graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
+
+const harness = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+async function main(engine) {
+
+    await EngineHarness.buildBasics({
+        engine
+    });
+
+    const remote = new RemoteController();
+
+    remote.attach(engine);
+    remote.startup();
+
+}
+
+harness.initialize({
+    configuration(config, engine) {
+
+        config.addSystem(new ShadedGeometrySystem(engine));
+
+    }
+}).then(main);
+
+

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

package/view/elements/MeshPreview.js

@@ -11,10 +11,14 @@ import { PointerDevice } from '../../engine/input/devices/PointerDevice.js';
 import dom from "../DOM.js";
 import { WebGLRendererPool } from "../../engine/graphics/render/RendererPool.js";
 import { advanceAnimation } from "../../engine/ecs/systems/AnimationSystem.js";
+import { computeFileExtension } from "../../core/path/computeFileExtension.js";
 
 const mapExtension2Mime = {
     gltf: "model/gltf+json",
     glb: "model/gltf",
+    /**
+     * @deprecated no longer supported, please don't use
+     */
     json: "three.js"
 };
 
@@ -56,7 +60,7 @@ class MeshPreview extends View {
             throw new Error(`Mesh URL was expected to be a string, instead was ${typeof url}: ${s}`);
         }
 
-        const extension = url.substring(url.lastIndexOf(".") + 1);
+        const extension = computeFileExtension(url);
 
         if (extension.length === 0) {
             throw new Error(`No file extension on url '${url}'`);

package/core/FilePath.js

@@ -1,73 +0,0 @@
-const PATH_SEPARATOR = '/';
-
-/**
- * Strips all directories from the path.
- * @example 'a/b/c' -> 'c'
- * @param {string} path
- * @returns {string}
- */
-function computePathBase(path) {
-    if (typeof path !== "string") {
-        throw new Error('path is not a string');
-    }
-
-    const lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
-
-    if (lastSlashIndex !== -1) {
-        return path.substring(lastSlashIndex + 1);
-    } else {
-        return path;
-    }
-}
-
-/**
- * Returns the directory name of a path, similar to the Unix dirname command.
- * @param {string} path
- * @return {string}
- */
-export function computePathDirectory(path) {
-    if (typeof path !== "string") {
-        throw new Error('path is not a string');
-    }
-
-    let lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
-
-    //rewind in case of trailing slashes
-    while (lastSlashIndex > 0 && path.charAt(lastSlashIndex - 1) === PATH_SEPARATOR) {
-        lastSlashIndex--;
-    }
-
-    if (lastSlashIndex !== -1) {
-        return path.substring(0, lastSlashIndex);
-    } else {
-        return path;
-    }
-}
-
-/**
- *
- * @param {string} path
- * @returns {String|null}
- */
-function computeFileExtension(path) {
-    if (typeof path !== "string") {
-        throw new Error('path is not a string');
-    }
-
-    //get base
-    const pathBase = computePathBase(path);
-
-    const lastDotIndex = pathBase.lastIndexOf('.');
-
-    if (lastDotIndex !== -1) {
-        return pathBase.substring(lastDotIndex + 1);
-    } else {
-        //no extension
-        return null;
-    }
-}
-
-export {
-    computePathBase,
-    computeFileExtension
-};

package/core/FilePath.spec.js

@@ -1,25 +0,0 @@
-import { computeFileExtension, computePathBase } from "./FilePath.js";
-
-test('extract extension of cat.txt', () => {
-    expect(computeFileExtension('cat.txt')).toEqual('txt');
-});
-
-test('extract extension of ../hmm/cat.txt', () => {
-    expect(computeFileExtension('../hmm/cat.txt')).toEqual('txt');
-});
-
-test('extract extension of empty string', () => {
-    expect(computeFileExtension('')).toBeNull();
-});
-
-test('extract base path of empty string', () => {
-    expect(computePathBase('')).toBe('');
-});
-
-test('extract base path of hello', () => {
-    expect(computePathBase('hello')).toBe('hello');
-});
-
-test('extract base path of hello/there/world', () => {
-    expect(computePathBase('hello/there/world')).toBe('world');
-});

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

@@ -1,329 +0,0 @@
-import { HashMap } from "../../../../collection/HashMap.js";
-import { split_by_2 } from "../../morton/mortonEncode_magicbits.js";
-import { NULL_POINTER } from "./BinaryTopology.js";
-
-
-/**
- * Populates supplied topology with data from supplied indexed geometry
- * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/blenkernel/intern/mesh_calc_edges.cc
- * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/io/stl/importer/stl_import_mesh.cc#L63
- * @param {BinaryTopology} out
- * @param {number[]} indices
- * @param {number[]} vertex_positions
- * @param {number[]} [vertex_normals]
- */
-export function bt_index_geometry_to_topology(
-    out,
-    indices,
-    vertex_positions,
-    vertex_normals
-) {
-
-    // remove any existing data
-    out.clear();
-
-    /*
-    NOTES:
-        - we use {@link BinaryElementPool#allocate_continuous} to avoid having to allocate additional mapping structure
-     */
-
-    // ingest all vertices
-    const vertex_count = vertex_positions.length / 3;
-
-    const vertex_allocation_offset = out.vertices.allocate_continuous(vertex_count);
-
-    for (let i = 0; i < vertex_count; i++) {
-        const i3 = i * 3;
-
-        const vertex_id = i + vertex_allocation_offset;
-
-        out.vertex_write_coordinate(vertex_id, vertex_positions, i3);
-
-        if (vertex_normals !== undefined) {
-            out.vertex_write_normal(vertex_id, vertex_normals, i3);
-        }
-
-        // initialize edge to NULL
-        out.vertex_write_edge(vertex_id, NULL_POINTER);
-    }
-
-    const face_count = indices.length / 3;
-
-    // reserve some memory to avoid extra allocations
-    out.loops.ensure_capacity(face_count * 3);
-    out.edges.ensure_capacity(face_count * 1.6);
-
-    // create faces
-    const face_allocation_offset = out.faces.allocate_continuous(face_count);
-
-    /**
-     *
-     * @type {HashMap<OrderedEdge, number>}
-     */
-    const edge_hash_map = new HashMap({
-        capacity: Math.ceil(1 + 2.1 * face_count)
-    });
-
-    for (let i = 0; i < face_count; i++) {
-        const i3 = i * 3;
-
-        const a = indices[i3];
-        const b = indices[i3 + 1];
-        const c = indices[i3 + 2];
-
-        const vertex_a = a + vertex_allocation_offset;
-        const vertex_b = b + vertex_allocation_offset;
-        const vertex_c = c + vertex_allocation_offset;
-
-        const face_id = i + face_allocation_offset;
-
-        // create edges
-        const edge_ab = get_or_create_edge(vertex_a, vertex_b, edge_hash_map, out);
-        const edge_bc = get_or_create_edge(vertex_b, vertex_c, edge_hash_map, out);
-        const edge_ca = get_or_create_edge(vertex_c, vertex_a, edge_hash_map, out);
-
-        // allocate loops
-        const loop_a = out.loop_create();
-        const loop_b = out.loop_create();
-        const loop_c = out.loop_create();
-
-        // write loops
-        out.loop_write_vertex(loop_a, vertex_a);
-        out.loop_write_vertex(loop_b, vertex_b);
-        out.loop_write_vertex(loop_c, vertex_c);
-
-        // link loops to edges
-        link_loop_to_edge(loop_a, edge_ab, out);
-        link_loop_to_edge(loop_b, edge_bc, out);
-        link_loop_to_edge(loop_c, edge_ca, out);
-
-        out.loop_write_face(loop_a, face_id);
-        out.loop_write_face(loop_b, face_id);
-        out.loop_write_face(loop_c, face_id);
-
-        /*
-        NOTE: Vertices (#BMLoop.v & #BMLoop.next.v) always contain vertices from (#BMEdge.v1 & #BMEdge.v2).
-         */
-        // link up loops around the face
-        out.loop_write_next(loop_a, loop_b);
-        out.loop_write_prev(loop_a, loop_c);
-
-        out.loop_write_next(loop_b, loop_c);
-        out.loop_write_prev(loop_b, loop_a);
-
-        out.loop_write_next(loop_c, loop_a);
-        out.loop_write_prev(loop_c, loop_b);
-
-        // update face
-        out.face_write_loop(face_id, loop_a);
-
-    }
-}
-
-/**
- * follow the pointer list to the end along radial list
- * @param {number} start_loop
- * @param {BinaryTopology} mesh
- * @returns {number}
- */
-function loop_radial_get_last(start_loop, mesh) {
-    let prev_loop = start_loop;
-    let next_loop;
-
-    while ((next_loop = mesh.loop_read_radial_next(prev_loop)) !== NULL_POINTER) {
-        prev_loop = next_loop;
-    }
-
-    return prev_loop;
-}
-
-/**
- *
- * @param {number} loop_id
- * @param {number} edge_id
- * @param {BinaryTopology} mesh
- */
-function link_loop_to_edge(loop_id, edge_id, mesh) {
-    mesh.loop_write_edge(loop_id, edge_id);
-
-    /**
-     * First loop attached to the edge
-     * @type {number}
-     */
-    const edge_loop_start = mesh.edge_read_loop(edge_id);
-
-    if (edge_loop_start === NULL_POINTER) {
-        // no loops connected yet
-        mesh.edge_write_loop(edge_id, loop_id);
-    } else {
-        // connect loop to the end of the list
-        const last_loop_in_list = loop_radial_get_last(edge_loop_start, mesh);
-
-        mesh.loop_write_radial_next(last_loop_in_list, loop_id);
-        mesh.loop_write_radial_prev(loop_id, last_loop_in_list);
-    }
-
-}
-
-/**
- * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/blenkernel/intern/mesh_calc_edges.cc#L209
- * @param {BinaryTopology} mesh
- */
-function bt_mesh_calc_edges(mesh) {
-    /**
-     *
-     * @type {HashMap<OrderedEdge, unknown>}
-     */
-    const map = new HashMap();
-
-    add_polygon_edges_to_map(mesh, map);
-}
-
-class OrderedEdge {
-    /**
-     *
-     * @param {number} v1
-     * @param {number} v2
-     */
-    constructor(v1, v2) {
-        if (v1 < v2) {
-            this.v_low = v1;
-            this.v_high = v2;
-        } else {
-            this.v_low = v2;
-            this.v_high = v1;
-        }
-    }
-
-    /**
-     *
-     * @param {number} v1
-     * @param {number} v2
-     */
-    set(v1, v2) {
-        if (v1 < v2) {
-            this.v_low = v1;
-            this.v_high = v2;
-        } else {
-            this.v_low = v2;
-            this.v_high = v1;
-        }
-    }
-
-    /**
-     *
-     * @param {OrderedEdge} other
-     */
-    copy(other) {
-        this.v_low = other.v_low;
-        this.v_high = other.v_high;
-    }
-
-    clone() {
-        return new OrderedEdge(this.v_low, this.v_high);
-    }
-
-    /**
-     *
-     * @return {number}
-     */
-    hash() {
-        return split_by_2(this.v_low) | (split_by_2(this.v_high) << 1);
-    }
-
-    /**
-     *
-     * @param {OrderedEdge} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.v_low === other.v_low
-            && this.v_high === other.v_high
-            ;
-    }
-}
-
-/**
- * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/blenkernel/intern/mesh_calc_edges.cc#L96
- * @param {BinaryTopology} mesh
- * @param {HashMap<OrderedEdge,*>} edge_map
- */
-function add_polygon_edges_to_map(mesh, edge_map) {
-
-    const faces = mesh.faces;
-    const face_count = faces.size;
-
-    for (let i = 0; i < face_count; i++) {
-        if (!faces.is_allocated(i)) {
-            continue;
-        }
-
-        const first_loop = mesh.face_read_loop(i);
-        let prev_loop = first_loop + j;
-
-        for (let j = 0; j < 3; j++) {
-            const loop = first_loop + j;
-
-
-            const prev_v = mesh.loop_read_vertex(prev_loop);
-            const next_v = mesh.loop_read_vertex(loop);
-
-            const edge = new OrderedEdge(prev_v, next_v);
-
-            edge_map.getOrSet(edge, null);
-
-            prev_loop = loop;
-        }
-    }
-
-}
-
-/**
- *
- * @param {number} v0
- * @param {number} v1
- * @param {HashMap<OrderedEdge,number>} map
- * @param {BinaryTopology} mesh
- */
-function get_or_create_edge(v0, v1, map, mesh) {
-    const scratch_ordered_edge = new OrderedEdge(v0, v1);
-
-    const existing = map.get(scratch_ordered_edge);
-
-    if (existing !== undefined) {
-        return existing;
-    }
-
-    // doesn't exist - create
-    const edge_id = mesh.edges.allocate();
-
-    mesh.edge_write_vertex1(edge_id, v0);
-    mesh.edge_write_vertex2(edge_id, v1);
-
-    // initialize rest of the edge
-    mesh.edge_write_loop(edge_id, NULL_POINTER);
-
-    // TODO process disk_link pointers for the edge
-
-    map.set(scratch_ordered_edge, edge_id);
-
-    return edge_id;
-}
-
-
-/**
- * Ensure an edge between two vertices
- * NOTE: works without having to use a separate hash map, resulting in faster execution and smaller RAM requirement
- * @param {number} v0
- * @param {number} v1
- * @param {BinaryTopology} mesh
- */
-function get_or_create_edge_2(v0, v1, mesh) {
-    const first_edge = mesh.vertex_read_edge(v0);
-
-    // iterate over all edges around the vertex
-
-    // if match is found - return the match, else create a new edge and assign
-
-    // TODO implement
-}

package/core/geom/3d/topology/struct/bt_index_geometry_to_topology.spec.js

@@ -1,26 +0,0 @@
-import { bt_index_geometry_to_topology } from "./bt_index_geometry_to_topology.js";
-import { BinaryTopology } from "./BinaryTopology.js";
-
-test('Empty geometry work as expected', () => {
-    const mesh = new BinaryTopology();
-    bt_index_geometry_to_topology(mesh, [], []);
-
-    expect(mesh.faces.size).toBe(0);
-    expect(mesh.vertices.size).toBe(0);
-    expect(mesh.edges.size).toBe(0);
-    expect(mesh.loops.size).toBe(0);
-});
-
-test('Single triangle', () => {
-    const mesh = new BinaryTopology();
-    bt_index_geometry_to_topology(mesh, [0, 1, 2], [
-        1, 3, 7,
-        11, 13, 17,
-        23, 27, -1
-    ]);
-
-    expect(mesh.faces.size).toBe(1);
-    expect(mesh.loops.size).toBe(3);
-    expect(mesh.edges.size).toBe(3);
-    expect(mesh.vertices.size).toBe(3);
-});