@woosh/meep-engine 2.43.22 → 2.43.24

package/engine/graphics/sh3/path_tracer/prototypePathTracer.js

@@ -7,8 +7,7 @@ import {
     OctahedronBufferGeometry,
     PerspectiveCamera,
     PlaneBufferGeometry,
-    Sphere,
-    SphereBufferGeometry
+    Sphere
 } from "three";
 import { Sampler2D } from "../../texture/sampler/Sampler2D.js";
 import sampler2D2Canvas from "../../texture/sampler/Sampler2D2Canvas.js";
@@ -134,8 +133,13 @@ function make_sun({
 function prepare_scene_sphere_01(pt, camera) {
     camera.position.set(0, 0, -2.1);
     camera.lookAt(0, 0, 0);
+
+
+    const sphere_geo = new OctahedronBufferGeometry(1, 9);
+    makeGeometryIndexed(sphere_geo);
+
     pt.addMesh(
-        new SphereBufferGeometry(1, 16, 16),
+        sphere_geo,
         // new MeshStandardMaterial({ color: '#FF0000' }),
         new MeshStandardMaterial({ color: '#FFFFFF' }),
         Transform.fromJSON({
@@ -460,7 +464,7 @@ function* render(target, pt, camera, progress = { current: 0, total: 0 }) {
                             ray_direction.x, ray_direction.y, ray_direction.z
                         );
 
-                        pt.path_trace(out, ray, Infinity, 16, random);
+                        pt.path_trace(out, ray, Infinity, 4, random);
 
                         out2[0] += out[0];
                         out2[1] += out[1];
@@ -510,13 +514,13 @@ const camera = new PerspectiveCamera();
 async function start_renderer(camera) {
     camera.aspect = vCanvas.size.x / vCanvas.size.y;
 
-    const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
     // const path = 'data/models/road_bike/road_bike.gltf'; //large CAD-type model
 
     // await prepare_scene_lucy(pt, camera);
     // await prepare_scene_rtiow(pt, camera);
-    // await prepare_scene_sphere_01(pt, camera);
-    await prepare_scene_gltf(pt, camera, path);
+    await prepare_scene_sphere_01(pt, camera);
+    // await prepare_scene_gltf(pt, camera, path);
 
     pt.build();
     pt.optimize();

package/engine/graphics/texture/cubemap/load_environment_map.js

@@ -1,8 +1,8 @@
 import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
 import { CubeTextureLoader, LinearFilter, PMREMGenerator, sRGBEncoding, TextureLoader, UnsignedByteType } from "three";
 import { noop } from "../../../../core/function/Functions.js";
-import { computeFileExtension } from "../../../../core/FilePath.js";
 import { HDRCubeTextureLoader } from "three/examples/jsm/loaders/HDRCubeTextureLoader.js";
+import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 
 /**
  *

package/engine/graphics/util/makeMeshPreviewScene.js

@@ -15,39 +15,51 @@ import AABB2 from "../../../core/geom/AABB2.js";
 
 /**
  *
- * @param {Mesh} mesh trhee.js mesh
- * @param {Vector2} size
- * @param {AABB2} focus
- * @returns {{scene: Scene, camera: PerspectiveCamera}}
+ * @param {THREE.OrthographicCamera} camera
  */
-export function makeMeshPreviewScene(mesh, size, focus = new AABB2(0, 0, size.x, size.y)) {
-    const scene = new ThreeScene();
+function setShadowCamera(camera) {
+    const sqrt2 = Math.sqrt(2);
+    let sqrt2_2 = sqrt2 / 2;
+    camera.left = -sqrt2_2;
+    camera.right = sqrt2_2;
+
+    camera.bottom = -sqrt2_2;
+    camera.top = sqrt2_2;
+}
 
-    //lights
-    const l0 = new ThreeDirectionalLight(0xffffff, 1);
-    l0.position.set(-1, 1, 1);
-    l0.castShadow = true;
-    l0.shadow.mapSize.set(1024, 1024);
+/**
+ *
+ * @param {THREE.Scene} scene
+ */
+function setupLights(scene) {
+    const lightKey = new ThreeDirectionalLight(0xffffff, 1);
+    lightKey.position.set(-1, 1, 1);
+    lightKey.castShadow = true;
+    lightKey.shadow.mapSize.set(1024, 1024);
 
-    function setShadowCamera(camera) {
-        const sqrt2 = Math.sqrt(2);
-        let sqrt2_2 = sqrt2 / 2;
-        camera.left = -sqrt2_2;
-        camera.right = sqrt2_2;
 
-        camera.bottom = -sqrt2_2;
-        camera.top = sqrt2_2;
-    }
+    setShadowCamera(lightKey.shadow.camera);
+    scene.add(lightKey);
 
-    setShadowCamera(l0.shadow.camera);
-    scene.add(l0);
+    const lightHighlight = new ThreeDirectionalLight(0xffffff, 0.50);
+    lightHighlight.position.set(0, 0, 1);
+    scene.add(lightHighlight);
 
-    const l1 = new ThreeDirectionalLight(0xffffff, 0.50);
-    l1.position.set(0, 0, 1);
-    scene.add(l1);
+    const lightFill = new ThreeAmbientLight(0xFFFFFF, 0.5);
+    scene.add(lightFill);
+}
+
+/**
+ *
+ * @param {Mesh} mesh trhee.js mesh
+ * @param {Vector2} size
+ * @param {AABB2} focus
+ * @returns {{scene: Scene, camera: THREE.PerspectiveCamera}}
+ */
+export function makeMeshPreviewScene(mesh, size, focus = new AABB2(0, 0, size.x, size.y)) {
+    const scene = new ThreeScene();
 
-    const l2 = new ThreeAmbientLight(0xFFFFFF, 0.5);
-    scene.add(l2);
+    setupLights(scene);
 
     scaleObject3ToBox(mesh, new Vector3(1, 1, 1), mesh.scale);
     scene.add(mesh);

package/engine/network/RemoteController.js

@@ -0,0 +1,138 @@
+import { BinaryBuffer } from "../../core/binary/BinaryBuffer.js";
+import BinaryBufferDeSerializer from "../ecs/storage/BinaryBufferDeSerializer.js";
+import { BinaryObjectSerializationAdapter } from "../ecs/storage/binary/object/BinaryObjectSerializationAdapter.js";
+
+class LocalAPI {
+    /**
+     *
+     * @type {Engine|null}
+     */
+    engine = null;
+
+    _object_serde = new BinaryObjectSerializationAdapter();
+
+    get _registry() {
+        return this.engine.binarySerializationRegistry;
+    }
+
+    /**
+     *
+     * @return {EntityComponentDataset}
+     * @private
+     */
+    get _current_dataset() {
+        return this.engine.entityManager.dataset;
+    }
+
+    /**
+     * Server sent us a new world state
+     * @param {BinaryBuffer} buffer
+     */
+    async writeCurrentSceneDataset(buffer) {
+        const deSerializer = new BinaryBufferDeSerializer();
+
+        const engine = this.engine;
+
+        deSerializer.registry = this._registry;
+
+        const ecd = this._current_dataset;
+
+        ecd.clear();
+
+        const task = deSerializer.process(buffer, engine, ecd);
+
+        const p = task.promise();
+
+        engine.executor.run(task);
+
+        await p;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @return {Promise<void>}
+     */
+    async createEntity(buffer) {
+        // create entity on the current scene with a given ID
+
+        const entity_id = buffer.readUintVar();
+
+        this._current_dataset.createEntitySpecific(entity_id);
+    }
+
+    async addComponentToEntity(buffer) {
+        const entity_id = buffer.readUintVar();
+
+        this._object_serde.registry = this._registry;
+        const component_instance = this._object_serde.deserialize(buffer);
+
+        this._current_dataset.addComponentToEntity(entity_id, component_instance);
+
+    }
+
+}
+
+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);
+
+        const buffer =  BinaryBuffer.fromArrayBuffer(data);
+
+        // read packet ID
+        const packet_id = 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](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,36 @@
+import { EngineHarness } from "../EngineHarness.js";
+import { RemoteController } from "./RemoteController.js";
+import { ShadedGeometrySystem } from "../graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
+import { initializeGameBinarySerializationRegistry } from "../../../model/game/GameBinarySerializationRegistry.js";
+
+const harness = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+async function main(engine) {
+
+    await EngineHarness.buildBasics({
+        engine
+    });
+
+    initializeGameBinarySerializationRegistry(engine.binarySerializationRegistry);
+
+    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.24",
   "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');
-});