@woosh/meep-engine 2.33.56 → 2.33.60

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

@@ -3,6 +3,57 @@ import { VGThreeRenderer } from "../render/v1/VGThreeRenderer.js";
 import { RenderLayer } from "../../render/layers/RenderLayer.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
 import { SOURCE_RENDER_LAYER_PROPERTY } from "../../render/visibility/VisibilityComputer.js";
+import { AssetTransformer } from "../../../asset/AssetTransformer.js";
+import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
+import { Cache } from "../../../../core/cache/Cache.js";
+import { computeGeometryHash } from "../../../asset/loaders/geometry/geometry/computeGeometryHash.js";
+import { computeGeometryEquality } from "../../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
+import { CachedAsyncMap } from "../../../../core/collection/map/CachedAsyncMap.js";
+import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteHashMap.js";
+import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";
+import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
+import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper.js";
+
+/**
+ *
+ * @type {string}
+ */
+const STORAGE_KEY = '@plugin/virtual-geometry-micron/geometry-cache';
+
+
+class GLTFAssetTransformer extends AssetTransformer {
+    /**
+     *
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
+     */
+    constructor(cache) {
+        super();
+
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @private
+         */
+        this.__cache = cache;
+    }
+
+    async transform(source) {
+        const animationClips = source.animations;
+        if (animationClips !== undefined && animationClips.length > 0) {
+            // not suitable
+            return source;
+        }
+
+        const root = source.create();
+
+        const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
+        micron_root.boundingSphere = root.boundingSphere;
+
+        source.override_mesh = micron_root;
+
+        return source;
+    }
+}
 
 export class MicronRenderPlugin extends EnginePlugin {
     constructor() {
@@ -37,6 +88,40 @@ export class MicronRenderPlugin extends EnginePlugin {
         });
 
         this.__view_observers = new Map();
+
+        /**
+         *
+         * @type {AsyncRemoteHashMap}
+         * @private
+         */
+        this.__persisted_geometry = new AsyncRemoteHashMap({
+            keyHashFunction: computeGeometryHash,
+            keyEqualityFunction: computeGeometryEquality,
+            keySerializationAdapter: new BufferGeometrySerializationAdapter(),
+            valueSerializationAdapter: new MicronGeometryBinarySerializationAdapter(),
+            storageKeyPrefix: STORAGE_KEY,
+
+        });
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @private
+         */
+        this.__cache = new CachedAsyncMap(
+            new AsyncMapWrapper(new Cache({
+                keyHashFunction: computeGeometryHash,
+                keyEqualityFunction: computeGeometryEquality
+            })),
+            this.__persisted_geometry
+        );
+
+        /**
+         *
+         * @type {AssetTransformer}
+         * @private
+         */
+        this.__asset_transformer = new GLTFAssetTransformer(this.__cache);
+
     }
 
     /**
@@ -87,13 +172,22 @@ export class MicronRenderPlugin extends EnginePlugin {
         view.on.preRender.remove(observer);
     }
 
+    __ingest_cache() {
+        this.engine.storage.lo
+    }
+
     async startup() {
 
+        const engine = this.engine;
+
+        engine.assetManager.registerTransformer("model/gltf", this.__asset_transformer);
+        engine.assetManager.registerTransformer("model/gltf+json", this.__asset_transformer);
+
         /**
          *
          * @type {GraphicsEngine}
          */
-        const ge = this.engine.graphics;
+        const ge = engine.graphics;
 
         ge.layers.add(this.__micron_render_layer);
 
