@woosh/meep-engine 2.169.0 → 2.169.2

package/src/engine/graphics/particles/node-based/particle/ParticleAttributeSpecification.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../../../core/assert.js";
 import { ParticleDataTypes } from "../nodes/ParticleDataTypes.js";
+import { particle_data_type_component_count } from "../nodes/particle_data_type_component_count.js";
 
 export class ParticleAttributeSpecification {
 
@@ -21,19 +22,7 @@ export class ParticleAttributeSpecification {
      * @return {number}
      */
     computeComponentCount() {
-        switch (this.type) {
-            case ParticleDataTypes.Float:
-                return 1;
-            case ParticleDataTypes.Vector2:
-                return 2;
-            case ParticleDataTypes.Vector3:
-                return 3;
-            case ParticleDataTypes.Vector4:
-                return 4;
-
-            default:
-                throw new Error(`Unsupported data type '${this.type}'`);
-        }
+        return particle_data_type_component_count(this.type);
     }
 
     /**

package/src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.d.ts

@@ -146,10 +146,10 @@ export class ParticleEmitter {
     addLayer(layer: ParticleLayer): void;
     /**
      *
-     * @param {function(layer:ParticleLayer,index:number)} visitor
+     * @param {(layer: ParticleLayer, index: number) => void} visitor
      * @param {*} [thisArg]
      */
-    traverseLayers(visitor: any, thisArg?: any): void;
+    traverseLayers(visitor: (layer: ParticleLayer, index: number) => void, thisArg?: any): void;
     /**
      * Causes all active particles from a given layer to be destroyed immediately
      * @param {ParticleLayer} layer

package/src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEmitter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js"],"names":[],"mappings":"AA2FA;IA0iCI;;;;OAIG;IACH,4BAFa,eAAe,CAM3B;IAljCD;;OAEG;IACH,IAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,wBAAoB;IAEpB;;;OAGG;IACH,UAFU,OAAO,CAEe;IAChC,eAA6B;IAC7B,qBAAsC;IAEtC;;;;;OAKG;IACH,qCAA2C;IAE3C;;;;OAIG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,cAFU,YAAY,GAAC,MAAM,CAEM;IAEnC;;;OAGG;IACH,WAFU,YAAY,GAAC,IAAI,CAEV;IAEjB;;;OAGG;IACH,MAFU,WAAS,IAAI,CAEX;IAEZ;;;OAGG;IACH,mBAFU,SAAS,CAEQ;IAG3B;;;;OAIG;IACH,yBAFU,KAAK,CAE2E;IAE1F;;;OAGG;IACH,yBAFU,KAAK,CAE8B;IAG7C;;;OAGG;IACH,OAFU,MAAM,CAE6F;IAE7G;;;;OAIG;IACH,eAAW;IAGX;;;OAGG;IACH,qBAFU,YAAY,CAEU;IAWhC,wBAIC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,mBAAmB,GACxB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,mBAAmB,GACxB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,mBAAmB,SAC1B,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,mBAAmB,GACxB,OAAO,CAInB;IAED;;OAEG;IACH,gCAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;MAeC;IAED,0BAkEC;IAGD;;;OAGG;IACH,gBAFW,aAAa,QASvB;IAED;;;;OAIG;IACH,kDAUC;IAED;;;;OAIG;IACH,iCAHW,aAAa,GACZ,MAAM,CA2CjB;IAED,8BA0DC;IAED,8BAmBC;IAED,2BAmBC;IAED,6BAkBC;IAED;;;OAGG;IACH,uCAHW,MAAM,GACJ,MAAM,CA+BlB;IAED,cAuCC;IAED,mBA6BC;IAuBD,eAOC;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CASnB;IAED;;;;OAIG;IACH,qCA2FC;IAED,eAOC;IAED;;;OAGG;IACH,4BAFY,MAAM,CAejB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAiCD;;;;OAIG;IACH,sCA+GC;IAED;;;;OAIG;IACH,qCA6GC;IAED;;;OAGG;IACH,aA4CC;IAGD;;OAEG;IACH,gBAIC;;CAYJ;;;;;;;;;;;;;;;;oBAnoCmB,wCAAwC;uBAFrC,2CAA2C;6BAOrC,6CAA6C;6BAqB7C,mBAAmB;0BApCtB,+CAA+C;sBAInD,8CAA8C;6BAYvC,8BAA8B;oCAiBvB,0BAA0B;8BAChC,oBAAoB;uCAF3C,0BAA0B;6CAA1B,0BAA0B;kDAA1B,0BAA0B;4CAA1B,0BAA0B;4CAA1B,0BAA0B;kDAA1B,0BAA0B;wCAA1B,0BAA0B;sCAA1B,0BAA0B;4CAA1B,0BAA0B;AAWjC,yCAKC"}
+{"version":3,"file":"ParticleEmitter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js"],"names":[],"mappings":"AA2FA;IA0iCI;;;;OAIG;IACH,4BAFa,eAAe,CAM3B;IAljCD;;OAEG;IACH,IAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,wBAAoB;IAEpB;;;OAGG;IACH,UAFU,OAAO,CAEe;IAChC,eAA6B;IAC7B,qBAAsC;IAEtC;;;;;OAKG;IACH,qCAA2C;IAE3C;;;;OAIG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,cAFU,YAAY,GAAC,MAAM,CAEM;IAEnC;;;OAGG;IACH,WAFU,YAAY,GAAC,IAAI,CAEV;IAEjB;;;OAGG;IACH,MAFU,WAAS,IAAI,CAEX;IAEZ;;;OAGG;IACH,mBAFU,SAAS,CAEQ;IAG3B;;;;OAIG;IACH,yBAFU,KAAK,CAE2E;IAE1F;;;OAGG;IACH,yBAFU,KAAK,CAE8B;IAG7C;;;OAGG;IACH,OAFU,MAAM,CAE6F;IAE7G;;;;OAIG;IACH,eAAW;IAGX;;;OAGG;IACH,qBAFU,YAAY,CAEU;IAWhC,wBAIC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,mBAAmB,GACxB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,mBAAmB,GACxB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,mBAAmB,SAC1B,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,mBAAmB,GACxB,OAAO,CAInB;IAED;;OAEG;IACH,gCAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;MAeC;IAED,0BAkEC;IAGD;;;OAGG;IACH,gBAFW,aAAa,QASvB;IAED;;;;OAIG;IACH,gCAHmB,aAAa,SAAS,MAAM,KAAK,IAAI,uBAavD;IAED;;;;OAIG;IACH,iCAHW,aAAa,GACZ,MAAM,CA2CjB;IAED,8BA0DC;IAED,8BAmBC;IAED,2BAmBC;IAED,6BAkBC;IAED;;;OAGG;IACH,uCAHW,MAAM,GACJ,MAAM,CA+BlB;IAED,cAuCC;IAED,mBA6BC;IAuBD,eAOC;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CASnB;IAED;;;;OAIG;IACH,qCA2FC;IAED,eAOC;IAED;;;OAGG;IACH,4BAFY,MAAM,CAejB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAiCD;;;;OAIG;IACH,sCA+GC;IAED;;;;OAIG;IACH,qCA6GC;IAED;;;OAGG;IACH,aA4CC;IAGD;;OAEG;IACH,gBAIC;;CAYJ;;;;;;;;;;;;;;;;oBAnoCmB,wCAAwC;uBAFrC,2CAA2C;6BAOrC,6CAA6C;6BAqB7C,mBAAmB;0BApCtB,+CAA+C;sBAInD,8CAA8C;6BAYvC,8BAA8B;oCAiBvB,0BAA0B;8BAChC,oBAAoB;uCAF3C,0BAA0B;6CAA1B,0BAA0B;kDAA1B,0BAA0B;4CAA1B,0BAA0B;4CAA1B,0BAA0B;kDAA1B,0BAA0B;wCAA1B,0BAA0B;sCAA1B,0BAA0B;4CAA1B,0BAA0B;AAWjC,yCAKC"}

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

@@ -358,7 +358,7 @@ export class ParticleEmitter {
 
     /**
      *
-     * @param {function(layer:ParticleLayer,index:number)} visitor
+     * @param {(layer: ParticleLayer, index: number) => void} visitor
      * @param {*} [thisArg]
      */
     traverseLayers(visitor, thisArg) {

package/src/engine/graphics/particles/particular/engine/emitter/computeEmissionFunction.d.ts

@@ -2,9 +2,9 @@
  *
  * @param {EmissionFromType} emissionType
  * @param {EmissionShapeType} emissionShape
- * @returns {function(random: function, result:(number[]|Float32Array|Float64Array), result_offset:number):void}
+ * @returns {(random: function, result: (number[]|Float32Array|Float64Array), result_offset: number) => void}
  */
-export function computeEmissionFunction(emissionType: EmissionFromType, emissionShape: EmissionShapeType): (arg0: random) => Function;
+export function computeEmissionFunction(emissionType: EmissionFromType, emissionShape: EmissionShapeType): (random: Function, result: (number[] | Float32Array | Float64Array), result_offset: number) => void;
 import { EmissionFromType } from "./EmissionFromType.js";
 import { EmissionShapeType } from "./EmissionShapeType.js";
 //# sourceMappingURL=computeEmissionFunction.d.ts.map

package/src/engine/graphics/particles/particular/engine/emitter/computeEmissionFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeEmissionFunction.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/emitter/computeEmissionFunction.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sDAJW,gBAAgB,iBAChB,iBAAiB,8BAyB3B;iCAlCgC,uBAAuB;kCAFtB,wBAAwB"}
+{"version":3,"file":"computeEmissionFunction.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/emitter/computeEmissionFunction.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sDAJW,gBAAgB,iBAChB,iBAAiB,8BACY,CAAC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CAAC,iBAAiB,MAAM,KAAK,IAAI,CAwB3G;iCAlCgC,uBAAuB;kCAFtB,wBAAwB"}

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

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

package/src/engine/graphics/particles/particular/engine/utils/distributeParticlesOnObject3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"distributeParticlesOnObject3D.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/utils/distributeParticlesOnObject3D.js"],"names":[],"mappings":"AA6HA;;;;;GAKG;AACH,uDAJW,eAAe,QACf,MAAM,0BAyGhB;gCAvO+B,+BAA+B"}
+{"version":3,"file":"distributeParticlesOnObject3D.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/utils/distributeParticlesOnObject3D.js"],"names":[],"mappings":"AA8HA;;;;;GAKG;AACH,uDAJW,eAAe,QACf,MAAM,0BA0ChB;gCA3K+B,+BAA+B"}

