@woosh/meep-engine 2.33.24 → 2.33.28

package/engine/graphics/ecs/light/Light.js

@@ -109,6 +109,8 @@ export class Light {
 
         if (json.castShadow !== undefined) {
             this.castShadow.fromJSON(json.castShadow);
+        } else {
+            this.castShadow.set(false);
         }
 
         const actual_type = this.type.getValue();

package/engine/graphics/ecs/light/binding/three/ThreeLightBinding.js

@@ -99,7 +99,8 @@ export class ThreeLightBinding extends LightBinding {
          */
         const cache = this.__system.__three_light_cache;
 
-        threeEnsureLightObject(this.__c_light, cache);
+        const c_light = this.__c_light;
+        threeEnsureLightObject(c_light, cache);
 
         super.link(ctx);
     }
@@ -112,6 +113,9 @@ export class ThreeLightBinding extends LightBinding {
 
         cache.release(this.__three_getLight());
 
+        // clear bound light
+        this.__c_light.__threeObject = null;
+
         this.__shadowmap_unlink();
 
         super.unlink(ctx);

package/engine/graphics/ecs/mesh-v2/DrawMode.js

@@ -0,0 +1,5 @@
+export const DrawMode = {
+    Triangles: 0,
+    Lines: 2,
+    LineSegments: 3
+};

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -1,9 +1,10 @@
-import { Mesh, Quaternion } from "three";
+import { Line, LineSegments, Mesh } from "three";
 import { updateNodeByMatrix4AndBBB } from "../mesh/updateNodeByTransformAndBBB.js";
 import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
+import { DrawMode } from "./DrawMode.js";
+import { applyTransformToThreeObject } from "../mesh/applyTransformToThreeObject.js";
 
-const _q = new Quaternion();
 const _aabb3 = new AABB3();
 
 export class ShadedGeometry {
@@ -19,6 +20,12 @@ export class ShadedGeometry {
          */
         this.material = null;
 
+        /**
+         *
+         * @type {DrawMode|number}
+         */
+        this.mode = DrawMode.Triangles;
+
         /**
          *
          * @type {THREE.Object3D|null}
@@ -34,6 +41,19 @@ export class ShadedGeometry {
         this.__bvh_leaf = new LeafNode(this, 0, 0, 0, 0, 0, 0);
     }
 
+    __build_object() {
+        const mode = this.mode;
+        if (mode === DrawMode.Triangles) {
+            this.__cached_object = new Mesh(this.geometry, this.material);
+        } else if (mode === DrawMode.Lines) {
+            this.__cached_object = new Line(this.geometry, this.material);
+        } else if (mode === DrawMode.LineSegments) {
+            this.__cached_object = new LineSegments(this.geometry, this.material);
+        } else {
+            throw new Error(`Unsupported draw mode '${mode}'`);
+        }
+    }
+
     get bvh() {
         return this.__bvh_leaf;
     }
@@ -42,10 +62,12 @@ export class ShadedGeometry {
      *
      * @param {THREE.BufferGeometry} geometry
      * @param {THREE.Material} material
+     * @param draw_mode
      */
-    from(geometry, material) {
+    from(geometry, material, draw_mode = DrawMode.Triangles) {
         this.geometry = geometry;
         this.material = material;
+        this.mode = draw_mode;
 
         // ensure that geometry has a bounding box
         if (geometry.boundingBox === null) {
@@ -53,7 +75,7 @@ export class ShadedGeometry {
         }
 
         if (this.__cached_object === null) {
-            this.__cached_object = new Mesh(geometry, material);
+            this.__build_object();
         } else {
             this.__cached_object.material = material;
             this.__cached_object.geometry = geometry;
@@ -64,12 +86,13 @@ export class ShadedGeometry {
      *
      * @param geometry
      * @param material
+     * @param mode
      * @return {ShadedGeometry}
      */
-    static from(geometry, material) {
+    static from(geometry, material, mode) {
         const r = new ShadedGeometry();
 
-        r.from(geometry, material);
+        r.from(geometry, material, mode);
 
         return r;
     }
@@ -77,6 +100,7 @@ export class ShadedGeometry {
     updateTransform() {
         // update matrix
         this.__cached_object.updateMatrix();
+        this.__cached_object.updateMatrixWorld();
 
         // update bounds
 
@@ -116,9 +140,7 @@ export class ShadedGeometry {
      */
     setRotationByComponents(x, y, z, w) {
 
-        _q.set(x, y, z, w);
-
-        this.__cached_object.rotation.setFromQuaternion(_q);
+        this.__cached_object.quaternion.set(x, y, z, w);
 
         this.updateTransform();
     }
@@ -140,15 +162,7 @@ export class ShadedGeometry {
      * @param {Transform} t
      */
     applyTransform(t) {
-        // TODO this can be optimized quite a lot
-        const position = t.position;
-        this.setPositionByComponents(position.x, position.y, position.z);
-
-        const rotation = t.rotation;
-        this.setRotationByComponents(rotation.x, rotation.y, rotation.z, rotation.w);
-
-        const scale = t.scale;
-        this.setScaleByComponents(scale.x, scale.y, scale.z);
+        applyTransformToThreeObject(this.__cached_object, t);
 
         this.updateTransform();
     }

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -9,6 +9,7 @@ import ThreeFactory from "../../three/ThreeFactory.js";
 import { StaticMaterialCache } from "../../../asset/loaders/material/StaticMaterialCache.js";
 import { composeCompile } from "../../material/composeCompile.js";
 import { typed_array_copy } from "../../../../core/collection/array/typed/typed_array_copy.js";
+import { rewriteMaterial } from "./rewriteMaterial.js";
 
 /**
  *
@@ -94,77 +95,6 @@ InstancedMeshGroup.prototype.setGeometry = function (geometry) {
 };
 
 
-const SHADER_PREAMBLE = `
-    attribute vec3 instancePosition;
-    attribute vec4 instanceRotation;
-    attribute vec3 instanceScale;
-    
-    vec3 instanceTransform( in vec3 position, vec3 T, vec4 R, vec3 S ){
-        vec3 result = position;
-        
-        //applies the scale
-        result *= S;
-        //computes the rotation where R is a (vec4) quaternion
-        result += 2.0 * cross( R.xyz, cross( R.xyz, result ) + R.w * result );
-        //translates the transformed 'blueprint'
-        result += T;
-        
-        return result;
-    }
-    
-    mat4 getInstanceMatrix(){
-      vec4 q = instanceRotation;
-      vec3 s = instanceScale;
-      vec3 v = instancePosition;
-
-      vec3 q2 = q.xyz + q.xyz;
-      vec3 a = q.xxx * q2.xyz;
-      vec3 b = q.yyz * q2.yzz;
-      vec3 c = q.www * q2.xyz;
-    
-      vec3 r0 = vec3( 1.0 - (b.x + b.z) , a.y + c.z , a.z - c.y ) * s.xxx;
-      vec3 r1 = vec3( a.y - c.z , 1.0 - (a.x + b.z) , b.y + c.x ) * s.yyy;
-      vec3 r2 = vec3( a.z + c.y , b.y - c.x , 1.0 - (a.x + b.x) ) * s.zzz;
-    
-      return mat4(
-          r0 , 0.0,
-          r1 , 0.0,
-          r2 , 0.0,
-          v  , 1.0
-      );
-    }\n`;
-
-function rewriteMaterial(shader) {
-    const originalVertexShader = shader.vertexShader;
-
-    const newVertexShader = SHADER_PREAMBLE
-        + originalVertexShader
-            .replace(
-                '#include <uv_vertex>',
-                `
-                mat4 instanceMatrix = getInstanceMatrix();
-                #include <uv_vertex>
-                `
-            )
-            .replace(
-                '#include <begin_vertex>',
-                `
-                vec3 transformed = ( instanceMatrix * vec4(position,1.0) ).xyz;
-                `
-            )
-            .replace(
-                '#include <beginnormal_vertex>',
-                `
-                vec3 objectNormal = mat3( instanceMatrix ) * vec3( normal );
-                #ifdef USE_TANGENT
-                    vec3 objectTangent = vec3( tangent.xyz );
-                #endif
-                `
-            );
-
-    shader.vertexShader = newVertexShader;
-}
-
 /**
  *
  * @param {THREE.Material} sourceMaterial
@@ -332,7 +262,19 @@ InstancedMeshGroup.prototype.add = function (reference) {
  * @param {*} [thisArg]
  */
 InstancedMeshGroup.prototype.traverseReferences = function (visitor, thisArg) {
-    this.indices.forEach(visitor, thisArg);
+    const indices = this.indices;
+    const index_count = indices.length;
+
+    for (let i = 0; i < index_count; i++) {
+        const index = indices[i];
+
+        if (index === undefined) {
+            // unoccupied
+            continue;
+        }
+
+        visitor.call(thisArg, index, i);
+    }
 };
 
 /**

package/engine/graphics/geometry/instancing/rewriteMaterial.js

@@ -0,0 +1,70 @@
+const SHADER_PREAMBLE = `
+    attribute vec3 instancePosition;
+    attribute vec4 instanceRotation;
+    attribute vec3 instanceScale;
+    
+    vec3 instanceTransform( in vec3 position, vec3 T, vec4 R, vec3 S ){
+        vec3 result = position;
+        
+        //applies the scale
+        result *= S;
+        //computes the rotation where R is a (vec4) quaternion
+        result += 2.0 * cross( R.xyz, cross( R.xyz, result ) + R.w * result );
+        //translates the transformed 'blueprint'
+        result += T;
+        
+        return result;
+    }
+    
+    mat4 getInstanceMatrix(){
+      vec4 q = instanceRotation;
+      vec3 s = instanceScale;
+      vec3 v = instancePosition;
+
+      vec3 q2 = q.xyz + q.xyz;
+      vec3 a = q.xxx * q2.xyz;
+      vec3 b = q.yyz * q2.yzz;
+      vec3 c = q.www * q2.xyz;
+    
+      vec3 r0 = vec3( 1.0 - (b.x + b.z) , a.y + c.z , a.z - c.y ) * s.xxx;
+      vec3 r1 = vec3( a.y - c.z , 1.0 - (a.x + b.z) , b.y + c.x ) * s.yyy;
+      vec3 r2 = vec3( a.z + c.y , b.y - c.x , 1.0 - (a.x + b.x) ) * s.zzz;
+    
+      return mat4(
+          r0 , 0.0,
+          r1 , 0.0,
+          r2 , 0.0,
+          v  , 1.0
+      );
+    }\n`;
+
+export function rewriteMaterial(shader) {
+    const originalVertexShader = shader.vertexShader;
+
+    const newVertexShader = SHADER_PREAMBLE
+        + originalVertexShader
+            .replace(
+                '#include <uv_vertex>',
+                `
+                mat4 instanceMatrix = getInstanceMatrix();
+                #include <uv_vertex>
+                `
+            )
+            .replace(
+                '#include <begin_vertex>',
+                `
+                vec3 transformed = ( instanceMatrix * vec4(position,1.0) ).xyz;
+                `
+            )
+            .replace(
+                '#include <beginnormal_vertex>',
+                `
+                vec3 objectNormal = mat3( instanceMatrix ) * vec3( normal );
+                #ifdef USE_TANGENT
+                    vec3 objectTangent = vec3( tangent.xyz );
+                #endif
+                `
+            );
+
+    shader.vertexShader = newVertexShader;
+}

package/engine/graphics/material/manager/MaterialManager.js

@@ -14,7 +14,8 @@ export class MaterialManager {
          */
         this.__library = new HashMap({
             keyHashFunction: computeMaterialHash,
-            keyEqualityFunction: computeMaterialEquality
+            keyEqualityFunction: computeMaterialEquality,
+            capacity: 1024
         });
 
         /**

package/engine/graphics/micron/render/instanced/AttributeDataTexture.js

@@ -237,8 +237,8 @@ export class AttributeDataTexture {
     /**
      *
      * @param {number} slot
-     * @param {number[]} indices
-     * @param {number[]} source
+     * @param {number[]} indices triangle indices (index buffer)
+     * @param {number[]} source vertex data
      */
     write_slot_from_indexed(slot, indices, source) {
         assert.isNonNegativeInteger(slot, 'index');
@@ -289,8 +289,10 @@ export class AttributeDataTexture {
         const start_index = slot_size * index;
         const end_index = slot_size * (index + 1);
 
-        this.__texture.image.data.fill(0, start_index, end_index);
-        this.__texture.needsUpdate = true;
+        const texture = this.__texture;
+
+        texture.image.data.fill(0, start_index, end_index);
+        texture.needsUpdate = true;
     }
 
     /**

package/engine/graphics/micron/render/instanced/ThreeInstancedAdapter.js

@@ -11,7 +11,6 @@ import Signal from "../../../../../core/events/signal/Signal.js";
 import { ATTRIBUTE_NAME_ADDRESS, ATTRIBUTE_NAME_TRANSFORM } from "./shader/constants.js";
 import { shader_rewrite_standard } from "./shader/shader_rewrite_standard.js";
 
-
 export class ThreeInstancedAdapter {
     /**
      *
@@ -79,7 +78,6 @@ export class ThreeInstancedAdapter {
         const position_buffer = new BufferAttribute(new Uint8Array(MICRON_PATCH_SIZE_MAX * 3 * 3), 3, false);
 
 
-
         position_buffer.setUsage(StaticReadUsage);
 
         geo.setAttribute('position', position_buffer);

package/engine/graphics/particles/ParticleEmitterLibrary.js

@@ -2,6 +2,9 @@ import { ParticleEmitter } from "./particular/engine/emitter/ParticleEmitter.js"
 import { GameAssetType } from "../../asset/GameAssetType.js";
 import { assert } from "../../../core/assert.js";
 
+/**
+ * @deprecated Use "Effect" API to achieve the same results
+ */
 export class ParticleEmitterLibrary {
     /**
      *

package/engine/graphics/particles/ecs/{ParticleEmitterSystem2.js → ParticleEmitterSystem.js}

@@ -8,6 +8,7 @@ import { ParticleEmitterLibrary } from "../ParticleEmitterLibrary.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
 import { StandardFrameBuffers } from "../../StandardFrameBuffers.js";
+import { assert } from "../../../../core/assert.js";
 
 /**
  *
@@ -28,36 +29,38 @@ function putEmitterToSleep(emitter) {
     emitter.setFlag(ParticleEmitterFlag.Sleeping);
 }
 
-export class ParticleEmitterSystem2 extends System {
+export class ParticleEmitterSystem extends System {
     /**
      *
      * @extends {System.<ParticleEmitter>}
      * @constructor
-     * @param {AssetManager} assetManager
-     * @param {GraphicsEngine} graphicsEngine
+     * @param {Engine} engine
      */
-    constructor(assetManager, graphicsEngine) {
+    constructor(engine) {
         super();
 
+        assert.defined(engine, 'engine');
+        assert.equal(engine.isEngine, true, 'engine.isEngine !== true');
+
         this.dependencies = [ParticleEmitter, Transform];
 
         /**
          *
          * @type {GraphicsEngine}
          */
-        this.graphicsEngine = graphicsEngine;
+        this.graphicsEngine = engine.graphics;
 
         /**
          *
          * @type {AssetManager}
          */
-        this.assetManager = assetManager;
+        this.assetManager = engine.assetManager;
 
         /**
          *
          * @type {ParticularEngine}
          */
-        this.particleEngine = new ParticularEngine(assetManager);
+        this.particleEngine = new ParticularEngine(engine.assetManager, engine.graphics.getMaterialManager());
 
         /**
          *
@@ -72,14 +75,19 @@ export class ParticleEmitterSystem2 extends System {
         this.bvh = null;
 
         /**
-         *
+         * @deprecated Use "Effect" API to achieve the same results
          * @type {ParticleEmitterLibrary}
          */
-        this.library = new ParticleEmitterLibrary(assetManager);
+        this.__library = new ParticleEmitterLibrary(engine.assetManager);
 
         this.__handlers = [];
     }
 
+    get library() {
+        console.warn('Deprecated, use "Effect" API to achieve the same results');
+        return this.__library;
+    }
+
     get componentClass() {
         return ParticleEmitter;
     }

package/engine/graphics/particles/particular/engine/ParticularEngine.js

@@ -8,8 +8,14 @@ import { SimulationStepApplyForce } from "./simulator/SimulationStepApplyForce.j
 import { SimulationStepCurlNoiseVelocity } from "./simulator/SimulationStepCurlNoiseVelocity.js";
 
 
-function ParticularEngine(assetManager) {
-    this.shaderManager = new ShaderManager(assetManager);
+/**
+ *
+ * @param {AssetManager} assetManager
+ * @param {MaterialManager} material_manager
+ * @constructor
+ */
+function ParticularEngine(assetManager, material_manager) {
+    this.shaderManager = new ShaderManager(assetManager, material_manager);
 
     /**
      *

package/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js

@@ -272,6 +272,7 @@ export class ParticleEmitter {
             softDepth: !this.getFlag(ParticleEmitterFlag.DepthSoftDisabled),
             velocityAlign: this.getFlag(ParticleEmitterFlag.AlignOnVelocity),
             depthSort: this.getFlag(ParticleEmitterFlag.DepthSorting),
+            receiveLight: this.getFlag(ParticleEmitterFlag.Lit),
             blendingMode: this.blendingMode,
             layers: this.layers.toJSON()
         };
@@ -330,6 +331,12 @@ export class ParticleEmitter {
             this.writeFlag(ParticleEmitterFlag.DepthSorting, true);
         }
 
+        if (typeof json.receiveLight === "boolean") {
+            this.writeFlag(ParticleEmitterFlag.Lit, json.receiveLight);
+        } else {
+            this.clearFlag(ParticleEmitterFlag.Lit);
+        }
+
         this.layers.fromJSON(json.layers, ParticleLayer);
 
         this.writeFlag(ParticleEmitterFlag.Built, false);
@@ -484,33 +491,15 @@ export class ParticleEmitter {
         //retire dead particles
         const particles = this.particles;
 
-        const liveParticleCount = particles.size();
+        particles.computeAttributeVector3AxisAlignedBoundingBox(PARTICLE_ATTRIBUTE_POSITION, scratch_array);
 
-        let bounds_x0 = Infinity;
-        let bounds_y0 = Infinity;
-        let bounds_z0 = Infinity;
+        let bounds_x0 = scratch_array[0];
+        let bounds_y0 = scratch_array[1];
+        let bounds_z0 = scratch_array[2];
 
-        let bounds_x1 = -Infinity;
-        let bounds_y1 = -Infinity;
-        let bounds_z1 = -Infinity;
-
-        for (let i = 0; i < liveParticleCount; i++) {
-
-            particles.readAttributeVector3(i, PARTICLE_ATTRIBUTE_POSITION, position);
-
-            const p_x = position[0];
-            const p_y = position[1];
-            const p_z = position[2];
-
-            //update bounds
-            bounds_x0 = min2(bounds_x0, p_x);
-            bounds_y0 = min2(bounds_y0, p_y);
-            bounds_z0 = min2(bounds_z0, p_z);
-
-            bounds_x1 = max2(bounds_x1, p_x);
-            bounds_y1 = max2(bounds_y1, p_y);
-            bounds_z1 = max2(bounds_z1, p_z);
-        }
+        let bounds_x1 = scratch_array[3];
+        let bounds_y1 = scratch_array[4];
+        let bounds_z1 = scratch_array[5];
 
         //expand bounds by maximum sprite size
         const extents = this.computeSpriteMaxHalfSize();

package/engine/graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js

@@ -59,4 +59,9 @@ export const ParticleEmitterFlag = {
      * Rotation of each particle will adjusted to world velocity vector
      */
     AlignOnVelocity: 8192,
+
+    /**
+     * Whether or not the particle should respond to lights
+     */
+    Lit: 16384
 };

package/engine/graphics/particles/particular/engine/emitter/ParticlePool.js

@@ -5,6 +5,8 @@ import ObservedValue from "../../../../../../core/model/ObservedValue.js";
 import { typed_array_copy } from "../../../../../../core/collection/array/typed/typed_array_copy.js";
 import { assert } from "../../../../../../core/assert.js";
 import { compute_typed_array_constructor_from_data_type } from "../../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { min2 } from "../../../../../../core/math/min2.js";
+import { max2 } from "../../../../../../core/math/max2.js";
 
 const SHRINK_THRESHOLD = 64;
 const GROW_MIN_STEP = 32;
@@ -218,11 +220,11 @@ export class ParticlePool {
                 const addressA = offsetA + j;
                 const addressB = offsetB + j;
 
-                const elementA = array[addressA];
+                const temp = array[addressA];
 
                 array[addressA] = array[addressB];
 
-                array[addressB] = elementA;
+                array[addressB] = temp;
             }
         }
     }
@@ -505,6 +507,92 @@ export class ParticlePool {
         array[address + 3] = w;
     }
 
+    /**
+     * Write the same attribute value for every particle.
+     * Assumes particles are packed (no holes).
+     * @param {number} attribute_index
+     * @param {number[]|Float32Array|Uint8Array|Uint16Array|Int8Array|Int32Array} value
+     */
+    writeAttributeForAllArray(attribute_index, value) {
+        const attribute = this.attributes[attribute_index];
+
+        const itemSize = attribute.itemSize;
+
+        if (value.length < itemSize) {
+            throw new Error(`Argument underflow, attribute.itemSize is '${itemSize}', but supplier argument's length is '${value.length}'`);
+        }
+
+        const n = this.size();
+
+        const destination = attribute.array;
+
+        let k;
+        for (let i = 0; i < n; i++) {
+            const offset = i * itemSize;
+
+            for (k = 0; k < itemSize; k++) {
+                destination[offset + k] = value[k];
+            }
+        }
+
+        // mark for update
+        attribute.needsUpdate = true;
+        attribute.updateRange.count = n;
+        attribute.updateRange.offset = 0;
+    }
+
+    /**
+     *
+     * @param {number} attribute_index
+     * @param {number[]} result
+     */
+    computeAttributeVector3AxisAlignedBoundingBox(attribute_index, result) {
+        const attribute = this.attributes[attribute_index];
+        const item_size = attribute.itemSize;
+
+        if (item_size !== 3) {
+            throw new Error(`Attribute item_size is expected to be 3, instead was '${item_size}'`);
+        }
+
+        let bounds_x0 = Infinity;
+        let bounds_y0 = Infinity;
+        let bounds_z0 = Infinity;
+
+        let bounds_x1 = -Infinity;
+        let bounds_y1 = -Infinity;
+        let bounds_z1 = -Infinity;
+
+        const particle_count = this.size();
+
+        const data = attribute.array;
+
+        for (let i = 0; i < particle_count; i++) {
+            const particle_address = i * 3;
+
+            const x = data[particle_address];
+            const y = data[particle_address + 1];
+            const z = data[particle_address + 2];
+
+            bounds_x0 = min2(bounds_x0, x);
+            bounds_y0 = min2(bounds_y0, y);
+            bounds_z0 = min2(bounds_z0, z);
+
+            bounds_x1 = max2(bounds_x1, x);
+            bounds_y1 = max2(bounds_y1, y);
+            bounds_z1 = max2(bounds_z1, z);
+        }
+
+        // read out
+        result[0] = bounds_x0;
+        result[1] = bounds_y0;
+        result[2] = bounds_z0;
+
+        result[3] = bounds_x1;
+        result[4] = bounds_y1;
+        result[5] = bounds_z1;
+
+    }
+
     dispose() {
         const bufferGeometry = this.geometry.getValue();