@woosh/meep-engine 2.43.21 → 2.43.23

package/editor/view/library/MeshLibraryView.js

@@ -2,13 +2,13 @@ import View from "../../../view/View.js";
 import { makeModelView } from "../../../view/renderModel.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import domify from "../../../view/DOM.js";
-import { computePathBase } from "../../../core/FilePath.js";
 import LabelView from "../../../view/common/LabelView.js";
 import List from "../../../core/collection/list/List.js";
 import AABB2 from "../../../core/geom/AABB2.js";
 import { DragEvents } from "../../../engine/input/devices/events/DragEvents.js";
 import { MouseEvents } from "../../../engine/input/devices/events/MouseEvents.js";
 import { TouchEvents } from "../../../engine/input/devices/events/TouchEvents.js";
+import { computePathBase } from "../../../core/path/computePathBase.js";
 
 
 const ICON_SIZE = 50;

package/engine/asset/guessAssetType.js

@@ -1,4 +1,4 @@
-import { computeFileExtension } from "../../core/FilePath.js";
+import { computeFileExtension } from "../../core/path/computeFileExtension.js";
 
 /**
  *

package/engine/asset/loaders/image/ImageRGBADataLoader.js

@@ -1,5 +1,4 @@
 import { AssetLoader } from "../AssetLoader.js";
-import { computeFileExtension } from "../../../../core/FilePath.js";
 import { GameAssetType } from "../../GameAssetType.js";
 import { convertTexture2Sampler2D } from "../../../graphics/texture/sampler/convertTexture2Sampler2D.js";
 import { ImageRGBADataAsset } from "./ImageRGBADataAsset.js";
@@ -7,6 +6,7 @@ import { ArrayBufferLoader } from "../ArrayBufferLoader.js";
 import { CodecWithFallback } from "./codec/CodecWithFallback.js";
 import { ThreadedImageDecoder } from "./codec/ThreadedImageDecoder.js";
 import { NativeImageDecoder } from "./codec/NativeImageDecoder.js";
+import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 
 const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 

package/engine/asset/loaders/texture/TextureAssetLoader.js

@@ -1,7 +1,7 @@
 import { AssetLoader } from "../AssetLoader.js";
-import { computeFileExtension } from "../../../../core/FilePath.js";
 import { loadDDSTexture } from "./loadDDSTexture.js";
 import { loadStandardImageTexture } from "./loadStandardImageTexture.js";
+import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 
 export class TextureAssetLoader extends AssetLoader {
     load(path, success, failure, progress) {

package/engine/ecs/storage/BinaryBufferSerializer.js

@@ -55,6 +55,11 @@ class BinaryBufferSerializer {
          * @type {BinarySerializationRegistry}
          */
         this.registry = null;
+        /**
+         *
+         * @type {Engine|null}
+         */
+        this.engine = null;
     }
 
     /**
@@ -92,6 +97,8 @@ class BinaryBufferSerializer {
 
         let i;
 
+        const engine = this.engine;
+
         for (i = 0; i < numSerializableTypes; i++) {
 
             const componentType = serializableComponentTypes[i];

package/engine/graphics/material/composeCompile.js

@@ -13,6 +13,7 @@ export function composeCompile(previous, next) {
     let t1_cache = cache.get(previous);
 
     if (t1_cache === undefined) {
+        // no caches starting from previous
         t1_cache = new WeakMap();
 
         cache.set(previous, t1_cache);
@@ -21,14 +22,11 @@ export function composeCompile(previous, next) {
     let result_function = t1_cache.get(next);
 
     if (result_function === undefined) {
+        // no matching function found for pair, let's create it
+
         // we create a custom function just to be able to name our function, this is because of how three.js caches onBeforeCompile by just turning it into the string, so changing the function name will result in altered cache key
         const f = new Function('previous, next', `return function f${id_counter++}(a,b,c,d){ previous(a,b,c,d); next(a,b,c,d); };`);
 
-        // result_function = function (a, b, c, d) {
-        //     previous(a, b, c, d);
-        //     next(a, b, c, d);
-        // };
-        //
 
         result_function = f(previous, next);
 

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

@@ -1,5 +1,4 @@
 import { AssetTransformer } from "../../../asset/AssetTransformer.js";
-import { computePathDirectory } from "../../../../core/FilePath.js";
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { MicronGeometry } from "../format/MicronGeometry.js";
 import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
@@ -12,6 +11,7 @@ import {
     deserialize_geometry_collection
 } from "../format/serialization/collection/geometry_collection_serialization.js";
 import { GLTF_MICRON_ID_FIELD } from "./GLTF_MICRON_ID_FIELD.js";
+import { computePathDirectory } from "../../../../core/path/computePathDirectory.js";
 
 export const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 
@@ -56,14 +56,13 @@ function ensureProxy(object) {
     }
 }
 
-export class GLTFAssetTransformer extends AssetTransformer {
+class TransformContext {
     /**
      *
-     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} [cache]
+     * @param {AssetManager} assetManager
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
      */
