@woosh/meep-engine 2.169.1 → 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/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.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,gBACF,MAAM,KAAK,MAAM,KAAK,MAAM,SAAS,MAAM,KAAK,IAAI,gCA4IlE;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";
 
@@ -50,39 +48,12 @@ export function distributeParticlesOnMesh(emitter, mesh, transform, randomSeed)
  */
 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"}

package/src/engine/graphics/postprocess/threejs/shaders/CopyShader.js

@@ -1,47 +1,15 @@
-/**
- * @author alteredq / http://alteredqualia.com/
- *
- * Full-screen textured quad shader
- */
-const CopyShader = {
-
-    uniforms: {
-
-        "tDiffuse": { type: "t", value: null },
-        "opacity": { type: "f", value: 1.0 }
-
-    },
-
-    vertexShader: [
-
-        "varying vec2 vUv;",
-
-        "void main() {",
-
-        "vUv = uv;",
-        "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-        "}"
-
-    ].join("\n"),
-
-    fragmentShader: [
-
-        "uniform float opacity;",
-
-        "uniform sampler2D tDiffuse;",
-
-        "varying vec2 vUv;",
-
-        "void main() {",
-
-        "vec4 texel = texture2D( tDiffuse, vUv );",
-        "gl_FragColor = opacity * texel;",
-
-        "}"
-
-    ].join("\n")
-
-};
-
-export default CopyShader;
+import CopyShaderFactory from "../../../shaders/CopyShader.js";
+
+/**
+ * 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.
+ */
+const CopyShader = CopyShaderFactory();
+
+export default CopyShader;

package/src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @example
+ *  await engine.plugins.acquire(AmbientOcclusionPostProcessEffect)
+ */
 export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
     __material: ShaderMaterial;
     /**

package/src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AmbientOcclusionPostProcessEffect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js"],"names":[],"mappings":"AAoBA;IAQQ,2BAQE;IAyBF;;;;OAIG;IACH,sBAA0B;IAE1B;;;;OAIG;IACH,2BAA6B;IAG7B;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,wBAA2B;IAE3B,8CAUE;IAEF;;;;OAIG;IACH,uBAAwB;IAExB;;;;;OAKG;IACH,2BASE;IAKF;;;;OAIG;IACH,0BAAwD;IAK5D;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;OAIG;IACH,oBAeC;IAMD;;;;OAIG;IACH,2BA2CC;IAED,uBASC;IAED;;;OAGG;IACH,iBAwBC;IAED;;;OAGG;IACH,4BAFW,OAAO,QAiCjB;IAED;;;;OAIG;IACH,gCASC;IAED;;;;OAIG;IACH,mCAUC;IAED;;;;;OAKG;IACH,qCAQC;IAGD,oCAiBC;CAuEJ;6BArb4B,uCAAuC;+BAD7D,OAAO;6CAAP,OAAO"}
+{"version":3,"file":"AmbientOcclusionPostProcessEffect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js"],"names":[],"mappings":"AAoBA;;;GAGG;AACH;IAQQ,2BAQE;IAyBF;;;;OAIG;IACH,sBAA0B;IAE1B;;;;OAIG;IACH,2BAA6B;IAG7B;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,wBAA2B;IAE3B,8CAUE;IAEF;;;;OAIG;IACH,uBAAwB;IAExB;;;;;OAKG;IACH,2BASE;IAKF;;;;OAIG;IACH,0BAAwD;IAK5D;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;OAIG;IACH,oBAeC;IAMD;;;;OAIG;IACH,2BA2CC;IAED,uBASC;IAED;;;OAGG;IACH,iBAwBC;IAED;;;OAGG;IACH,4BAFW,OAAO,QAiCjB;IAED;;;;OAIG;IACH,gCASC;IAED;;;;OAIG;IACH,mCAUC;IAED;;;;;OAKG;IACH,qCAQC;IAGD,oCAiBC;CAuEJ;6BAzb4B,uCAAuC;+BAD7D,OAAO;6CAAP,OAAO"}

package/src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js

@@ -18,6 +18,10 @@ import { generateHilbertNoiseTexture } from "./generateHilbertNoiseTexture.js";
 import { SAOShader } from "./SAOShader.js";
 import { SAOUpscaleShader } from "./SAOUpscaleShader.js";
 
+/**
+ * @example
+ *  await engine.plugins.acquire(AmbientOcclusionPostProcessEffect)
+ */
 export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
     constructor() {
         super();