@woosh/meep-engine 2.33.20 → 2.33.24

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

@@ -53,18 +53,18 @@ function normalized_internal_format(dt, channel_count) {
 export class AttributeDataTexture {
     /**
      *
-     * @param {MicronGeometryBufferAttributeSpec} spec
+     * @param {AttributeSpec} spec
      * @param {number} column_count
      */
     constructor(spec, column_count) {
         assert.defined(spec, 'spec');
-        assert.equal(spec.isMicronGeometryBufferAttributeSpec, true, 'spec.isMicronGeometryBufferAttributeSpec !== true');
+        assert.equal(spec.isAttributeSpec, true, 'spec.isAttributeSpec !== true');
 
         assert.isNonNegativeInteger(column_count, 'column_count');
 
         /**
          *
-         * @type {MicronGeometryBufferAttributeSpec}
+         * @type {AttributeSpec}
          * @private
          */
         this.__spec = spec;
@@ -90,7 +90,7 @@ export class AttributeDataTexture {
 
     /**
      *
-     * @return {MicronGeometryBufferAttributeSpec}
+     * @return {AttributeSpec}
      */
     get spec() {
         return this.__spec;
@@ -320,7 +320,7 @@ export class AttributeDataTexture {
     /**
      *
      * @return {AttributeDataTexture}
-     * @param {MicronGeometryBufferAttributeSpec} spec
+     * @param {AttributeSpec} spec
      * @param {number} column_count
      */
     static from(spec, column_count) {

package/engine/graphics/micron/render/refinement/is_patch_facing_back.js

@@ -1,5 +1,5 @@
 import { PI_HALF } from "../../../../../core/math/MathUtils.js";
-import { v3_angleBetween } from "../../../../../core/geom/Vector3.js";
+import { v3_angle_between } from "../../../../../core/geom/v3_angle_between.js";
 
 /**
  *
@@ -28,7 +28,7 @@ function is_patch_facing_back(refinement_spec, patch) {
         // compute view angle of the bounding sphere
         const normal_cone_direction = normal_cone.direction;
 
-        const angle = v3_angleBetween(
+        const angle = v3_angle_between(
             view_direction_x, view_direction_y, view_direction_z,
             normal_cone_direction.x, normal_cone_direction.y, normal_cone_direction.z
         );

package/engine/graphics/micron/render/v1/ThreeVirtualGeometryAdapter.js

@@ -4,7 +4,7 @@ import { DataType2TypedArrayConstructorMapping } from "../../../../../core/colle
 import { getTransformedPositionsCached } from "./getTransformedPositionsCached.js";
 import { Color } from "../../../../../core/color/Color.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
-import { randomFloatBetween } from "../../../../../core/math/MathUtils.js";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
 
 
 const scratch_random = seededRandom(0);

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

@@ -63,10 +63,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,7 @@ export class ParticleEmitter {
             readDepth: !this.getFlag(ParticleEmitterFlag.DepthReadDisabled),
             softDepth: !this.getFlag(ParticleEmitterFlag.DepthSoftDisabled),
             velocityAlign: this.getFlag(ParticleEmitterFlag.AlignOnVelocity),
+            depthSort: this.getFlag(ParticleEmitterFlag.DepthSorting),
             blendingMode: this.blendingMode,
             layers: this.layers.toJSON()
         };
@@ -349,6 +324,12 @@ 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);
+        }
+
         this.layers.fromJSON(json.layers, ParticleLayer);
 
         this.writeFlag(ParticleEmitterFlag.Built, false);
@@ -404,19 +385,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 +407,7 @@ export class ParticleEmitter {
             occupancy.set(i, false);
 
             removeCount++;
+
         }
 
         if (removeCount > 0) {
@@ -489,7 +472,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);
     }
@@ -708,8 +694,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 +703,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 +790,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 +875,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 +919,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 +936,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 +997,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 +1026,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 +1042,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 +1054,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 +1114,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 +1162,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 +1227,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/ParticleLayer.js

@@ -3,7 +3,6 @@ import { NumericInterval } from "../../../../../../core/math/interval/NumericInt
 import { ParameterTrackSet } from "../parameter/ParameterTrackSet.js";
 import { AABB3 } from "../../../../../../core/bvh2/aabb3/AABB3.js";
 import { ParticleParameters } from "./ParticleParameters.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
 import { ConicRay } from "../../../../../../core/geom/ConicRay.js";
 import { SimulationStepDefinition } from "../simulator/SimulationStepDefinition.js";
 import List from "../../../../../../core/collection/list/List.js";
@@ -12,6 +11,8 @@ import { computeStringHash } from "../../../../../../core/primitives/strings/com
 import { computeConeBoundingBox } from "../../../../../../core/geom/3d/cone/computeConeBoundingBox.js";
 import { EmissionFromType } from "./EmissionFromType.js";
 import { EmissionShapeType } from "./EmissionShapeType.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../../core/math/hash/computeHashFloat.js";
 
 function ParticleLayer() {
     /**
@@ -68,6 +69,7 @@ function ParticleLayer() {
      * @type {number}
      */
     this.emissionRate = 1;
+
     /**
      * When layer is added - it will immediately emit this number of particles
      * @type {number}
@@ -97,6 +99,11 @@ function ParticleLayer() {
      * @type {ConicRay}
      */
     this.particleVelocityDirection = new ConicRay();
+
+    /**
+     *
+     * @type {NumericInterval}
+     */
     this.particleSpeed = new NumericInterval(0, 0);
 
     /**
@@ -111,7 +118,6 @@ function ParticleLayer() {
      */
     this.isEmitting = true;
 
-
     /**
      * Simulation steps that are to be applied
      * @type {List<SimulationStepDefinition>}
@@ -173,7 +179,12 @@ ParticleLayer.prototype.computePointBoundingBox = function (result) {
     //displace by current position
     const position = this.position;
 
-    computeConeBoundingBox(aabb3, position.x, position.y, position.z, direction.x, direction.y, direction.z, particleVelocityDirection.angle, maxDisplacement);
+    computeConeBoundingBox(
+        aabb3,
+        position.x, position.y, position.z,
+        direction.x, direction.y, direction.z,
+        particleVelocityDirection.angle, maxDisplacement
+    );
 
     x0 = aabb3.x0;
     y0 = aabb3.y0;