@@ -101,13 +195,22 @@ export class MicronRenderPlugin extends EnginePlugin {
         ge.views.elements.on.removed.add(this.__handle_view_removed, this);
 
         // link all views
-        ge.views.elements.forEach(this.__handle_view_added,this);
+        ge.views.elements.forEach(this.__handle_view_added, this);
+
+        this.__persisted_geometry.attach_storage(engine.storage);
 
         await super.startup();
     }
 
     async shutdown() {
-        const ge = this.engine.graphics;
+        const engine = this.engine;
+
+        this.__persisted_geometry.detach_storage();
+
+        engine.assetManager.unregisterTransformer("model/gltf", this.__asset_transformer);
+        engine.assetManager.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+
+        const ge = engine.graphics;
 
         ge.layers.remove(this.__micron_render_layer);
 
@@ -115,7 +218,7 @@ export class MicronRenderPlugin extends EnginePlugin {
         ge.views.elements.on.removed.remove(this.__handle_view_removed, this);
 
         // clear all observer
-        ge.views.elements.forEach(this.__handle_view_removed,this);
+        ge.views.elements.forEach(this.__handle_view_removed, this);
 
         await super.shutdown();
     }

package/engine/graphics/micron/plugin/serialization/BufferGeometrySerializationAdapter.js

@@ -0,0 +1,176 @@
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { BufferAttribute, BufferGeometry } from "three";
+
+function typed_array_to_enum(array) {
+    if (array instanceof Uint8Array) {
+        return 0;
+    } else if (array instanceof Uint16Array) {
+        return 1;
+    } else if (array instanceof Uint32Array) {
+        return 2;
+    } else if (array instanceof Uint8Array) {
+        return 3;
+    } else if (array instanceof Uint16Array) {
+        return 4;
+    } else if (array instanceof Uint32Array) {
+        return 5;
+    } else if (array instanceof Float32Array) {
+        return 6;
+    } else if (array instanceof Float64Array) {
+        return 7;
+    } else {
+        throw new Error('Unsupported array type');
+    }
+}
+
+function marker_to_typed_array_constructor(marker) {
+    switch (marker) {
+        case 0:
+            return Uint8Array;
+        case 1:
+            return Uint16Array;
+        case 2:
+            return Uint32Array;
+        case 3:
+            return Int8Array;
+        case 4:
+            return Int16Array;
+        case 5:
+            return Int32Array;
+        case 6:
+            return Float32Array;
+        case 7:
+            return Float64Array;
+        default:
+            throw new Error('Unsupported marker');
+    }
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {Uint8Array|Float32Array|ArrayLike<number>} value
+ */
+function write_typed_array(buffer, value) {
+
+    buffer.writeUint8(typed_array_to_enum(value));
+    buffer.writeUintVar(value.byteLength);
+
+    const data = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    buffer.writeBytes(data, 0, value.byteLength);
+}
+
+function read_typed_array(buffer) {
+    const type_marker = buffer.readUint8();
+    const byte_length = buffer.readUintVar();
+
+    const array = new Uint8Array(byte_length);
+
+    buffer.readBytes(array, 0, byte_length);
+
+    // re-interpret bytes
+    const TypedArray = marker_to_typed_array_constructor(type_marker);
+
+    return new TypedArray(array.buffer, 0);
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {BufferAttribute} value
+ */
+function write_attribute(buffer, value) {
+    buffer.writeUTF8String(value.name);
+    buffer.writeUintVar(value.itemSize);
+    buffer.writeUint8(value.normalized ? 1 : 0);
+    buffer.writeUint32(value.usage);
+
+    write_typed_array(buffer, value.array);
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @returns {BufferAttribute}
+ */
+function read_attribute(buffer) {
+    const name = buffer.readUTF8String();
+    const itemSize = buffer.readUintVar();
+    const normalized = buffer.readUint8() !== 0;
+    const usage = buffer.readUint32();
+
+    const array = read_typed_array(buffer);
+
+    const attribute = new BufferAttribute(array, itemSize, normalized);
+
+    attribute.usage = usage;
+    attribute.name = name;
+
+    return attribute;
+}
+
+export class BufferGeometrySerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = BufferGeometry;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {BufferGeometry} value
+     */
+    serialize(buffer, value) {
+        // write index if one exists
+        const index = value.getIndex();
+        if (index === null) {
+            buffer.writeUint8(0);
+        } else {
+            buffer.writeUint8(1);
+
+            write_attribute(buffer, index);
+        }
+
+        const attributes = value.attributes;
+        const attribute_keys = Object.keys(attributes);
+
+        const attribute_count = attribute_keys.length;
+        buffer.writeUintVar(attribute_count);
+
+        for (let i = 0; i < attribute_count; i++) {
+            const attribute_key = attribute_keys[i];
+
+            buffer.writeUTF8String(attribute_key);
+
+            const attribute = attributes[attribute_key];
+
+            write_attribute(buffer, attribute);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {BufferGeometry} value
+     */
+    deserialize(buffer, value) {
+        const index_flag = buffer.readUint8();
+
+        if (index_flag !== 0) {
+            value.setIndex(read_attribute(buffer));
+        } else {
+            value.setIndex(null);
+        }
+
+        const attribute_count = buffer.readUintVar();
+
+        for (let i = 0; i < attribute_count; i++) {
+            const attribute_key = buffer.readUTF8String();
+
+            const attribute = read_attribute(buffer);
+
+            value.setAttribute(attribute_key, attribute);
+        }
+    }
+}

package/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.d.ts

@@ -19,6 +19,8 @@ export class ParticleVolume {
 
     from(args?: Args): void
 
+    fromJSON(json: any): void
+
     build(): void
 
     readonly attributes: Attributes

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -132,6 +132,7 @@ function makeConfig(engine) {
 
     // Plugins
     config.addPlugin(MicronRenderPlugin);
+    config.addPlugin(AmbientOcclusionPostProcessEffect);
 
 
     // Knowledge
@@ -159,8 +160,6 @@ async function init(harness) {
     await engine.graphics.loadEnvironmentMap(buildCubeURLs('data/textures/cubemaps/hip_miramar/32/', '.png'));
 
 
-    await engine.plugins.acquire(AmbientOcclusionPostProcessEffect);
-
     await harness.initialize();
 
     main(engine);

package/engine/graphics/render/buffer/simple-fx/DepthLimitedBlur.js

@@ -3,7 +3,7 @@ import { BlurShaderUtils, DepthLimitedBlurShader } from "three/examples/jsm/shad
 import { renderScreenSpace } from "../../utils/renderScreenSpace.js";
 
 export class DepthLimitedBlur {
-    constructor({ format = RGBAFormat }) {
+    constructor({ format = RGBAFormat, radius = 8 }) {
 
         /**
          *
@@ -41,7 +41,7 @@ export class DepthLimitedBlur {
 
         this.__depth_cutoff = 0.01;
 
-        this.__blur_radius = 8;
+        this.__blur_radius = radius;
         this.__blur_std_dev = 4;
     }
 

package/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js

@@ -33,7 +33,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         // AO parameters
         const uniforms = this.__material.uniforms;
         uniforms.bias.value = 0.5;
-        uniforms.intensity.value = 1;
+        uniforms.intensity.value = 2;
 
         uniforms.kernelRadius.value = 30;
         uniforms.minResolution.value = 0;

package/engine/graphics/render/buffer/simple-fx/ao/SAOShader.js

@@ -16,7 +16,6 @@ const SAOShader = {
     uniforms: {
 
         'tDepth': { value: null },
-        'tDiffuse': { value: null },
         'tNormal': { value: null },
         'size': { value: new Vector2(512, 512) },
 
@@ -47,10 +46,6 @@ const SAOShader = {
 
 		varying vec2 vUv;
 
-		#if DIFFUSE_TEXTURE == 1
-		uniform sampler2D tDiffuse;
-		#endif
-
 		uniform sampler2D tDepth;
 
 		#if NORMAL_TEXTURE == 1
@@ -75,14 +70,6 @@ const SAOShader = {
 		
 		out float out_occlusion;
 
-		vec4 getDefaultColor( const in vec2 screenPosition ) {
-			#if DIFFUSE_TEXTURE == 1
-			    return texture2D( tDiffuse, vUv );
-			#else
-			    return vec4( 1.0 );
-			#endif
-		}
-
 		float getDepth( const in vec2 screenPosition ) {
 			#if DEPTH_PACKING == 1
 			return unpackRGBAToDepth( texture2D( tDepth, screenPosition ) );
@@ -114,7 +101,14 @@ const SAOShader = {
 			return normalize( cross( dFdx( viewPosition ), dFdy( viewPosition ) ) );
 			#endif
 		}
-
+		
+		// Non-sin based hash function, fast and has good randomness
+        float hash12(vec2 p){
+            vec3 p3  = fract(vec3(p.xyx) * .1031);
+            p3 += dot(p3, p3.yzx + 33.33);
+            return fract((p3.x + p3.y) * p3.z);
+        }
+        
 		float minResolutionMultipliedByCameraFar;
 
 		float getOcclusion( const in vec3 centerViewPosition, const in vec3 centerViewNormal, const in vec3 sampleViewPosition ) {
@@ -139,7 +133,7 @@ const SAOShader = {
 			vec3 centerViewNormal = getViewNormal( centerViewPosition, vUv );
 
 			// jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
-			float angle = rand( vUv + randomSeed ) * PI2;
+			float angle = hash12( vUv + randomSeed ) * PI2;
 			vec2 radius = vec2( kernelRadius * INV_NUM_SAMPLES ) / size;
 
 			float occlusionSum = 0.0;

package/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -83,6 +83,7 @@ import { ShadedGeometrySystem } from "../../../ecs/mesh-v2/ShadedGeometrySystem.
 import { FogOfWar } from "../../../../ecs/fow/FogOfWar.js";
 import { FogOfWarRevealer } from "../../../../ecs/fow/FogOfWarRevealer.js";
 import Team from "../../../../../../model/game/ecs/component/Team.js";
+import { AmbientOcclusionPostProcessEffect } from "../../buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
 
 const geo_light_center_octahedron = new BoxBufferGeometry(0.1, 0.1, 0.1);
 const engineHarness = new EngineHarness();
@@ -163,6 +164,7 @@ function makeConfig(engine) {
 
     // Plugins
     config.addPlugin(ForwardPlusRenderingPlugin);
+    config.addPlugin(AmbientOcclusionPostProcessEffect);
     // config.addPlugin(MicronRenderPlugin);
 
     // Knowledge

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_texture.js

@@ -116,14 +116,16 @@ export function query_bvh_frustum_from_texture(
                 const radius = source_data[light_address + 3];
 
                 if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
+                    // cull
                     continue;
                 }
+
             } else if (light_type === 3) {
                 // decal
                 debugger;
 
             } else {
-                throw new Error('Unsupported light type');
+                throw new Error(`Unsupported light type ${light_type}`);
             }
 
             // write to output

package/engine/graphics/shadows/ShadowMapRenderer.js

@@ -95,12 +95,18 @@ export class ShadowMapRenderer {
 
         this.onBeforeRender.send3(renderer, shadow_camera, scene);
 
-        renderer.render(scene, shadow_camera);
-
-        if (renderer.shadowMap.type === VSMShadowMap) {
-            this.__do_vsm_pass(shadow);
+        if (target.width <= 0 || target.height <= 0) {
+            // no point in rendering
+        } else {
+            // do the draw
+            renderer.render(scene, shadow_camera);
+
+            if (renderer.shadowMap.type === VSMShadowMap) {
+                this.__do_vsm_pass(shadow);
+            }
         }
 
+
         // restore state
         renderer.setRenderTarget(__rt, __acf, __aml);
         renderer.setScissorTest(__scissor);

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -570,6 +570,10 @@ Sampler2D.prototype.sampleChannelBicubic = function (x, y, channel) {
     const x1 = clamp(x, 0, x_max) | 0;
     const y1 = clamp(y, 0, y_max) | 0;
 
+    // fractional texel position (from the nearest low texel)
+    const xd = x - x1;
+    const yd = y - y1;
+
     const x0 = max2(0, x1 - 1);
     const y0 = max2(0, y1 - 1);
 
@@ -595,61 +599,36 @@ Sampler2D.prototype.sampleChannelBicubic = function (x, y, channel) {
     const col2_offset = x2 * itemSize;
     const col3_offset = x3 * itemSize;
 
-    // compute sample addresses
-    const i0 = row0_address + col0_offset;
-    const i1 = row0_address + col1_offset;
-    const i2 = row0_address + col2_offset;
-    const i3 = row0_address + col3_offset;
-
-    const j0 = row1_address + col0_offset;
-    const j1 = row1_address + col1_offset;
-    const j2 = row1_address + col2_offset;
-    const j3 = row1_address + col3_offset;
+    // read samples
+    const vi0 = data[row0_address + col0_offset];
+    const vi1 = data[row0_address + col1_offset];
+    const vi2 = data[row0_address + col2_offset];
+    const vi3 = data[row0_address + col3_offset];
 
-    const k0 = row2_address + col0_offset;
-    const k1 = row2_address + col1_offset;
-    const k2 = row2_address + col2_offset;
-    const k3 = row2_address + col3_offset;
+    const vj0 = data[row1_address + col0_offset];
+    const vj1 = data[row1_address + col1_offset];
+    const vj2 = data[row1_address + col2_offset];
+    const vj3 = data[row1_address + col3_offset];
 
-    const l0 = row3_address + col0_offset;
-    const l1 = row3_address + col1_offset;
-    const l2 = row3_address + col2_offset;
-    const l3 = row3_address + col3_offset;
+    const vk0 = data[row2_address + col0_offset];
+    const vk1 = data[row2_address + col1_offset];
+    const vk2 = data[row2_address + col2_offset];
+    const vk3 = data[row2_address + col3_offset];
 
-    // read samples
-    const vi0 = data[i0];
-    const vi1 = data[i1];
-    const vi2 = data[i2];
-    const vi3 = data[i3];
-
-    const vj0 = data[j0];
-    const vj1 = data[j1];
-    const vj2 = data[j2];
-    const vj3 = data[j3];
-
-    const vk0 = data[k0];
-    const vk1 = data[k1];
-    const vk2 = data[k2];
-    const vk3 = data[k3];
-
-    const vl0 = data[l0];
-    const vl1 = data[l1];
-    const vl2 = data[l2];
-    const vl3 = data[l3];
+    const vl0 = data[row3_address + col0_offset];
+    const vl1 = data[row3_address + col1_offset];
+    const vl2 = data[row3_address + col2_offset];
+    const vl3 = data[row3_address + col3_offset];
 
-    const xd = x - x1;
-    const yd = y - y1;
 
-    // perform filtering in X
+    // perform filtering in X (rows)
     const s0 = bicubic_terp(xd, vi0, vi1, vi2, vi3);
     const s1 = bicubic_terp(xd, vj0, vj1, vj2, vj3);
     const s2 = bicubic_terp(xd, vk0, vk1, vk2, vk3);
     const s3 = bicubic_terp(xd, vl0, vl1, vl2, vl3);
 
-    // filter in Y
-    const result = bicubic_terp(yd, s0, s1, s2, s3);
-
-    return result;
+    // filter in Y (columns)
+    return bicubic_terp(yd, s0, s1, s2, s3);
 };
 
 /**

package/engine/intelligence/behavior/ecs/WaitForEventBehavior.js

@@ -1,6 +1,7 @@
 import { EntityBehavior } from "./EntityBehavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { assert } from "../../../../core/assert.js";
 
 export class WaitForEventBehavior extends EntityBehavior {
     constructor() {
@@ -26,6 +27,8 @@ export class WaitForEventBehavior extends EntityBehavior {
     }
 
     fromJSON({ event, target = -1 }) {
+        assert.isString(event, 'event');
+
         this.event = event;
         this.target = target;
     }

package/engine/save/storage/IndexedDBStorage.js

@@ -1,12 +1,18 @@
 import Storage from "../Storage.js";
 import { IndexedDBTransactionMode } from "./IndexedDBTransactionMode.js";
+import { assert } from "../../../core/assert.js";
 
 const MAIN_STORE_NAME = 'main';
 
+/**
+ * TODO add QuotaExceededError handling
+ */
 export class IndexedDBStorage extends Storage {
     constructor(name) {
         super();
 
+        assert.isString(name, 'name');
+
         /**
          *
          * @param {IDBDatabase} database
@@ -43,7 +49,7 @@ export class IndexedDBStorage extends Storage {
 
                 const objectStore = transaction.objectStore(MAIN_STORE_NAME);
 
-                const idbRequest = objectStore.delete( key);
+                const idbRequest = objectStore.delete(key);
 
                 if (typeof resolve === "function") {
 
@@ -60,6 +66,7 @@ export class IndexedDBStorage extends Storage {
                     });
 
                 }
+
             });
 
         if (typeof reject === "function") {

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