package/src/engine/graphics/particles/particular/engine/utils/distributeParticlesOnObject3D.js

@@ -1,9 +1,10 @@
-import { seededRandom } from "../../../../../../core/math/random/seededRandom.js";
-import { computeMeshSurfaceArea } from "../../../../geometry/computeMeshSurfaceArea.js";
 import { ParticleEmitter } from "../emitter/ParticleEmitter.js";
 import { ParticleEmitterFlag } from "../emitter/ParticleEmitterFlag.js";
 import { computeSkinnedMeshVertices } from "../../../../geometry/skining/computeSkinnedMeshVertices.js";
-import { roundFair } from "../../../../../../core/math/random/roundFair.js";
+import {
+    distribute_points_on_indexed_triangles,
+    IDENTITY_TRANSFORM_ELEMENTS
+} from "./distribute_points_on_indexed_triangles.js";
 
 let buffer_points = new Float32Array();
 let buffer_indices = new Uint32Array();
@@ -149,86 +150,23 @@ export function distributeParticlesOnObject3D(emitter, seed, object) {
 
     const polygonCount = cursor_indices / 3;
 
-    const areas = new Float32Array(polygonCount);
-
-    const meshSurfaceArea = computeMeshSurfaceArea(areas, buffer_points, buffer_indices, polygonCount);
-
     const pool = emitter.particles;
 
     const particleCount = pool.size();
 
-    const surfaceSpacing = meshSurfaceArea / particleCount;
-    const invSurfaceSpacing = 1 / surfaceSpacing;
-
-    let placedPoints = 0;
-
     const PARTICLE_ATTRIBUTE_POSITION = ParticleEmitter.Attributes.PARTICLE_ATTRIBUTE_POSITION;
 
-    const random = seededRandom(seed);
-
-    poly: for (let i = 0; i < polygonCount; i++) {
-        const area = areas[i];
-
-        const placementCount = area * invSurfaceSpacing;
-
-        const roundedPlacementCount = roundFair(placementCount, random);
-
-        for (let j = 0; j < roundedPlacementCount; j++) {
-
-            //pick a point
-            const index3 = i * 3;
-
-            const a = buffer_indices[index3];
-            const b = buffer_indices[index3 + 1];
-            const c = buffer_indices[index3 + 2];
-
-            //read triangle points
-            const a3 = a * 3;
-
-            const ax = buffer_points[a3];
-            const ay = buffer_points[a3 + 1];
-            const az = buffer_points[a3 + 2];
-
-            const b3 = b * 3;
-
-            const bx = buffer_points[b3];
-            const by = buffer_points[b3 + 1];
-            const bz = buffer_points[b3 + 2];
-
-            const c3 = c * 3;
-
-            const cx = buffer_points[c3];
-            const cy = buffer_points[c3 + 1];
-            const cz = buffer_points[c3 + 2];
-
-            //pick random point on the triangle
-            // method from here: https://math.stackexchange.com/questions/538458/triangle-point-picking-in-3d
-            const cax = cx - ax;
-            const cay = cy - ay;
-            const caz = cz - az;
-
-            const bax = bx - ax;
-            const bay = by - ay;
-            const baz = bz - az;
-
-            //pick two random numbers
-            const r0 = random();
-            const r1 = random() * (1 - r0);
-
-
-            //compute random point
-            const x = ax + r0 * bax + r1 * cax;
-            const y = ay + r0 * bay + r1 * cay;
-            const z = az + r0 * baz + r1 * caz;
-
-            //place the point
-            pool.writeAttributeVector3(placedPoints, PARTICLE_ATTRIBUTE_POSITION, x, y, z);
-
-            placedPoints++;
-
-            if (placedPoints >= particleCount) {
-                break poly;
-            }
+    distribute_points_on_indexed_triangles(
+        particleCount,
+        buffer_points,
+        buffer_indices,
+        polygonCount,
+        // visitObject already baked each mesh's matrixWorld into buffer_points,
+        // so the sampled points need no further transform.
+        IDENTITY_TRANSFORM_ELEMENTS,
+        seed,
+        (x, y, z, index) => {
+            pool.writeAttributeVector3(index, PARTICLE_ATTRIBUTE_POSITION, x, y, z);
         }
-    }
+    );
 }

package/src/engine/graphics/particles/particular/engine/utils/distribute_points_on_indexed_triangles.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Scatter `count` points over an indexed triangle soup, distributed by area, and
+ * hand each one to `callback`.
+ *
+ * WHY THIS EXISTS
+ *
+ * `distributePointsOnMesh` and `distributeParticlesOnObject3D` each carried
+ * their own transcription of this loop — the same area-weighted `roundFair`
+ * budget, the same index/vertex fetch, and the same barycentric point pick down
+ * to the `r1 = random() * (1 - r0)` line and the source-URL comment. It is the
+ * only area-weighted triangle sampler in the codebase, so there is no reason
+ * for two of it. The two front-ends differ only in where the geometry comes
+ * from (one mesh, or a flattened hierarchy) and what they do with each point.
+ *
+ * DETERMINISM
+ *
+ * The PRNG is drawn in a fixed order — one `roundFair` per triangle, then `r0`
+ * and `r1` per placement — so the same `seed` and the same geometry always
+ * produce the same points. Do not add or reorder `random()` draws.
+ *
+ * This is a setup-time operation: emitters are seeded once when an effect
+ * spawns, not per frame.
+ *
+ * @param {number} count how many points to place; the sweep stops as soon as this many have been emitted
+ * @param {Float32Array|number[]} points xyz triples
+ * @param {Uint8Array|Uint16Array|Uint32Array|number[]} indices triangle vertex indices
+ * @param {number} polygon_count number of triangles to consider in `indices` (may be fewer than it holds)
+ * @param {number[]|Float32Array} transform_elements column-major 4x4 applied to each sampled point; see {@link IDENTITY_TRANSFORM_ELEMENTS}
+ * @param {number} seed
+ * @param {(x: number, y: number, z: number, index: number, polygon_index: number, r0: number, r1: number, a: number, b: number, c: number) => void} callback
+ * @param {*} [callback_context]
+ */
+export function distribute_points_on_indexed_triangles(count: number, points: Float32Array | number[], indices: Uint8Array | Uint16Array | Uint32Array | number[], polygon_count: number, transform_elements: number[] | Float32Array, seed: number, callback: (x: number, y: number, z: number, index: number, polygon_index: number, r0: number, r1: number, a: number, b: number, c: number) => void, callback_context?: any): void;
+/**
+ * Column-major 4x4 identity, in the element layout three.js `Matrix4.elements`
+ * uses.
+ *
+ * Callers whose points are already in the destination space pass this rather
+ * than the sampler taking a "no transform" mode: one code path, one meaning for
+ * the parameter.
+ *
+ * @type {number[]}
+ */
+export const IDENTITY_TRANSFORM_ELEMENTS: number[];
+//# sourceMappingURL=distribute_points_on_indexed_triangles.d.ts.map

package/src/engine/graphics/particles/particular/engine/utils/distribute_points_on_indexed_triangles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distribute_points_on_indexed_triangles.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/utils/distribute_points_on_indexed_triangles.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,8DATW,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,WACrB,UAAU,GAAC,WAAW,GAAC,WAAW,GAAC,MAAM,EAAE,iBAC3C,MAAM,sBACN,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,gBACF,MAAM,KAAK,MAAM,KAAK,MAAM,SAAS,MAAM,iBAAiB,MAAM,MAAM,MAAM,MAAM,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK,IAAI,gCAqHlJ;AAnKD;;;;;;;;;GASG;AACH,0CAFU,MAAM,EAAE,CAOhB"}

package/src/engine/graphics/particles/particular/engine/utils/distribute_points_on_indexed_triangles.js

@@ -0,0 +1,168 @@
+import { roundFair } from "../../../../../../core/math/random/roundFair.js";
+import { seededRandom } from "../../../../../../core/math/random/seededRandom.js";
+import { computeMeshSurfaceArea } from "../../../../geometry/computeMeshSurfaceArea.js";
+
+/**
+ * Column-major 4x4 identity, in the element layout three.js `Matrix4.elements`
+ * uses.
+ *
+ * Callers whose points are already in the destination space pass this rather
+ * than the sampler taking a "no transform" mode: one code path, one meaning for
+ * the parameter.
+ *
+ * @type {number[]}
+ */
+export const IDENTITY_TRANSFORM_ELEMENTS = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+];
+
+/**
+ * Scatter `count` points over an indexed triangle soup, distributed by area, and
+ * hand each one to `callback`.
+ *
+ * WHY THIS EXISTS
+ *
+ * `distributePointsOnMesh` and `distributeParticlesOnObject3D` each carried
+ * their own transcription of this loop — the same area-weighted `roundFair`
+ * budget, the same index/vertex fetch, and the same barycentric point pick down
+ * to the `r1 = random() * (1 - r0)` line and the source-URL comment. It is the
+ * only area-weighted triangle sampler in the codebase, so there is no reason
+ * for two of it. The two front-ends differ only in where the geometry comes
+ * from (one mesh, or a flattened hierarchy) and what they do with each point.
+ *
+ * DETERMINISM
+ *
+ * The PRNG is drawn in a fixed order — one `roundFair` per triangle, then `r0`
+ * and `r1` per placement — so the same `seed` and the same geometry always
+ * produce the same points. Do not add or reorder `random()` draws.
+ *
+ * This is a setup-time operation: emitters are seeded once when an effect
+ * spawns, not per frame.
+ *
+ * @param {number} count how many points to place; the sweep stops as soon as this many have been emitted
+ * @param {Float32Array|number[]} points xyz triples
+ * @param {Uint8Array|Uint16Array|Uint32Array|number[]} indices triangle vertex indices
+ * @param {number} polygon_count number of triangles to consider in `indices` (may be fewer than it holds)
+ * @param {number[]|Float32Array} transform_elements column-major 4x4 applied to each sampled point; see {@link IDENTITY_TRANSFORM_ELEMENTS}
+ * @param {number} seed
+ * @param {(x: number, y: number, z: number, index: number, polygon_index: number, r0: number, r1: number, a: number, b: number, c: number) => void} callback
+ * @param {*} [callback_context]
+ */
+export function distribute_points_on_indexed_triangles(
+    count,
+    points,
+    indices,
+    polygon_count,
+    transform_elements,
+    seed,
+    callback,
+    callback_context
+) {
+
+    const random = seededRandom(seed);
+
+    //read out relevant transform matrix elements for faster access
+    const tx0 = transform_elements[0];
+    const tx1 = transform_elements[1];
+    const tx2 = transform_elements[2];
+
+    const tx4 = transform_elements[4];
+    const tx5 = transform_elements[5];
+    const tx6 = transform_elements[6];
+
+    const tx8 = transform_elements[8];
+    const tx9 = transform_elements[9];
+    const tx10 = transform_elements[10];
+
+    const tx12 = transform_elements[12];
+    const tx13 = transform_elements[13];
+    const tx14 = transform_elements[14];
+
+    const areas = new Float32Array(polygon_count);
+
+    const surface_area = computeMeshSurfaceArea(areas, points, indices, polygon_count);
+
+    const surface_spacing = surface_area / count;
+    const inverse_surface_spacing = 1 / surface_spacing;
+
+    let placed_points = 0;
+
+    poly: for (let i = 0; i < polygon_count; i++) {
+        const area = areas[i];
+
+        const placement_count = area * inverse_surface_spacing;
+
+        const rounded_placement_count = roundFair(placement_count, random);
+
+        for (let j = 0; j < rounded_placement_count; j++) {
+
+            //pick a point
+            const index3 = i * 3;
+
+            const a = indices[index3];
+            const b = indices[index3 + 1];
+            const c = indices[index3 + 2];
+
+            //read triangle points
+            const a3 = a * 3;
+
+            const ax = points[a3];
+            const ay = points[a3 + 1];
+            const az = points[a3 + 2];
+
+            const b3 = b * 3;
+
+            const bx = points[b3];
+            const by = points[b3 + 1];
+            const bz = points[b3 + 2];
+
+            const c3 = c * 3;
+
+            const cx = points[c3];
+            const cy = points[c3 + 1];
+            const cz = points[c3 + 2];
+
+            // pick random point on the triangle using barycentric coordinates
+            // method from here: https://math.stackexchange.com/questions/538458/triangle-point-picking-in-3d
+            const cax = cx - ax;
+            const cay = cy - ay;
+            const caz = cz - az;
+
+            const bax = bx - ax;
+            const bay = by - ay;
+            const baz = bz - az;
+
+            //pick two random numbers
+            const r0 = random();
+            const r1 = random() * (1 - r0);
+
+            //compute random point
+            const x = ax + r0 * bax + r1 * cax;
+            const y = ay + r0 * bay + r1 * cay;
+            const z = az + r0 * baz + r1 * caz;
+
+            //apply transform
+            const _x = tx0 * x + tx4 * y + tx8 * z + tx12;
+            const _y = tx1 * x + tx5 * y + tx9 * z + tx13;
+            const _z = tx2 * x + tx6 * y + tx10 * z + tx14;
+
+            //place the point
+            callback.call(callback_context,
+                _x, _y, _z,
+                placed_points,
+                i,
+                r0, r1,
+                a, b, c
+            );
+
+            placed_points++;
+
+            if (placed_points >= count) {
+                break poly;
+            }
+        }
+    }
+}

