@woosh/meep-engine 2.33.23 → 2.33.27

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

@@ -14,7 +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 { ParticleEmitterFlag } from "./ParticleEmitterFlag.js";
 import { AABB3 } from "../../../../../../core/bvh2/aabb3/AABB3.js";
 import {
@@ -35,6 +34,7 @@ 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();
 
@@ -59,6 +59,12 @@ const corners = new Float64Array(24);
  */
 const scratch_array = [];
 
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_v3_array = [];
+
 /**
  *
  * @param {ParameterSet} parameters
@@ -74,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() {
         /**
@@ -236,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()
         };
@@ -288,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);
@@ -343,8 +392,6 @@ export class ParticleEmitter {
             throw new Error('Layer not found');
         }
 
-        const numLayers = layers.length;
-
         const particles = this.particles;
         const occupancy = particles.occupancy;
 
@@ -358,9 +405,7 @@ export class ParticleEmitter {
 
             const layerPosition = particles.readAttributeScalar(i, PARTICLE_ATTRIBUTE_LAYER_POSITION);
 
-            const layerIndex = Math.round(layerPosition * numLayers);
-
-            if (layerIndex !== targetLayerIndex) {
+            if (layerPosition !== targetLayerIndex) {
                 // not the layer we want
                 continue;
             }
@@ -446,33 +491,15 @@ export class ParticleEmitter {
         //retire dead particles
         const particles = this.particles;
 
-        const liveParticleCount = particles.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;
-
-        for (let i = 0; i < liveParticleCount; i++) {
+        particles.computeAttributeVector3AxisAlignedBoundingBox(PARTICLE_ATTRIBUTE_POSITION, scratch_array);
 
-            particles.readAttributeVector3(i, PARTICLE_ATTRIBUTE_POSITION, position);
+        let bounds_x0 = scratch_array[0];
+        let bounds_y0 = scratch_array[1];
+        let bounds_z0 = scratch_array[2];
 
-            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();
@@ -837,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;
             }
@@ -891,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;
@@ -910,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);
@@ -969,24 +986,13 @@ 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);
 
@@ -1025,8 +1031,6 @@ export class ParticleEmitter {
 
         const emissionFunction = computeEmissionFunction(layer.emissionFrom, layer.emissionShape);
 
-        const layerPosition = layerIndex / layers.length;
-
         //compute transform matrix of the emitter
         composeMatrix4(matrix4, this.position, this.rotation, this.scale);
 
@@ -1039,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);
@@ -1097,25 +1103,13 @@ 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);
 

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/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() {
     /**

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

@@ -1,9 +1,12 @@
 import { BitSet } from "../../../../../../core/binary/BitSet.js";
 import { max3 } from "../../../../../../core/math/max3.js";
-import { itemSizeFromAttributeType, typedArrayConstructorFromDataType } from "../../group/ParticleGroup.js";
-import { BufferAttribute, BufferGeometry, DynamicDrawUsage } from 'three';
+import { BufferAttribute, BufferGeometry, StreamDrawUsage } from 'three';
 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;
@@ -11,13 +14,15 @@ const GROW_MIN_STEP = 32;
 export class ParticlePool {
     /**
      *
-     * @param {ParticleSpecification} spec
+     * @param {VertexDataSpec} spec
      * @constructor
      */
     constructor(spec) {
+        assert.equal(spec.isVertexDataSpec, true, 'spec.VertexDataSpec !== true');
+
         /**
          *
-         * @type {ParticleSpecification}
+         * @type {VertexDataSpec}
          */
         this.spec = spec;
 
@@ -215,15 +220,50 @@ 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;
             }
         }
     }
 