-    constructor(cache) {
-        super();
-
+    constructor(assetManager, cache) {
         /**
          *
          * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>|undefined}
@@ -71,20 +70,6 @@ export class GLTFAssetTransformer extends AssetTransformer {
          */
         this.__cache = cache;
 
-        /**
-         *
-         * @type {AssetManager|null}
-         * @private
-         */
-        this.__am = null;
-
-        /**
-         * Minimum number of polygons required for micron to be used
-         * @type {number}
-         * @private
-         */
-        this.__threshold_polycount = DEFAULT_THRESHOLD_POLYCOUNT;
-
         /**
          *
          * @type {MicronGeometry[]}
@@ -92,31 +77,54 @@ export class GLTFAssetTransformer extends AssetTransformer {
          */
         this.__active_mesh_micron_cache = [];
 
-        /**
-         * @deprecated
-         * Whether override mesh will be created for the asset, this is generally outdated
-         * @type {boolean}
-         * @private
-         */
-        this.__settings_build_override_mesh = false;
+        this.__am = assetManager;
     }
 
     /**
      *
-     * @param {AssetManager|null} am
+     * @param {{userData:{}}} gltf
+     * @param {AssetDescription} ad
      */
-    set assetManager(am) {
-        this.__am = am;
-    }
+    async load_mesh_micron_data(gltf, ad) {
+        // clear active cache
+        this.__active_mesh_micron_cache = [];
 
+        const micron_metadata = gltf.userData.micron;
+
+        if (micron_metadata === undefined) {
+            return;
+        }
+
+        const uri = micron_metadata.geometry_data_uri;
+        if (uri === undefined) {
+            return;
+        }
+
+        const base = computePathDirectory(ad.path);
+
+        let micron_data;
+
+        const micron_path = `${base}/${uri}`;
+
+        try {
+            micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER, { skip_queue: true });
+        } catch (e) {
+            console.error(`Failed to load micron geometry '${micron_path}' referenced in GLTF (will skip): ${e}`);
+            return;
+        }
+
+        // deserialize micron data
+        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
+
+        deserialize_geometry_collection(this.__active_mesh_micron_cache, buffer);
+    }
 
     /**
      * @param {THREE.Object3D} object
      * @param {{asset:AssetDescription}} ctx
      * @return {Promise<void>}
-     * @private
      */
-    async __visitObjectToLoadMicron(object, ctx) {
+    async visitObjectToLoadMicron(object, ctx) {
         if (!object.isMesh) {
             return;
         }
@@ -150,46 +158,59 @@ export class GLTFAssetTransformer extends AssetTransformer {
         }
     }
 
+}
 
+export class GLTFAssetTransformer extends AssetTransformer {
     /**
      *
-     * @param {{userData:{}}} gltf
-     * @param {AssetDescription} ad
-     * @private
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} [cache]
      */
-    async __load_mesh_micron_data(gltf, ad) {
-        // clear active cache
-        this.__active_mesh_micron_cache = [];
-
-        const micron_metadata = gltf.userData.micron;
-
-        if (micron_metadata === undefined) {
-            return;
-        }
-
-        const uri = micron_metadata.geometry_data_uri;
-        if (uri === undefined) {
-            return;
-        }
-
-        const base = computePathDirectory(ad.path);
+    constructor(cache) {
+        super();
 
-        let micron_data;
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>|undefined}
+         * @private
+         */
+        this.__cache = cache;
 
-        const micron_path = `${base}/${uri}`;
+        /**
+         *
+         * @type {AssetManager|null}
+         * @private
+         */
+        this.__am = null;
 
-        try {
-            micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER, { skip_queue: true });
-        } catch (e) {
-            console.error(`Failed to load micron geometry '${micron_path}' referenced in GLTF (will skip): ${e}`);
-            return;
-        }
+        /**
+         * Minimum number of polygons required for micron to be used
+         * @type {number}
+         * @private
+         */
+        this.__threshold_polycount = DEFAULT_THRESHOLD_POLYCOUNT;
 
-        // deserialize micron data
-        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
+        /**
+         *
+         * @type {MicronGeometry[]}
+         * @private
+         */
+        this.__active_mesh_micron_cache = [];
 
-        deserialize_geometry_collection(this.__active_mesh_micron_cache, buffer);
+        /**
+         * @deprecated
+         * Whether override mesh will be created for the asset, this is generally outdated
+         * @type {boolean}
+         * @private
+         */
+        this.__settings_build_override_mesh = false;
+    }
 
+    /**
+     *
+     * @param {AssetManager|null} am
+     */
+    set assetManager(am) {
+        this.__am = am;
     }
 
 
