@woosh/meep-engine 2.33.22 → 2.33.26

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);
 
     /**
      *
@@ -63,10 +69,12 @@ ParticularEngine.prototype.add = function (emitter) {
  * @param {ParticleEmitter} emitter
  */
 ParticularEngine.prototype.remove = function (emitter) {
-    const i = this.emitters.indexOf(emitter);
+    const emitters = this.emitters;
+
+    const i = emitters.indexOf(emitter);
 
     if (i !== -1) {
-        this.emitters.remove(i);
+        emitters.remove(i);
     }
 
     this.shaderManager.deregister(emitter);

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

@@ -0,0 +1,84 @@
+import { VertexDataSpec } from "../../../../geometry/VertexDataSpec.js";
+import { AttributeSpec } from "../../../../geometry/AttributeSpec.js";
+import { DataType } from "../../../../../../core/collection/table/DataType.js";
+
+//build particle spec
+export const PARTICULAR_PARTICLE_SPECIFICATION = new VertexDataSpec();
+
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'position',
+    itemSize: 3,
+    type: DataType.Float32,
+    normalized: false
+}));
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'age',
+    itemSize: 1,
+    type: DataType.Float32,
+    normalized: false
+}));
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'deathAge',
+    itemSize: 1,
+    type: DataType.Float32,
+    normalized: false
+}));
+
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'atlasPatch',
+    itemSize: 4,
+    type: DataType.Uint16,
+    normalized: true
+}));
+
+// TODO convert "size" to scale instead
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'size',
+    itemSize: 1,
+    type: DataType.Float32,
+    normalized: false
+}));
+
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'layerPosition',
+    itemSize: 1,
+    type: DataType.Uint8,
+    normalized: false
+}));
+
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'velocity',
+    itemSize: 3,
+    type: DataType.Float32,
+    normalized: false
+}));
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'rotation',
+    itemSize: 1,
+    type: DataType.Float32,
+    normalized: false
+}));
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'rotationSpeed',
+    itemSize: 1,
+    type: DataType.Float32,
+    normalized: false
+}));
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'color',
+    itemSize: 4,
+    type: DataType.Uint8,
+    normalized: true
+}));
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'blending',
+    itemSize: 1,
+    type: DataType.Float32,
+    normalized: false
+}));
+PARTICULAR_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'size_initial',
+    itemSize: 1,
+    type: DataType.Float32,
+    normalized: false
+}));

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

@@ -3,7 +3,6 @@ import List from "../../../../../../core/collection/list/List.js";
 import { lerp } from "../../../../../../core/math/lerp.js";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { min2 } from "../../../../../../core/math/min2.js";
-import { ParticleAttributeType, ParticleDataType } from "../../group/ParticleGroup.js";
 import { Box3, BufferGeometry, Frustum, Matrix4, Points, PointsMaterial } from 'three';
 import { frustumFromCamera } from "../../../../ecs/camera/CameraSystem.js";
 import { ParticlePool } from "./ParticlePool.js";
@@ -15,9 +14,6 @@ import { ParticleLayer } from "./ParticleLayer.js";
 import { ParticleParameters } from "./ParticleParameters.js";
 import { BlendingType } from "../../../../texture/sampler/BlendingType.js";
 import Quaternion from "../../../../../../core/geom/Quaternion.js";