+    /**
+     *
+     * @param {AttributeSpec} spec
+     * @return {number}
+     * @private
+     */
+    __compute_attribute_byte_size(spec) {
+
+        const item_size = spec.itemSize;
+
+        const TypedArrayConstructor = compute_typed_array_constructor_from_data_type(spec.type);
+
+        const element_byte_size = TypedArrayConstructor.BYTES_PER_ELEMENT;
+
+        return item_size * element_byte_size * this.capacity;
+    }
+
+    /**
+     *
+     * @return {number}
+     * @private
+     */
+    __compute_attribute_byte_size_total() {
+
+        const spec_attributes = this.spec.attributes;
+        const l = spec_attributes.length;
+
+        let r = 0;
+        for (let i = 0; i < l; i++) {
+            r += this.__compute_attribute_byte_size(spec_attributes[i]);
+        }
+
+        return r;
+    }
+
     build() {
         const geometry = new BufferGeometry();
         geometry.dynamic = true;
@@ -234,25 +274,26 @@ export class ParticlePool {
         for (let i = 0; i < l; i++) {
 
             /**
-             * @type {ParticleAttribute}
+             * @type {AttributeSpec}
              */
             const attributeSpec = spec_attributes[i];
 
-            const itemSize = itemSizeFromAttributeType(attributeSpec.type);
-            const TypedArrayConstructor = typedArrayConstructorFromDataType(attributeSpec.dataType);
+            const itemSize = attributeSpec.itemSize;
+            const TypedArrayConstructor = compute_typed_array_constructor_from_data_type(attributeSpec.type);
 
             const newArrayLength = itemSize * this.capacity;
             const newArray = new TypedArrayConstructor(newArrayLength);
 
-            const attribute = this.attributes[i];
-            if (attribute !== undefined && attribute.count !== 0) {
+            const old_attribute = this.attributes[i];
+
+            if (old_attribute !== undefined && old_attribute.count !== 0) {
                 //copy old data
-                typed_array_copy(attribute.array, newArray);
+                typed_array_copy(old_attribute.array, newArray);
             }
 
-            const newAttribute = new BufferAttribute(newArray, itemSize);
+            const newAttribute = new BufferAttribute(newArray, itemSize, attributeSpec.normalized);
 
-            newAttribute.setUsage(DynamicDrawUsage);
+            newAttribute.setUsage(StreamDrawUsage);
             newAttribute.name = attributeSpec.name;
 
             this.attributes[i] = newAttribute;
@@ -466,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();
 

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

@@ -1,16 +1,17 @@
 import { ParticlePool } from "./ParticlePool.js";
-import { ParticleAttributeType, ParticleDataType, } from "../../group/ParticleGroup.js";
-import { ParticleSpecification } from "../../group/ParticleSpecification.js";
-import { ParticleAttribute } from "../../group/ParticleAttribute.js";
+import { VertexDataSpec } from "../../../../geometry/VertexDataSpec.js";
+import { DataType } from "../../../../../../core/collection/table/DataType.js";
+import { AttributeSpec } from "../../../../geometry/AttributeSpec.js";
 
 /**
  *
  * @returns {ParticlePool}
  */
 function samplePool() {
-    const specification = new ParticleSpecification();
-    specification.add(new ParticleAttribute('a', ParticleAttributeType.Scalar, ParticleDataType.Float32));
-    specification.add(new ParticleAttribute('b', ParticleAttributeType.Vector4, ParticleDataType.Float32));
+    const specification = new VertexDataSpec();
+
+    specification.add(AttributeSpec.fromJSON({name:'a', type:DataType.Float32, itemSize:1}));
+    specification.add(AttributeSpec.fromJSON({name:'b', type:DataType.Float32, itemSize:4}));
 
     const pool = new ParticlePool(specification);
 
@@ -184,4 +185,4 @@ test('read/write scalar attribute', () => {
     pool.writeAttributeScalar(1, 0, 42);
 
     expect(pool.readAttributeScalar(1, 0)).toBe(42);
-});
+});

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

@@ -10,7 +10,7 @@ import { randomPointOnBox } from "../../../../../../core/geom/random/randomPoint
  *
  * @param {EmissionFromType} emissionType
  * @param {EmissionShapeType} emissionShape
- * @returns {function(random: function, result:Vector3):void}
+ * @returns {function(random: function, result:(number[]|Float32Array|Float64Array), result_offset:number):void}
  */
 export function computeEmissionFunction(emissionType, emissionShape) {
     if (emissionShape === EmissionShapeType.Point) {

package/engine/graphics/particles/particular/engine/emitter/serde/ParameterLookupTableSerializationAdapter.js

@@ -86,10 +86,16 @@ export class ParameterLookupTableSerializationAdapter extends BinaryClassSeriali
 
         const dataLength = itemCount * value.itemSize;
 
-        const data = new Float32Array(dataLength);
+        /**
+         * Reserve a continuous chunk of memory for faster access
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer((dataLength + itemCount) * 4);
+
+        const data = new Float32Array(array_buffer, itemCount * 4, dataLength);
         buffer.readFloat32Array(data, 0, dataLength);
 
-        const positions = new Float32Array(itemCount);
+        const positions = new Float32Array(array_buffer, 0, itemCount);
         buffer.readFloat32Array(positions, 0, itemCount);
 
         value.write(data, positions);

package/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js

@@ -1,11 +1,12 @@
 import { inverseLerp } from "../../../../../../core/math/inverseLerp.js";
-import { computeHashFloatArray, computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
 import { assert } from "../../../../../../core/assert.js";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { min2 } from "../../../../../../core/math/min2.js";
 import { mix } from "../../../../../../core/math/mix.js";
 import { ParameterLookupTableFlags } from "./ParameterLookupTableFlags.js";
 import { ParameterLookupTableSerializationAdapter } from "../emitter/serde/ParameterLookupTableSerializationAdapter.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloatArray } from "../../../../../../core/math/hash/computeHashFloatArray.js";
 
 
 export class ParameterLookupTable {

package/engine/graphics/particles/particular/engine/parameter/ParameterTrack.js

@@ -5,8 +5,8 @@
  * @constructor
  */
 import { ParameterLookupTable } from "./ParameterLookupTable.js";
-import { computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
 import { computeStringHash } from "../../../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 export class ParameterTrack {
     constructor(name, lut) {

package/engine/graphics/particles/particular/engine/parameter/ParticleParameter.js

@@ -1,10 +1,10 @@
-import { computeHashIntegerArray} from "../../../../../../core/math/MathUtils.js";
 import { assert } from "../../../../../../core/assert.js";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { min2 } from "../../../../../../core/math/min2.js";
 import { ParameterLookupTable } from "./ParameterLookupTable.js";
 import List from "../../../../../../core/collection/list/List.js";
 import { computeStringHash } from "../../../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 
 export class ParticleParameter {

package/engine/graphics/particles/particular/engine/renderers/billboard/BILLBOARD_PARTICLE_SPECIFICATION.js

@@ -0,0 +1,24 @@
+import { VertexDataSpec } from "../../../../../geometry/VertexDataSpec.js";
+import { AttributeSpec } from "../../../../../geometry/AttributeSpec.js";
+import { DataType } from "../../../../../../../core/collection/table/DataType.js";
+
+export const BILLBOARD_PARTICLE_ATTRIBUTE_POSITION = 0;
+export const BILLBOARD_PARTICLE_ATTRIBUTE_UV = 1;
+export const BILLBOARD_PARTICLE_ATTRIBUTE_SIZE = 2;
+export const BILLBOARD_PARTICLE_ATTRIBUTE_VELOCITY = 3;
+export const BILLBOARD_PARTICLE_ATTRIBUTE_COLOR = 5;
+export const BILLBOARD_PARTICLE_ATTRIBUTE_BLEND = 6;
+
+export const BILLBOARD_PARTICLE_SPECIFICATION = new VertexDataSpec();
+
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'position', itemSize: 3, type: DataType.Float32 }));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({
+    name: 'atlasPatch',
+    itemSize: 4,
+    type: DataType.Float32
+}));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'size', itemSize: 1, type: DataType.Float32 }));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'velocity', itemSize: 3, type: DataType.Float32 }));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'rotation', itemSize: 1, type: DataType.Float32 }));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'color', itemSize: 1, type: DataType.Float32 }));
+BILLBOARD_PARTICLE_SPECIFICATION.add(AttributeSpec.fromJSON({ name: 'blending', itemSize: 1, type: DataType.Uint8 }));