package/src/engine/graphics/particles/particular/engine/utils/distrubuteParticlesOnMesh.d.ts

@@ -12,9 +12,9 @@ export function distributeParticlesOnMesh(emitter: ParticleEmitter, mesh: Mesh |
  * @param {Mesh} mesh
  * @param {Matrix4} transform
  * @param {number} randomSeed
- * @param {function(x:number,y:number,z:number,index:number)} callback
+ * @param {(x: number, y: number, z: number, index: number) => void} callback
  * @param {*} [callback_context]
  */
-export function distributePointsOnMesh(count: number, mesh: Mesh, transform: Matrix4, randomSeed: number, callback: any, callback_context?: any): void;
+export function distributePointsOnMesh(count: number, mesh: Mesh, transform: Matrix4, randomSeed: number, callback: (x: number, y: number, z: number, index: number) => void, callback_context?: any): void;
 import { ParticleEmitter } from "../emitter/ParticleEmitter.js";
 //# sourceMappingURL=distrubuteParticlesOnMesh.d.ts.map

package/src/engine/graphics/particles/particular/engine/utils/distrubuteParticlesOnMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"distrubuteParticlesOnMesh.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/utils/distrubuteParticlesOnMesh.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,mDALW,eAAe,QACf,kBAAgB,kCAEhB,MAAM,QA0BhB;AAGD;;;;;;;;GAQG;AACH,8CAPW,MAAM,8CAGN,MAAM,+CA6IhB;gCAvL+B,+BAA+B"}
+{"version":3,"file":"distrubuteParticlesOnMesh.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/utils/distrubuteParticlesOnMesh.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,mDALW,eAAe,QACf,kBAAgB,kCAEhB,MAAM,QA0BhB;AAGD;;;;;;;;GAQG;AACH,8CAPW,MAAM,8CAGN,MAAM,gBACF,MAAM,KAAK,MAAM,KAAK,MAAM,SAAS,MAAM,KAAK,IAAI,gCAsClE;gCAjF+B,+BAA+B"}

