@woosh/meep-engine 2.33.64 → 2.33.69

package/engine/graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js

@@ -0,0 +1,10 @@
+export const FULL_SCREEN_QUAD_VERTEX_SHADER = `        
+        varying vec2 vUv;
+
+        void main() {
+
+            vUv = uv;
+                
+            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
+            
+        }`;

package/engine/graphics/filter/ImageFilter.js

@@ -5,13 +5,14 @@
 
 import { LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
+import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../FULL_SCREEN_QUAD_VERTEX_SHADER.js";
 
 /**
  *
  * @param {WebGLRenderer} renderer
  * @param {number} width
  * @param {number} height
- * @param {{vertexShader:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
+ * @param {{vertexShader?:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
  * @param {Uint8Array} [destination]
  * @return {{array: Uint8Array, renderer: WebGLRenderer}}
  */
@@ -34,9 +35,12 @@ function processTexture(
     scene.add(camera);
 
     //make a quad to render
-    const material = new ShaderMaterial(processShader);
+    const material = new ShaderMaterial(Object.assign({ vertexShader: FULL_SCREEN_QUAD_VERTEX_SHADER }, processShader));
+
     material.lights = false;
     material.fog = false;
+    material.uniformsNeedUpdate = true;
+    material.needsUpdate = true;
 
     const quad = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, material);
 

package/engine/graphics/geometry/buffered/query/ClippingPlaneContainmentComputingVisitor.js

@@ -79,21 +79,32 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
 
             const index3 = index * 3;
 
-            const a = this.__buffer_indices[index3] * 3;
-            const b = this.__buffer_indices[index3 + 1] * 3;
-            const c = this.__buffer_indices[index3 + 2] * 3;
+            const indices = this.__buffer_indices;
 
-            const ax = this.__buffer_vertices[a];
-            const ay = this.__buffer_vertices[a + 1];
-            const az = this.__buffer_vertices[a + 2];
+            const a = indices[index3];
+            const b = indices[index3 + 1];
+            const c = indices[index3 + 2];
 
-            const bx = this.__buffer_vertices[b];
-            const by = this.__buffer_vertices[b + 1];
-            const bz = this.__buffer_vertices[b + 2];
+            const vertices = this.__buffer_vertices;
 
-            const cx = this.__buffer_vertices[c];
-            const cy = this.__buffer_vertices[c + 1];
-            const cz = this.__buffer_vertices[c + 2];
+            const stride = this.__buffer_vertex_stride;
+            const offset = this.__buffer_position_offset;
+
+            const a_address = a * stride + offset;
+            const b_address = b * stride + offset;
+            const c_address = c * stride + offset;
+
+            const ax = vertices[a_address];
+            const ay = vertices[a_address + 1];
+            const az = vertices[a_address + 2];
+
+            const bx = vertices[b_address];
+            const by = vertices[b_address + 1];
+            const bz = vertices[b_address + 2];
+
+            const cx = vertices[c_address];
+            const cy = vertices[c_address + 1];
+            const cz = vertices[c_address + 2];
 
             for (let i = 0; i < plane_count; i++) {
                 const plane = planes[i];
@@ -108,15 +119,9 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
                     plane_normal_y,
                     plane_normal_z,
                     plane_constant,
-                    ax,
-                    ay,
-                    az,
-                    bx,
-                    by,
-                    bz,
-                    cx,
-                    cy,
-                    cz
+                    ax, ay, az,
+                    bx, by, bz,
+                    cx, cy, cz
                 );
 
                 if (side === -3) {
@@ -163,12 +168,8 @@ export class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcc
                     plane_normal_z,
                     plane_constant,
 
-                    x0,
-                    y0,
-                    z0,
-                    x1,
-                    y1,
-                    z1
+                    x0, y0, z0,
+                    x1, y1, z1
                 );
 
                 if (side === -2) {

package/engine/graphics/geometry/buffered/query/GeometryVisitor.js

@@ -1,6 +1,6 @@
 import { IndexedBinaryBVHVisitor } from "../../../../../core/bvh2/binary/IndexedBinaryBVHVisitor.js";
 
-export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
+export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor {
     constructor() {
         super();
 
@@ -25,6 +25,20 @@ export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
          */
         this.__buffer_vertices = null;
 
+        /**
+         *
+         * @type {number}
+         * @protected
+         */
+        this.__buffer_vertex_stride = 3;
+
+        /**
+         *
+         * @type {number}
+         * @protected
+         */
+        this.__buffer_position_offset = 0;
+
         /**
          * @protected
          * @type {IndexedBinaryBVH}
@@ -47,7 +61,20 @@ export class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor{
         this.geometry = geometry;
 
         this.__buffer_indices = geometry.getIndex().array;
-        this.__buffer_vertices = geometry.getAttribute('position').array;
+
+        const position_attribute = geometry.getAttribute('position');
+
+        if (position_attribute.isInterleavedBufferAttribute) {
+            const data = position_attribute.data;
+
+            this.__buffer_vertices = data.array;
+            this.__buffer_vertex_stride = data.stride;
+            this.__buffer_position_offset = position_attribute.offset;
+        } else {
+            this.__buffer_vertices = position_attribute.array;
+            this.__buffer_vertex_stride = 3;
+            this.__buffer_position_offset = 0;
+        }
     }
 
 }

package/engine/graphics/geometry/buffered/query/RaycastNearestHitComputingVisitor.js

@@ -96,21 +96,32 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
 
             const index3 = index * 3;
 
-            const a = this.__buffer_indices[index3] * 3;
-            const b = this.__buffer_indices[index3 + 1] * 3;
-            const c = this.__buffer_indices[index3 + 2] * 3;
+            const indices = this.__buffer_indices;
 
-            const ax = this.__buffer_vertices[a];
-            const ay = this.__buffer_vertices[a + 1];
-            const az = this.__buffer_vertices[a + 2];
+            const a = indices[index3];
+            const b = indices[index3 + 1];
+            const c = indices[index3 + 2];
 
-            const bx = this.__buffer_vertices[b];
-            const by = this.__buffer_vertices[b + 1];
-            const bz = this.__buffer_vertices[b + 2];
+            const vertices = this.__buffer_vertices;
 
-            const cx = this.__buffer_vertices[c];
-            const cy = this.__buffer_vertices[c + 1];
-            const cz = this.__buffer_vertices[c + 2];
+            const stride = this.__buffer_vertex_stride;
+            const offset = this.__buffer_position_offset;
+
+            const a_address = a * stride + offset;
+            const b_address = b * stride + offset;
+            const c_address = c * stride + offset;
+
+            const ax = vertices[a_address];
+            const ay = vertices[a_address + 1];
+            const az = vertices[a_address + 2];
+
+            const bx = vertices[b_address];
+            const by = vertices[b_address + 1];
+            const bz = vertices[b_address + 2];
+
+            const cx = vertices[c_address];
+            const cy = vertices[c_address + 1];
+            const cz = vertices[c_address + 2];
 
             if (computeTriangleRayIntersection(
                 this.__temp_hit,
@@ -120,15 +131,9 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
                 rayDirection.x,
                 rayDirection.y,
                 rayDirection.z,
-                ax,
-                ay,
-                az,
-                bx,
-                by,
-                bz,
-                cx,
-                cy,
-                cz
+                ax, ay, az,
+                bx, by, bz,
+                cx, cy, cz
             )) {
                 const d = this.__temp_hit.position.distanceSqrTo(rayOrigin);
 
@@ -154,12 +159,8 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
             const z1 = data[address + 5];
 
             return intersectRay(
-                x0,
-                y0,
-                z0,
-                x1,
-                y1,
-                z1,
+                x0, y0, z0,
+                x1, y1, z1,
 
                 rayOrigin.x,
                 rayOrigin.y,

package/engine/graphics/micron/MICRON_GEOMETRY_FIELD.js

@@ -0,0 +1 @@
+export const MICRON_GEOMETRY_FIELD = '@micron_geometry';

package/engine/graphics/micron/MICRON_URI_FIELD.js

@@ -0,0 +1 @@
+export const MICRON_URI_FIELD = '@micron_path';

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -4,6 +4,7 @@ import { computeGeometryEquality } from "../../asset/loaders/geometry/geometry/c
 import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
 import { ThreeMicronMesh } from "./format/ThreeMicronMesh.js";
 import { AsyncMapWrapper } from "../../../core/collection/map/AsyncMapWrapper.js";
+import { MICRON_GEOMETRY_FIELD } from "./MICRON_GEOMETRY_FIELD.js";
 
 /**
  *
@@ -19,7 +20,6 @@ const pending_cache = new HashMap({
     keyEqualityFunction: computeGeometryEquality
 });
 
-
 /**
  *
  * @param {THREE.Object3D} object
@@ -36,10 +36,22 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
      * @returns {MicronGeometry}
      */
     async function obtain_geometry(g) {
-        const existing = await micron_cache.get(g);
+        const attached_micron = g[MICRON_GEOMETRY_FIELD];
 
-        if (existing !== undefined && existing !== null) {
-            return existing;
+        if (attached_micron !== undefined && attached_micron.isMicronGeometry) {
+            // micron geometry is already attached, use it
+            return attached_micron;
+        }
+
+        const cached_micron = await micron_cache.get(g);
+
+
+        if (cached_micron !== undefined && cached_micron !== null) {
+
+            // set proxy
+            cached_micron.proxy = g;
+
+            return cached_micron;
         }
 
         const pending = pending_cache.get(g);
@@ -54,8 +66,14 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
 
         promises.push(micron_geometry_promise);
 
+        /**
+         *
+         * @type {MicronGeometry}
+         */
         const micron_geometry = await micron_geometry_promise;
 
+        micron_geometry.proxy = g;
+
         await micron_cache.set(g, micron_geometry);
 
         return micron_geometry;
@@ -90,7 +108,15 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
             && !mesh.isSkinnedMesh // skinned meshes not supported
         ) {
 
-            const micronGeometry = await obtain_geometry(mesh.geometry);
+            let micronGeometry;
+            try {
+                micronGeometry = await obtain_geometry(mesh.geometry);
+            } catch (e) {
+                console.error(`Failed to convert geometry to micron, skipping : ${e}`);
+
+                // return original
+                return mesh;
+            }
 
             const micron_mesh = new ThreeMicronMesh(micronGeometry, mesh.material);
 

package/engine/graphics/micron/format/MicronGeometry.js

@@ -117,3 +117,9 @@ export class MicronGeometry {
         return this.__patches[id];
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+MicronGeometry.prototype.isMicronGeometry = true;

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

@@ -13,6 +13,13 @@ import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteH
 import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";
 import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
 import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper.js";
+import { async_traverse_three_object } from "../../../asset/loaders/async_traverse_three_object.js";
+import { computePathDirectory } from "../../../../core/FilePath.js";
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { MicronGeometry } from "../format/MicronGeometry.js";
+import { ArrayBufferLoader } from "../../../asset/loaders/ArrayBufferLoader.js";
+import { MICRON_URI_FIELD } from "../MICRON_URI_FIELD.js";
+import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
 
 /**
  *
@@ -20,6 +27,7 @@ import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper
  */
 const STORAGE_KEY = '@plugin/virtual-geometry-micron/geometry-cache';
 
+const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 
 class GLTFAssetTransformer extends AssetTransformer {
     /**
@@ -35,17 +43,100 @@ class GLTFAssetTransformer extends AssetTransformer {
          * @private
          */
         this.__cache = cache;
+
+        /**
+         *
+         * @type {AssetManager|null}
+         * @private
+         */
+        this.__am = null;
+
+        /**
+         *
+         * @type {MicronGeometryBinarySerializationAdapter}
+         * @private
+         */
+        this.__serde = new MicronGeometryBinarySerializationAdapter();
     }
 
-    async transform(source) {
+    /**
+     *
+     * @param {AssetManager|null} am
+     */
+    set assetManager(am) {
+        this.__am = am;
+    }
+
+
+    /**
+     * @param {THREE.Object3D} object
+     * @param {{asset:AssetDescription}} ctx
+     * @return {Promise<void>}
+     * @private
+     */
+    async __visitObjectToLoadMicron(object, ctx) {
+        if (!object.isMesh) {
+            return;
+        }
+
+        /**
+         * @type {THREE.BufferGeometry}
+         */
+        const geometry = object.geometry;
+
+        const micron_uri = geometry.userData[MICRON_URI_FIELD];
+
+        if (typeof micron_uri !== "string") {
+            return;
+        }
+
+
+        /**
+         * @type {AssetDescription}
+         */
+        const ad = ctx.asset;
+
+        const base = computePathDirectory(ad.path);
+
+        const micron_data = await this.__am.promise(`${base}/${micron_uri}`, ASSET_TYPE_ARRAY_BUFFER);
+
+        // deserialize micron data
+        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
+        const micron_geometry = new MicronGeometry();
+
+        this.__serde.deserialize(buffer, micron_geometry);
+
+        // set proxy for raycasting
+        micron_geometry.proxy = geometry;
+
+        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
+    }
+
+
+    /**
+     *
+     * @param {Asset} source
+     * @param asset_description
+     * @return {Promise<Asset>}
+     */
+    async transform(source, asset_description) {
         const animationClips = source.animations;
+
         if (animationClips !== undefined && animationClips.length > 0) {
             // not suitable
             return source;
         }
 
+        /**
+         * @type {THREE.Object3D}
+         */
         const root = source.create();
 
+        // attempt to load existing micron geometries
+        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
+            asset: asset_description
+        });
+
         const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
         micron_root.boundingSphere = root.boundingSphere;
 
@@ -117,7 +208,7 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         /**
          *
-         * @type {AssetTransformer}
+         * @type {GLTFAssetTransformer}
          * @private
          */
         this.__asset_transformer = new GLTFAssetTransformer(this.__cache);
@@ -180,8 +271,17 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         const engine = this.engine;
 
-        engine.assetManager.registerTransformer("model/gltf", this.__asset_transformer);
-        engine.assetManager.registerTransformer("model/gltf+json", this.__asset_transformer);
+        const am = engine.assetManager;
+
+        // ensure that "arraybuffer" asset loader is present
+        if (am.getLoaderByType(ASSET_TYPE_ARRAY_BUFFER) === undefined) {
+            am.registerLoader(ASSET_TYPE_ARRAY_BUFFER, new ArrayBufferLoader());
+        }
+
+        this.__asset_transformer.assetManager = am;
+
+        am.registerTransformer("model/gltf", this.__asset_transformer);
+        am.registerTransformer("model/gltf+json", this.__asset_transformer);
 
         /**
          *
@@ -207,8 +307,12 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         this.__persisted_geometry.detach_storage();
 
-        engine.assetManager.unregisterTransformer("model/gltf", this.__asset_transformer);
-        engine.assetManager.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+        const am = engine.assetManager;
+
+        am.unregisterTransformer("model/gltf", this.__asset_transformer);
+        am.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+
+        this.__asset_transformer.assetManager = null;
 
         const ge = engine.graphics;
 

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

@@ -433,7 +433,9 @@ async function sample_scene_nam(engine) {
         "distanceMax": 1000
     });
 
-    load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
+    // load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
+    load_model('moicon/20_Dec_2021_Nammo/with_assets_micron_conveted/model.gltf', ecd)
+    // load_model('moicon/micron_container/model.gltf', ecd)
 
     const P_SIZE_SMALL = 0.15;
     const P_SIZE_MEDIUM = 0.6;