-import { computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
-import { ParticleSpecification } from "../../group/ParticleSpecification.js";
-import { ParticleAttribute } from "../../group/ParticleAttribute.js";
 import { ParticleEmitterFlag } from "./ParticleEmitterFlag.js";
 import { AABB3 } from "../../../../../../core/bvh2/aabb3/AABB3.js";
 import {
@@ -34,14 +30,11 @@ import {
     PARTICLE_ATTRIBUTE_VELOCITY
 } from "./PARTICLE_ATTRIBUTES.js";
 import { composeMatrix4 } from "../../../../util/composeMatrix4.js";
-import { randomPointInPoint } from "../../../../../../core/geom/random/randomPointInPoint.js";
-import { randomPointInSphere } from "../../../../../../core/geom/random/randomPointInSphere.js";
-import { randomPointOnSphere } from "../../../../../../core/geom/random/randomPointOnSphere.js";
-import { randomPointInBox } from "../../../../../../core/geom/random/randomPointInBox.js";
-import { randomPointOnBox } from "../../../../../../core/geom/random/randomPointOnBox.js";
-import { EmissionFromType } from "./EmissionFromType.js";
-import { EmissionShapeType } from "./EmissionShapeType.js";
 import { update_parameters } from "../simulator/update_parameters.js";
+import { distance_to_camera } from "./distance_to_camera.js";
+import { computeEmissionFunction } from "./computeEmissionFunction.js";
+import { PARTICULAR_PARTICLE_SPECIFICATION } from "./PARTICULAR_PARTICLE_SPECIFICATION.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 const EMPTY_GEOMETRY = new BufferGeometry();
 
@@ -68,57 +61,9 @@ const scratch_array = [];
 
 /**
  *
- * @param {EmissionFromType} emissionType
- * @param {EmissionShapeType} emissionShape
- * @returns {function(random: function, result:Vector3):void}
- */
-function computeEmissionFunction(emissionType, emissionShape) {
-    if (emissionShape === EmissionShapeType.Point) {
-        return randomPointInPoint;
-    } else if (emissionShape === EmissionShapeType.Sphere) {
-        if (emissionType === EmissionFromType.Volume) {
-            return randomPointInSphere;
-        } else if (emissionType === EmissionFromType.Shell) {
-            return randomPointOnSphere;
-        } else {
-            throw new TypeError(`Unsupported EmissionFrom Type`);
-        }
-    } else if (emissionShape === EmissionShapeType.Box) {
-        if (emissionType === EmissionFromType.Volume) {
-            return randomPointInBox;
-        } else if (emissionType === EmissionFromType.Shell) {
-            return randomPointOnBox;
-        } else {
-            throw new TypeError(`Unsupported EmissionFrom Type`);
-        }
-    }
-}
-
-/**
- *
- * @param {number} index
- * @param {number[]|Float32Array} positionArray
- * @param {Vector3} planeNormal
- * @return {number}
+ * @type {number[]}
  */
-function distanceToCamera(index, positionArray, planeNormal) {
-    const address = index * 3;
-
-    // extract position components of the particle
-    const x = positionArray[address];
-    const y = positionArray[address + 1];
-    const z = positionArray[address + 2];
-
-    const planeNormalX = planeNormal.x;
-    const planeNormalY = planeNormal.y;
-    const planeNormalZ = planeNormal.z;
-
-    // compute dot product
-    const dot = x * planeNormalX + y * planeNormalY + z * planeNormalZ;
-
-    // use dot product instead of the actual distance to save computation. Difference is going to be constant
-    return dot;
-}
+const scratch_v3_array = [];
 
 /**
  *
@@ -135,6 +80,35 @@ function generateStandardParameterSet(parameters) {
     parameters.add(pColor);
 }
 
+
+const uint16_mul = 65536;
+
+/**
+ *
+ * @param {AtlasPatch} atlasPatch
+ * @param {ParticlePool} particles
+ * @param {number} ref
+ */
+function write_particle_patch_uv(atlasPatch, particles, ref) {
+    const uv = atlasPatch.uv;
+
+    const uv_position = uv.position;
+
+    const u0 = uv_position.x;
+    const v0 = uv_position.y;
+
+    const uv_size = uv.size;
+
+    const u1 = uv_size.x;
+    const v1 = uv_size.y;
+
+    particles.writeAttributeVector4(
+        ref,
+        PARTICLE_ATTRIBUTE_UV,
+        u0 * uint16_mul, v0 * uint16_mul, u1 * uint16_mul, v1 * uint16_mul
+    );
+}
+
 export class ParticleEmitter {
     constructor() {
         /**
@@ -297,6 +271,8 @@ export class ParticleEmitter {
             readDepth: !this.getFlag(ParticleEmitterFlag.DepthReadDisabled),
             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()
         };
@@ -349,6 +325,18 @@ export class ParticleEmitter {
             this.writeFlag(ParticleEmitterFlag.AlignOnVelocity, false);
         }
 
+        if (typeof json.depthSort === "boolean") {
+            this.writeFlag(ParticleEmitterFlag.DepthSorting, json.depthSort);
+        } else {
+            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);
@@ -404,19 +392,20 @@ export class ParticleEmitter {
             throw new Error('Layer not found');
         }
 
-        const numLayers = layers.length;
-
         const particles = this.particles;
         const occupancy = particles.occupancy;
 
         let removeCount = 0;
 
-        for (let i = occupancy.nextSetBit(0); i !== -1; i = occupancy.nextSetBit(i + 1)) {
-            const layerPosition = particles.readAttributeScalar(i, PARTICLE_ATTRIBUTE_LAYER_POSITION);
+        for (
+            let i = occupancy.nextSetBit(0);
+            i !== -1;
+            i = occupancy.nextSetBit(i + 1)
+        ) {
 
-            const layerIndex = Math.round(layerPosition * numLayers);
+            const layerPosition = particles.readAttributeScalar(i, PARTICLE_ATTRIBUTE_LAYER_POSITION);
 
-            if (layerIndex !== targetLayerIndex) {
+            if (layerPosition !== targetLayerIndex) {
                 // not the layer we want
                 continue;
             }
@@ -425,6 +414,7 @@ export class ParticleEmitter {
             occupancy.set(i, false);
 
             removeCount++;
+
         }
 
         if (removeCount > 0) {
@@ -489,7 +479,10 @@ export class ParticleEmitter {
             }
         }
 
-        this.emisionBounds.setBounds(bounds_x0, bounds_y0, bounds_z0, bounds_x1, bounds_y1, bounds_z1);
+        this.emisionBounds.setBounds(
+            bounds_x0, bounds_y0, bounds_z0,
+            bounds_x1, bounds_y1, bounds_z1
+        );
 
         this.clearFlag(ParticleEmitterFlag.BaseBoundsNeedUpdate);
     }
@@ -498,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();
@@ -708,8 +683,8 @@ export class ParticleEmitter {
     }
 
     computeHash() {
-        const parametersHash = this.parameters.hash();
-        const layersHash = this.layers.hash();
+        const parameters_hash = this.parameters.hash();
+        const layers_hash = this.layers.hash();
 
         /**
          * Extract relevant flags
@@ -717,7 +692,12 @@ export class ParticleEmitter {
          */
         const flags = this.flags & (SERIALIZABLE_FLAGS);
 
-        return computeHashIntegerArray(parametersHash, layersHash, this.blendingMode, flags);
+        return computeHashIntegerArray(
+            parameters_hash,
+            layers_hash,
+            this.blendingMode,
+            flags
+        );
     }
 
     hash() {
@@ -799,14 +779,19 @@ export class ParticleEmitter {
 
             const pivotIndex = (left + right) >> 1;
 
-            const pivot = distanceToCamera(pivotIndex, positionArray, nearPlaneNormal);
+            const pivot = distance_to_camera(pivotIndex, positionArray, nearPlaneNormal);
 
             /* partition */
             while (i <= j) {
-                while (distanceToCamera(i, positionArray, nearPlaneNormal) > pivot)
+
+                while (distance_to_camera(i, positionArray, nearPlaneNormal) > pivot) {
                     i++;
-                while (distanceToCamera(j, positionArray, nearPlaneNormal) < pivot)
+                }
+
+                while (distance_to_camera(j, positionArray, nearPlaneNormal) < pivot) {
                     j--;
+                }
+
                 if (i <= j) {
 
                     if (i !== j) {
@@ -879,29 +864,19 @@ export class ParticleEmitter {
 
         const layers = this.layers;
 
-        const numLayers = layers.length;
-
         let missingFlag = false;
 
         //cycle through each particle
         for (let i = occupancy.nextSetBit(0); i !== -1; i = occupancy.nextSetBit(i + 1)) {
-            const layerPosition = particles.readAttributeScalar(i, PARTICLE_ATTRIBUTE_LAYER_POSITION);
-
-            const layerIndex = Math.round(layerPosition * numLayers);
+            const layerIndex = particles.readAttributeScalar(i, PARTICLE_ATTRIBUTE_LAYER_POSITION);
 
             const layer = layers.get(layerIndex);
 
             const atlasPatch = layer.__atlasPatch;
 
             if (atlasPatch !== null) {
-                const uv = atlasPatch.uv;
-
-                const u0 = uv.position.x;
-                const v0 = uv.position.y;
-                const u1 = uv.size.x;
-                const v1 = uv.size.y;
 
-                particles.writeAttributeVector4(i, PARTICLE_ATTRIBUTE_UV, u0, v0, u1, v1);
+                write_particle_patch_uv(atlasPatch, particles, i);
             } else {
                 missingFlag = true;
             }
@@ -933,8 +908,6 @@ export class ParticleEmitter {
 
         const emissionPeriod = 1 / layer.emissionRate;
 
-        const layerPosition = layerIndex / this.layers.length;
-
         //compute transform matrix of the emitter
         const emitter_position = this.position;
         const last_spawn_position = this.__lastSpawnPosition;
@@ -952,7 +925,9 @@ export class ParticleEmitter {
             const f = time / timeDelta;
 
             //compute position for particle
-            emissionFunction(random, v3position);
+            emissionFunction(random, scratch_v3_array, 0);
+
+            v3position.readFromArray(scratch_v3_array, 0);
 
             //apply layer transform
             v3position.multiply(layer.scale);
@@ -1011,28 +986,17 @@ export class ParticleEmitter {
             //write UV
             const atlasPatch = layer.__atlasPatch;
             if (atlasPatch !== null) {
-                const uv = atlasPatch.uv;
-
-                const uv_position = uv.position;
-
-                const u0 = uv_position.x;
-                const v0 = uv_position.y;
-
-                const uv_size = uv.size;
-
-                const u1 = uv_size.x;
-                const v1 = uv_size.y;
-
-                particles.writeAttributeVector4(ref, PARTICLE_ATTRIBUTE_UV, u0, v0, u1, v1);
+                //patch exists, write it
+                write_particle_patch_uv(atlasPatch, particles, ref);
             } else {
                 this.setFlag(ParticleEmitterFlag.SpritesNeedUpdate);
             }
 
-            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_LAYER_POSITION, layerPosition);
+            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_LAYER_POSITION, layerIndex);
 
             update_parameters(ref, particles, layer, initialAge / deathAge);
 
-            particles.writeAttributeScalar(ref,PARTICLE_ATTRIBUTE_BLEND,this.blendingMode);
+            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_BLEND, this.blendingMode);
         }
 
         //update time buffer
@@ -1051,9 +1015,11 @@ export class ParticleEmitter {
             return;
         }
 
-        assert.ok(layerIndex < this.layers.length && layerIndex >= 0, `layerIndex[=${layerIndex}] is out of bounds`);
+        const layers = this.layers;
 
-        const layer = this.layers.get(layerIndex);
+        assert.ok(layerIndex < layers.length && layerIndex >= 0, `layerIndex[=${layerIndex}] is out of bounds`);
+
+        const layer = layers.get(layerIndex);
 
         const random = Math.random;
 
@@ -1065,8 +1031,6 @@ export class ParticleEmitter {
 
         const emissionFunction = computeEmissionFunction(layer.emissionFrom, layer.emissionShape);
 
-        const layerPosition = layerIndex / this.layers.length;
-
         //compute transform matrix of the emitter
         composeMatrix4(matrix4, this.position, this.rotation, this.scale);
 
@@ -1079,7 +1043,9 @@ export class ParticleEmitter {
             const ref = particles.create();
 
             //compute position for particle
-            emissionFunction(random, v3position);
+            emissionFunction(random, scratch_v3_array, 0);
+
+            v3position.readFromArray(scratch_v3_array, 0);
 
             //apply layer transform
             v3position.multiply(layer.scale);
@@ -1137,29 +1103,17 @@ export class ParticleEmitter {
 
             if (atlasPatch !== null) {
                 //patch exists, write it
-                const uv = atlasPatch.uv;
-
-                const uv_position = uv.position;
-
-                const u0 = uv_position.x;
-                const v0 = uv_position.y;
-
-                const uv_size = uv.size;
-
-                const u1 = uv_size.x;
-                const v1 = uv_size.y;
-
-                particles.writeAttributeVector4(ref, PARTICLE_ATTRIBUTE_UV, u0, v0, u1, v1);
+                write_particle_patch_uv(atlasPatch, particles, ref);
             } else {
                 //patch is not loaded yet, request update
                 spritesNeedUpdate = true;
             }
 
-            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_LAYER_POSITION, layerPosition);
+            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_LAYER_POSITION, layerIndex);
 
             update_parameters(ref, particles, layer, initialAge / deathAge);
 
-            particles.writeAttributeScalar(ref,PARTICLE_ATTRIBUTE_BLEND,this.blendingMode);
+            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_BLEND, this.blendingMode);
         }
 
         if (spritesNeedUpdate) {
@@ -1197,7 +1151,9 @@ export class ParticleEmitter {
                 continue;
             }
 
-            const averageLifetime = (layer.particleLife.max + layer.particleLife.min) / 2;
+            const particleLife = layer.particleLife;
+
+            const averageLifetime = (particleLife.max + particleLife.min) / 2;
 
             //emitting more than averageLifetime lifetime is unproductive, so we'll crop the emission
             let emissionDelta;
@@ -1260,27 +1216,8 @@ const matrix4 = new Matrix4();
 
 const defaultPointsMaterial = new PointsMaterial({ color: 0xFFFFFF });
 
-
-//build particle spec
-export const PARTICULAR_PARTICLE_SPECIFICATION = new ParticleSpecification();
-
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('position', ParticleAttributeType.Vector3, ParticleDataType.Float32));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('age', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('deathAge', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('atlasPatch', ParticleAttributeType.Vector4, ParticleDataType.Float32));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('size', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('layerPosition', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('velocity', ParticleAttributeType.Vector3, ParticleDataType.Float32));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('rotation', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('rotationSpeed', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('color', ParticleAttributeType.Vector4, ParticleDataType.Float32));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('blending', ParticleAttributeType.Scalar, ParticleDataType.Uint8));
-PARTICULAR_PARTICLE_SPECIFICATION.add(new ParticleAttribute('size_initial', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-
-
 const frustum = new Frustum();
 
-const velocity = [];
 const position = [];
 
 const v3position = new Vector3();

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
 };