package/src/engine/graphics/particles/particular/engine/utils/distrubuteParticlesOnMesh.js

@@ -1,7 +1,5 @@
-import { roundFair } from "../../../../../../core/math/random/roundFair.js";
-import { seededRandom } from "../../../../../../core/math/random/seededRandom.js";
-import { computeMeshSurfaceArea } from "../../../../geometry/computeMeshSurfaceArea.js";
 import { computeSkinnedMeshVertices } from "../../../../geometry/skining/computeSkinnedMeshVertices.js";
+import { distribute_points_on_indexed_triangles } from "./distribute_points_on_indexed_triangles.js";
 import { ParticleEmitter } from "../emitter/ParticleEmitter.js";
 import { ParticleEmitterFlag } from "../emitter/ParticleEmitterFlag.js";
 
@@ -45,44 +43,17 @@ export function distributeParticlesOnMesh(emitter, mesh, transform, randomSeed)
  * @param {Mesh} mesh
  * @param {Matrix4} transform
  * @param {number} randomSeed
- * @param {function(x:number,y:number,z:number,index:number)} callback
+ * @param {(x: number, y: number, z: number, index: number) => void} callback
  * @param {*} [callback_context]
  */
 export function distributePointsOnMesh(count, mesh, transform, randomSeed, callback, callback_context) {
 
-    const random = seededRandom(randomSeed);
-
-    /**
-     *
-     * @type {number[]}
-     */
-    const m4_tx = transform.elements;
-
-    //read out relevant transform matrix elements for faster access
-    const tx0 = m4_tx[0];
-    const tx1 = m4_tx[1];
-    const tx2 = m4_tx[2];
-
-    const tx4 = m4_tx[4];
-    const tx5 = m4_tx[5];
-    const tx6 = m4_tx[6];
-
-    const tx8 = m4_tx[8];
-    const tx9 = m4_tx[9];
-    const tx10 = m4_tx[10];
-
-    const tx12 = m4_tx[12];
-    const tx13 = m4_tx[13];
-    const tx14 = m4_tx[14];
-
-
     /**
      *
      * @type {BufferGeometry}
      */
     const geometry = mesh.geometry;
 
-    //compute total surface area of the mesh
     const attributes = geometry.attributes;
 
     const aPosition = attributes.position;
@@ -100,89 +71,14 @@ export function distributePointsOnMesh(count, mesh, transform, randomSeed, callb
         points = aPosition.array;
     }
 
-    const areas = new Float32Array(polygonCount);
-
-    const meshSurfaceArea = computeMeshSurfaceArea(areas, points, indices);
-
-    const surfaceSpacing = meshSurfaceArea / count;
-    const invSurfaceSpacing = 1 / surfaceSpacing;
-
-    let placedPoints = 0;
-
-    poly: for (let i = 0; i < polygonCount; i++) {
-        const area = areas[i];
-
-        const placementCount = area * invSurfaceSpacing;
-
-        const roundedPlacementCount = roundFair(placementCount, random);
-
-        for (let j = 0; j < roundedPlacementCount; j++) {
-
-            //pick a point
-            const index3 = i * 3;
-
-            const a = indices[index3];
-            const b = indices[index3 + 1];
-            const c = indices[index3 + 2];
-
-            //read triangle points
-            const a3 = a * 3;
-
-            const ax = points[a3];
-            const ay = points[a3 + 1];
-            const az = points[a3 + 2];
-
-            const b3 = b * 3;
-
-            const bx = points[b3];
-            const by = points[b3 + 1];
-            const bz = points[b3 + 2];
-
-            const c3 = c * 3;
-
-            const cx = points[c3];
-            const cy = points[c3 + 1];
-            const cz = points[c3 + 2];
-
-            // pick random point on the triangle using barycentric coordinates
-            // method from here: https://math.stackexchange.com/questions/538458/triangle-point-picking-in-3d
-            const cax = cx - ax;
-            const cay = cy - ay;
-            const caz = cz - az;
-
-            const bax = bx - ax;
-            const bay = by - ay;
-            const baz = bz - az;
-
-            //pick two random numbers
-            const r0 = random();
-            const r1 = random() * (1 - r0);
-
-
-            //compute random point
-            const x = ax + r0 * bax + r1 * cax;
-            const y = ay + r0 * bay + r1 * cay;
-            const z = az + r0 * baz + r1 * caz;
-
-            //apply transform
-            const _x = tx0 * x + tx4 * y + tx8 * z + tx12;
-            const _y = tx1 * x + tx5 * y + tx9 * z + tx13;
-            const _z = tx2 * x + tx6 * y + tx10 * z + tx14;
-
-            //place the point
-            callback.call(callback_context,
-                _x, _y, _z,
-                placedPoints,
-                i,
-                r0, r1,
-                a, b, c
-            );
-
-            placedPoints++;
-
-            if (placedPoints >= count) {
-                break poly;
-            }
-        }
-    }
+    distribute_points_on_indexed_triangles(
+        count,
+        points,
+        indices,
+        polygonCount,
+        transform.elements,
+        randomSeed,
+        callback,
+        callback_context
+    );
 }

