@woosh/meep-engine 2.27.0 → 2.30.0

package/engine/asset/AssetManager.js

@@ -293,7 +293,7 @@ AssetManager.prototype.hasLoaderForType = function (type) {
  * @returns {AssetLoader|undefined}
  */
 AssetManager.prototype.getLoaderByType = function (type) {
-    assert.typeOf(type, 'string', 'type');
+    assert.isString(type, 'type');
 
     return this.loaders[type];
 };
@@ -305,9 +305,20 @@ AssetManager.prototype.getLoaderByType = function (type) {
  * @throws if a loader is already registered for the given type
  */
 AssetManager.prototype.registerLoader = async function (type, loader) {
+    assert.isString(type, 'type');
+
+    const existing_loader = this.getLoaderByType(type);
 
-    if (this.getLoaderByType(type) !== undefined) {
-        throw new Error(`Loader for type '${type}' is already registered`);
+    if (existing_loader !== undefined) {
+        if (existing_loader === loader) {
+            // all is well, already registered
+            return existing_loader;
+        } else if (existing_loader.__proto__ === loader.__proto__) {
+            console.warn(`Another instance of this loader is already registered for type '${type}'. Ignoring.`);
+            return existing_loader;
+        } else {
+            throw new Error(`Loader for type '${type}' is already registered`);
+        }
     }
 
     if (typeof loader === "function") {

package/engine/asset/loaders/image/codec/CodecWithFallback.js

@@ -17,7 +17,7 @@ export class CodecWithFallback extends Codec {
     async decode(data) {
 
         try {
-            return this.main.decode(data);
+            return await this.main.decode(data);
         } catch (e) {
             logger.warn(`Main codec failed, will attempt fallback. Error: ${e}`);
 

package/engine/asset/loaders/image/png/PNGReader.js

@@ -7,19 +7,6 @@ import { PNG } from './PNG.js';
 import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
 
-var inflate = function (data, callback) {
-    let result;
-
-    try {
-        result = zlib.inflate(new Uint8Array(data));
-
-        callback(null, result);
-    } catch (e) {
-        callback(e);
-    }
-
-};
-
 function readUInt32(buffer, offset) {
     return (buffer[offset] << 24) +
         (buffer[offset + 1] << 16) +
@@ -294,11 +281,14 @@ PNGReader.prototype.unFilterNone = function (scanline, scanline_offset, pixels,
 PNGReader.prototype.unFilterSub = function (scanline, scanline_offset, pixels, bpp, of, length) {
     var i = 0;
 
-    for (; i < bpp; i++) pixels[of + i] = scanline[i + scanline_offset];
+    for (; i < bpp; i++) {
+        pixels[of + i] = scanline[i + scanline_offset];
+    }
 
     for (; i < length; i++) {
         // Raw(x) + Raw(x - bpp)
-        pixels[of + i] = (scanline[i + scanline_offset] + pixels[of + i - bpp]) & 0xFF;
+        const of_i = of + i;
+        pixels[of_i] = (scanline[i + scanline_offset] + pixels[of_i - bpp]) & 0xFF;
     }
 };
 
@@ -336,19 +326,26 @@ PNGReader.prototype.unFilterAverage = function (scanline, scanline_offset, pixel
         }
         // Prior(x) == 0 && Raw(x - bpp) != 0 (right shift, prevent doubles)
         for (; i < length; i++) {
-            pixels[of + i] = (scanline[i + scanline_offset] + (pixels[of + i - bpp] >> 1)) & 0xFF;
+            const of_i = of + i;
+            pixels[of_i] = (scanline[i + scanline_offset] + (pixels[of_i - bpp] >> 1)) & 0xFF;
         }
     } else {
         // Prior(x) != 0 && Raw(x - bpp) == 0
         for (; i < bpp; i++) {
-            pixels[of + i] = (scanline[i + scanline_offset] + (pixels[of - length + i] >> 1)) & 0xFF;
+            const of_i = of + i;
+
+            pixels[of_i] = (scanline[i + scanline_offset] + (pixels[of_i - length] >> 1)) & 0xFF;
         }
         // Prior(x) != 0 && Raw(x - bpp) != 0
         for (; i < length; i++) {
             byte = scanline[i + scanline_offset];
-            prev = pixels[of + i - bpp];
-            prior = pixels[of + i - length];
-            pixels[of + i] = (byte + (prev + prior >> 1)) & 0xFF;
+
+            const of_i = of + i;
+
+            prev = pixels[of_i - bpp];
+            prior = pixels[of_i - length];
+
+            pixels[of_i] = (byte + (prev + prior >> 1)) & 0xFF;
         }
     }
 };
@@ -387,10 +384,11 @@ PNGReader.prototype.unFilterPaeth = function (scanline, scanline_offset, pixels,
             pixels[of + i] = (scanline[i + scanline_offset] + pixels[of + i - bpp]) & 0xFF;
         }
     } else {
+        const of1 = of - length;
         // Prior(x) != 0 && Raw(x - bpp) == 0
         // paethPredictor(x, 0, 0) is always x
         for (; i < bpp; i++) {
-            pixels[of + i] = (scanline[i + scanline_offset] + pixels[of + i - length]) & 0xFF;
+            pixels[of + i] = (scanline[i + scanline_offset] + pixels[of1 + i]) & 0xFF;
         }
         // Prior(x) != 0 && Raw(x - bpp) != 0
         for (; i < length; i++) {

package/engine/ecs/EntityManager.js

@@ -699,6 +699,16 @@ EntityManager.prototype.startSystem = function (system, successCallback, errorCa
  * @param {function} errorCallback executed if entity manager encounters an error during startup
  */
 EntityManager.prototype.startup = function (readyCallback, errorCallback) {
+    if (this.state === EntityManagerState.Starting) {
+        throw new IllegalStateException(`System is currently in starting state`);
+    }
+
+    if (this.state === EntityManagerState.Running) {
+        // already running, do nothing
+        readyCallback();
+        return;
+    }
+
     assert.isFunction(readyCallback, 'readyCallback');
     assert.isFunction(errorCallback, 'errorCallback');
 

package/engine/ecs/terrain/overlay/TerrainOverlay.js

@@ -224,7 +224,14 @@ export class TerrainOverlay {
 
         const ctx = this.context2d;
 
-        const imageData = ctx.createImageData(this.size.x, this.size.y);
+        const size = this.size;
+
+        if (size.x === 0 || size.y === 0) {
+            // nothing to write
+            return;
+        }
+
+        const imageData = ctx.createImageData(size.x, size.y);
 
         const array = imageData.data;
 

package/engine/graphics/camera/makeOrbitalCameraController.js

@@ -1,4 +1,4 @@
-import TopDownCameraController from "../ecs/camera/topdown/TopDownCameraController.js";
+import TopDownCameraController, { rotate_from_view } from "../ecs/camera/topdown/TopDownCameraController.js";
 import InputController from "../../input/ecs/components/InputController.js";
 import { decodeMouseEventButtons } from "../../input/devices/PointerDevice.js";
 import EntityBuilder from "../../ecs/EntityBuilder.js";
@@ -34,8 +34,7 @@ export function makeOrbitalCameraController({
 
         const cameraController = getCameraController();
 
-        cameraController.yaw += delta.x * sensitivity;
-        cameraController.pitch -= delta.y * sensitivity;
+        rotate_from_view(delta.x * sensitivity, delta.y * sensitivity, cameraController, cameraController);
     }
 
     /**

package/engine/graphics/ecs/camera/topdown/ComputeCameraFacingVector.js

@@ -0,0 +1,21 @@
+import Quaternion from "../../../../../core/geom/Quaternion.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+
+const q = new Quaternion();
+
+/**
+ *
+ * @param {number} yaw
+ * @param {number} pitch
+ * @param roll
+ * @param {Vector3} result
+ */
+export function computeCameraFacingVector(yaw, pitch, roll, result) {
+    q.__setFromEuler(pitch, yaw, roll, 'ZYX');
+    q.normalize();
+
+    result.copy(Vector3.forward);
+    result.applyQuaternion(q);
+    result.normalize();
+
+}

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.d.ts

@@ -28,4 +28,6 @@ export default class TopDownCameraController {
     public fromJSON(j: any): void
 
     static pan(delta: Vector2, object: Object3D, element: Element, targetDistance: number, fov: number, result: Vector3, multiplier?: Vector3): void
+
+    static rotate(delta_x: number, delta_y: number, input: TopDownCameraController, output: TopDownCameraController): void
 }

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.js

@@ -10,9 +10,34 @@ import { Euler, Matrix4 } from "three";
 
 const m4 = new Matrix4();
 const euler = new Euler();
+const scratch_vector3 = new Vector3();
 
 const panOffset = new Vector3();
 
+/**
+ *
+ * @param {number} displacement_x
+ * @param {number} displacement_y
+ * @param {TopDownCameraController} input
+ * @param {TopDownCameraController} output rotation delta
+ */
+export function rotate_from_view(displacement_x, displacement_y, input, output) {
+
+    euler.set(input.pitch, input.yaw, input.roll)
+    m4.makeRotationFromEuler(euler);
+
+    const up = scratch_vector3;
+    scratch_vector3.copy(Vector3.up);
+
+    up.applyMatrix4_three(m4);
+
+    // detect when camera is upside-down
+    const y_multiplier = up.y <= 0 ? -1 : 1;
+
+    output.pitch -= displacement_y;
+    output.yaw += displacement_x * y_multiplier;
+}
+
 /**
  * pass in distance in world space to move left
  * @param {number} distance
@@ -236,6 +261,7 @@ class TopDownCameraController {
 TopDownCameraController.typeName = "TopDownCameraController";
 
 TopDownCameraController.pan = pan;
+TopDownCameraController.rotate = rotate_from_view;
 
 export default TopDownCameraController;
 

package/engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js

@@ -13,7 +13,6 @@ import { System } from '../../../../ecs/System.js';
 import TopDownCameraController from './TopDownCameraController.js';
 
 import { Euler as ThreeEuler } from 'three';
-import Quaternion from "../../../../../core/geom/Quaternion.js";
 
 
 const v3_scratch = new Vector3();
@@ -74,25 +73,6 @@ export function computeTopDownTransform(control, result) {
     result.position.copy(v3_scratch);
 }
 
-const q = new Quaternion();
-
-/**
- *
- * @param {number} yaw
- * @param {number} pitch
- * @param roll
- * @param {Vector3} result
- */
-export function computeCameraFacingVector(yaw, pitch, roll, result) {
-    q.__setFromEuler(pitch, yaw, roll, 'ZYX');
-    q.normalize();
-
-    result.copy(Vector3.forward);
-    result.applyQuaternion(q);
-    result.normalize();
-
-}
-
 /**
  *
  * @param {Transform} transform
@@ -123,11 +103,11 @@ export function setCameraControllerFromTransform(transform, controller, distance
 
     controller.distance = distance;
 
-    const targetOffset = direction.clone()
-        .multiplyScalar(controller.distance);
+    const targetOffset = direction.clone();
+    targetOffset.multiplyScalar(controller.distance);
 
-    const target = transform.position.clone()
-        .sub(targetOffset);
+    const target = transform.position.clone();
+    target.sub(targetOffset);
 
     controller.target.copy(target)
 }

package/engine/graphics/ecs/mesh/applyTransform.js

@@ -1,9 +1,5 @@
 import { Transform } from "../../../ecs/transform/Transform.js";
-import { copyToVector3 } from "./copyToVector3.js";
-import { setThreeObjectRotation } from "./setThreeObjectRotation.js";
 import { setTransform } from "./setTransform.js";
-import { updateMeshTransform } from "./updateMeshTransform.js";
-import { updateNodeByTransformAndBBB } from "./updateNodeByTransformAndBBB.js";
 
 /**
  * @readonly
@@ -27,10 +23,12 @@ export function applyTransform(component, transform) {
      */
     let _t;
 
-    if (component.asset.has_root_transform) {
+    const asset = component.asset;
+
+    if (asset.has_root_transform) {
         _t = scratch_transform;
 
-        _t.multiplyTransforms(component.asset.root_transform, transform);
+        _t.multiplyTransforms(transform, asset.root_transform);
 
         // console.log("root transform");
     } else {
@@ -38,4 +36,4 @@ export function applyTransform(component, transform) {
     }
 
     setTransform(_t, component);
-}
+}

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

@@ -132,6 +132,7 @@ ParticularEngine.prototype.advanceEmitter = function (emitter, timeDelta) {
 
             const step = steps[type];
 
+            step.emitter = emitter;
             step.timeDelta = timeDelta;
             step.particles = emitter.particles;
             step.layer_parameters[j] = stepDefinition.parameters;

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

@@ -0,0 +1,8 @@
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const EmissionFromType = {
+    Shell: 0,
+    Volume: 1
+};

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

@@ -0,0 +1,9 @@
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const EmissionShapeType = {
+    Sphere: 0,
+    Box: 1,
+    Point: 3
+};

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

@@ -3,7 +3,10 @@ export const PARTICLE_ATTRIBUTE_AGE = 1;
 export const PARTICLE_ATTRIBUTE_DEATH_AGE = 2;
 export const PARTICLE_ATTRIBUTE_UV = 3;
 export const PARTICLE_ATTRIBUTE_SIZE = 4;
+export const PARTICLE_ATTRIBUTE_SIZE_INITIAL = 11;
 export const PARTICLE_ATTRIBUTE_LAYER_POSITION = 5;
 export const PARTICLE_ATTRIBUTE_VELOCITY = 6;
 export const PARTICLE_ATTRIBUTE_ROTATION = 7;
 export const PARTICLE_ATTRIBUTE_ROTATION_SPEED = 8;
+export const PARTICLE_ATTRIBUTE_COLOR = 9;
+export const PARTICLE_ATTRIBUTE_BLEND = 10;

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

@@ -4,13 +4,6 @@ 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 {
-    randomPointInBox,
-    randomPointInPoint,
-    randomPointInSphere,
-    randomPointOnBox,
-    randomPointOnSphere
-} from "../../../../../../core/geom/GeometryMath.js";
 import { Box3, BufferGeometry, Frustum, Matrix4, Points, PointsMaterial } from 'three';
 import { frustumFromCamera } from "../../../../ecs/camera/CameraSystem.js";
 import { ParticlePool } from "./ParticlePool.js";
@@ -18,28 +11,37 @@ import { ParticleParameter } from "../parameter/ParticleParameter.js";
 import { ParameterSet } from "../parameter/ParameterSet.js";
 import { assert } from "../../../../../../core/assert.js";
 import { LeafNode } from "../../../../../../core/bvh2/LeafNode.js";
-import { EmissionFromType, EmissionShapeType, ParticleLayer } from "./ParticleLayer.js";
+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 { 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 {
     PARTICLE_ATTRIBUTE_AGE,
+    PARTICLE_ATTRIBUTE_BLEND,
     PARTICLE_ATTRIBUTE_DEATH_AGE,
     PARTICLE_ATTRIBUTE_LAYER_POSITION,
     PARTICLE_ATTRIBUTE_POSITION,
     PARTICLE_ATTRIBUTE_ROTATION,
     PARTICLE_ATTRIBUTE_ROTATION_SPEED,
     PARTICLE_ATTRIBUTE_SIZE,
+    PARTICLE_ATTRIBUTE_SIZE_INITIAL,
     PARTICLE_ATTRIBUTE_UV,
     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";
 
 const EMPTY_GEOMETRY = new BufferGeometry();
 
@@ -635,7 +637,7 @@ export class ParticleEmitter {
 
     build() {
 
-        this.particles = new ParticlePool(particleSpecification);
+        this.particles = new ParticlePool(PARTICULAR_PARTICLE_SPECIFICATION);
 
         //make overallocation a bit more aggressive to prevent frequent resizing
         this.particles.shrinkFactor = 0.5;
@@ -934,7 +936,10 @@ export class ParticleEmitter {
         const layerPosition = layerIndex / this.layers.length;
 
         //compute transform matrix of the emitter
-        composeMatrix4(matrix4, this.position, this.rotation, this.scale);
+        const emitter_position = this.position;
+        const last_spawn_position = this.__lastSpawnPosition;
+
+        composeMatrix4(matrix4, emitter_position, this.rotation, this.scale);
 
         let time = -layer.timeSinceLastEmission;
 
@@ -955,9 +960,9 @@ export class ParticleEmitter {
 
             if (this.getFlag(ParticleEmitterFlag.PositionChanged)) {
                 //compute position in between
-                matrix4.elements[12] = lerp(this.position.x, this.__lastSpawnPosition.x, f);
-                matrix4.elements[13] = lerp(this.position.y, this.__lastSpawnPosition.y, f);
-                matrix4.elements[14] = lerp(this.position.z, this.__lastSpawnPosition.z, f);
+                matrix4.elements[12] = lerp(emitter_position.x, last_spawn_position.x, f);
+                matrix4.elements[13] = lerp(emitter_position.y, last_spawn_position.y, f);
+                matrix4.elements[14] = lerp(emitter_position.z, last_spawn_position.z, f);
             }
 
             //apply emitter transform
@@ -1001,17 +1006,22 @@ export class ParticleEmitter {
             //write particle size
             const size = layer.particleSize.sampleRandom(random);
 
-            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_SIZE, size);
+            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_SIZE_INITIAL, size);
 
             //write UV
             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;
+                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);
             } else {
@@ -1019,6 +1029,10 @@ export class ParticleEmitter {
             }
 
             particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_LAYER_POSITION, layerPosition);
+
+            update_parameters(ref, particles, layer, initialAge / deathAge);
+
+            particles.writeAttributeScalar(ref,PARTICLE_ATTRIBUTE_BLEND,this.blendingMode);
         }
 
         //update time buffer
@@ -1116,7 +1130,7 @@ export class ParticleEmitter {
             //write size
             const size = layer.particleSize.sampleRandom(random);
 
-            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_SIZE, size);
+            particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_SIZE_INITIAL, size);
 
             //write UV
             const atlasPatch = layer.__atlasPatch;
@@ -1125,10 +1139,15 @@ export class ParticleEmitter {
                 //patch exists, write it
                 const uv = atlasPatch.uv;
 
-                const u0 = uv.position.x;
-                const v0 = uv.position.y;
-                const u1 = uv.size.x;
-                const v1 = uv.size.y;
+                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);
             } else {
@@ -1138,6 +1157,9 @@ export class ParticleEmitter {
 
             particles.writeAttributeScalar(ref, PARTICLE_ATTRIBUTE_LAYER_POSITION, layerPosition);
 
+            update_parameters(ref, particles, layer, initialAge / deathAge);
+
+            particles.writeAttributeScalar(ref,PARTICLE_ATTRIBUTE_BLEND,this.blendingMode);
         }
 
         if (spritesNeedUpdate) {
@@ -1240,17 +1262,20 @@ const defaultPointsMaterial = new PointsMaterial({ color: 0xFFFFFF });
 
 
 //build particle spec
-const particleSpecification = new ParticleSpecification();
-
-particleSpecification.add(new ParticleAttribute('position', ParticleAttributeType.Vector3, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('age', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('deathAge', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('atlasPatch', ParticleAttributeType.Vector4, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('size', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('layerPosition', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('velocity', ParticleAttributeType.Vector3, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('rotation', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-particleSpecification.add(new ParticleAttribute('rotationSpeed', ParticleAttributeType.Scalar, ParticleDataType.Float32));
+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();

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

@@ -10,25 +10,8 @@ import List from "../../../../../../core/collection/list/List.js";
 import { SimulationStepType } from "../simulator/SimulationStepType.js";
 import { computeStringHash } from "../../../../../../core/primitives/strings/computeStringHash.js";
 import { computeConeBoundingBox } from "../../../../../../core/geom/3d/cone/computeConeBoundingBox.js";
-
-/**
- * @readonly
- * @enum {number}
- */
-const EmissionShapeType = {
-    Sphere: 0,
-    Box: 1,
-    Point: 3
-};
-
-/**
- * @readonly
- * @enum {number}
- */
-const EmissionFromType = {
-    Shell: 0,
-    Volume: 1
-};
+import { EmissionFromType } from "./EmissionFromType.js";
+import { EmissionShapeType } from "./EmissionShapeType.js";
 
 function ParticleLayer() {
     /**
@@ -97,7 +80,16 @@ function ParticleLayer() {
      */
     this.parameterTracks = new ParameterTrackSet();
 
+    /**
+     *
+     * @type {Vector3}
+     */
     this.position = new Vector3(0, 0, 0);
+
+    /**
+     *
+     * @type {Vector3}
+     */
     this.scale = new Vector3(1, 1, 1);
 
     /**
@@ -127,6 +119,11 @@ function ParticleLayer() {
     this.steps = new List();
 
     this.scaledSpriteHalfSize = -1;
+
+    /**
+     *
+     * @type {AABB3}
+     */
     this.baseBoundingBox = new AABB3(0, 0, 0, 0, 0, 0);
 }
 
@@ -381,4 +378,4 @@ ParticleLayer.prototype.fromBinaryBuffer = function (buffer) {
     this.scaledSpriteHalfSize = -1;
 };
 
-export { ParticleLayer, EmissionShapeType, EmissionFromType };
+export { ParticleLayer };

package/engine/graphics/particles/particular/engine/emitter/ParticleLayer.spec.js

@@ -1,7 +1,9 @@
-import { EmissionFromType, EmissionShapeType, ParticleLayer } from "./ParticleLayer.js";
+import { ParticleLayer } from "./ParticleLayer.js";
 import { ParameterLookupTable } from "../parameter/ParameterLookupTable.js";
 import { ParameterTrack } from "../parameter/ParameterTrack.js";
 import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
+import { EmissionFromType } from "./EmissionFromType.js";
+import { EmissionShapeType } from "./EmissionShapeType.js";
 
 function sampleA() {
     const layer0 = new ParticleLayer();