@@ -212,10 +233,12 @@ export class GLTFAssetTransformer extends AssetTransformer {
          */
         const root = source.create();
 
-        await this.__load_mesh_micron_data(source.gltf, asset_description);
+        const context = new TransformContext(this.__am, this.__cache);
+
+        await context.load_mesh_micron_data(source.gltf, asset_description);
 
         // attempt to load existing micron geometries
-        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
+        await async_traverse_three_object(root, context.visitObjectToLoadMicron, context, {
             asset: asset_description
         });
 
@@ -227,6 +250,8 @@ export class GLTFAssetTransformer extends AssetTransformer {
         }
 
         if (this.__settings_build_override_mesh) {
+            console.warn(`Deprecated OVERRIDE_MESH setting is ON, generating override mesh for asset: ${asset_description}`);
+
             const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
             micron_root.boundingSphere = root.boundingSphere;
 

package/engine/graphics/sh3/README.md

@@ -3,3 +3,5 @@ Path tracing ideas:
 * [smallpt](https://www.kevinbeason.com/smallpt/) (100 line c implementation of path tracer)
 * [three path tracer](https://github.com/gkjohnson/three-gpu-pathtracer)
 * http://blog.hvidtfeldts.net/index.php/2015/01/path-tracing-3d-fractals/
+* [Global Illumination and Path Tracing](https://www.scratchapixel.com/lessons/3d-basic-rendering/global-illumination-path-tracing/global-illumination-path-tracing-practical-implementation)
+* [Path Tracing, by Steve Rotenberg](https://cseweb.ucsd.edu/classes/sp17/cse168-a/CSE168_08_PathTracing.pdf)

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

@@ -20,7 +20,6 @@ import {
     UnsignedByteType
 } from "three";
 import { linear_to_sRGB } from "../../../../core/color/linear_to_sRGB.js";
-import { random_in_hemisphere } from "./random_in_hemisphere.js";
 import { sample_triangle_attribute } from "./sample_triangle_attribute.js";
 import { vec3_uint8_to_float } from "./vec3_uint8_to_float.js";
 import { apply_texture_clamping_to_coordinate } from "./apply_texture_clamping_to_coordinate.js";
@@ -29,6 +28,7 @@ import { v3_dot } from "../../../../core/geom/v3_dot.js";
 import { make_one_vector3 } from "./make_one_vector3.js";
 import { transform_normal_m4 } from "./ray_hit_apply_transform.js";
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
+import { getBiasedNormalSample } from "./getBiasedNormalSample.js";
 
 /*
  Ray hit data layout:
@@ -526,10 +526,6 @@ export class PathTracer {
                 break;
             }
 
-
-            // irradiance[0] += m;
-            // irradiance[1] += m;
-            // irradiance[2] += m;
             this.sample_material(tmp_0, trace_result);
 
             // adjust normal on the hit
@@ -539,8 +535,7 @@ export class PathTracer {
             // reflect ray
             array_copy(trace_result, 0, _ray_0, 0, 3);
 
-            // getBiasedNormalSample(_ray, 3, tmp, 3, 1, random);
-            random_in_hemisphere(random, _ray_0, 3, tmp_0, 3);
+            getBiasedNormalSample(_ray_0, 3, tmp_0, 3, 1, random);
 
             // accumulate
             vec3.multiply(irradiance, irradiance, tmp_0);
@@ -555,14 +550,6 @@ export class PathTracer {
             vec3.multiply(irradiance, irradiance, tmp_1);
         }
 
-        //
-        // if (got_emission === false) {
-        //     // no light source was hit, propagate shadow(darkness) along the ray
-        //     irradiance[0] = 0;
-        //     irradiance[1] = 0;
-        //     irradiance[2] = 0;
-        // }
-
         array_copy(irradiance, 0, out, 0, 3);
     }
 }

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

@@ -8,7 +8,7 @@
  * @param {number} power
  * @param {function():number} random
  */
-function getBiasedNormalSample(out, out_offset, normal, normal_offset, power, random) {
+export function getBiasedNormalSample(out, out_offset, normal, normal_offset, power, random) {
     const dir_x = normal[normal_offset];
     const dir_y = normal[normal_offset + 1];
     const dir_z = normal[normal_offset + 2];

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({
@@ -185,9 +189,10 @@ function promise_gltf(url) {
  * @param {PathTracer} pt
  * @param {THREE.Camera} camera
  * @param {string} url
+ * @param zoom
  * @return {Promise<void>}
  */
-async function prepare_scene_gltf(pt, camera, url) {
+async function prepare_scene_gltf(pt, camera, url, zoom = 1) {
     const gltf = await promise_gltf(url);
 
 
@@ -220,7 +225,7 @@ async function prepare_scene_gltf(pt, camera, url) {
 
     camera.position.set(1, 1.3, 1)
         .normalize()
-        .multiplyScalar(sphere.radius * 2.6);
+        .multiplyScalar(sphere.radius * 2.6 * (1 / zoom));
 
     camera.lookAt(sphere.center);
 }
@@ -459,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];
@@ -509,12 +514,12 @@ 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_rtiow(pt, camera);
+    await prepare_scene_sphere_01(pt, camera);
     // await prepare_scene_gltf(pt, camera, path);
 
     pt.build();

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,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);
+        });
+    }
+}