package/src/engine/graphics/postprocess/threejs/shaders/CopyShader.d.ts

@@ -1,18 +1,26 @@
 export default CopyShader;
-declare namespace CopyShader {
-    namespace uniforms {
-        namespace tDiffuse {
-            let type: string;
-            let value: any;
-        }
-        namespace opacity {
-            let type_1: string;
-            export { type_1 as type };
-            let value_1: number;
-            export { value_1 as value };
-        }
-    }
-    let vertexShader: string;
-    let fragmentShader: string;
-}
+/**
+ * Full-screen textured quad shader.
+ *
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * @deprecated this module used to be a byte-identical copy of `engine/graphics/shaders/CopyShader.js`
+ * - same uniforms, same vertex and fragment source, differing only in shape (frozen object here,
+ * zero-arg factory there). It is kept as a shared instance of the factory's output so existing
+ * importers keep working; use `engine/graphics/shaders/CopyShader.js` directly instead.
+ */
+declare const CopyShader: {
+    uniforms: {
+        tDiffuse: {
+            type: string;
+            value: any;
+        };
+        opacity: {
+            type: string;
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
 //# sourceMappingURL=CopyShader.d.ts.map

package/src/engine/graphics/postprocess/threejs/shaders/CopyShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CopyShader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/postprocess/threejs/shaders/CopyShader.js"],"names":[],"mappings":""}
+{"version":3,"file":"CopyShader.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/postprocess/threejs/shaders/CopyShader.js"],"names":[],"mappings":";AAEA;;;;;;;;;GASG;AACH;;;;;;;;;;;;;EAAuC"}