@woosh/meep-engine 2.33.20 → 2.33.24

package/engine/graphics/particles/particular/group/ParticleGroup.js

@@ -11,95 +11,13 @@ import {
     InstancedBufferGeometry
 } from "three";
 import ObservedValue from "../../../../../core/model/ObservedValue.js";
+import { typedArrayConstructorFromDataType } from "./typedArrayConstructorFromDataType.js";
+import { itemSizeFromAttributeType } from "./itemSizeFromAttributeType.js";
+import { OperationType } from "./OperationType.js";
+import { Operation } from "./Operation.js";
+import { optimizeCommandQueue } from "./optimizeCommandQueue.js";
 
 
-/**
- *
- * @enum {number}
- */
-const ParticleDataType = {
-    Float32: 0,
-    Float64: 1,
-    Uint8: 2
-};
-
-/**
- *
- * @enum {number}
- */
-const ParticleAttributeType = {
-    Scalar: 1,
-    Vector2: 2,
-    Vector3: 3,
-    Vector4: 4
-};
-
-/**
- *
- * @enum {number}
- */
-const OperationType = {
-    Remove: 0,
-    Add: 1,
-    WriteAttribute: 2
-};
-
-/**
- *
- * @param {OperationType} operator
- * @param {Array} operands
- * @constructor
- */
-function Operation(operator, operands) {
-    /**
-     *
-     * @type {OperationType}
-     */
-    this.operator = operator;
-    /**
-     *
-     * @type {Array}
-     */
-    this.operands = operands;
-}
-
-/**
- *
- * @param {ParticleAttributeType} type
- */
-export function itemSizeFromAttributeType(type) {
-    switch (type) {
-        case ParticleAttributeType.Scalar:
-            return 1;
-        case ParticleAttributeType.Vector2:
-            return 2;
-        case ParticleAttributeType.Vector3:
-            return 3;
-        case ParticleAttributeType.Vector4:
-            return 4;
-        default:
-            throw new Error(`Unsupported attribute type: ${type}`);
-    }
-}
-
-/**
- *
- * @param {ParticleDataType} type
- * @returns {*}
- */
-export function typedArrayConstructorFromDataType(type) {
-    switch (type) {
-        case ParticleDataType.Float32:
-            return Float32Array;
-        case ParticleDataType.Float64:
-            return Float64Array;
-        case ParticleDataType.Uint8:
-            return Uint8Array;
-        default:
-            throw new Error(`Unsupported type: ${type}`);
-    }
-}
-
 /**
  *
  * @param {ParticleSpecification} spec
@@ -264,161 +182,7 @@ ParticleGroup.prototype.update = function () {
 };
 
 ParticleGroup.prototype.optimizeCommandQueue = function () {
-    const queue = this.commandQueue;
-
-    /**
-     * TODO this is pretty slow and should be optimized
-     * @param {Array.<Operation>} queue
-     */
-    function cutRedundantOperations(queue) {
-        const queueLength = queue.length;
-        loop_Main: for (let i = queueLength - 1; i >= 0; i--) {
-            const opA = queue[i];
-            if (opA.operator === OperationType.Add) {
-                //nothing to do
-                continue;
-            }
-            const operandsA = opA.operands;
-            if (opA.operator === OperationType.Remove) {
-                //hunt and delete operations before this remove that affect deleted references
-                for (let k = 0, kl = operandsA.length; k < kl; k++) {
-                    const refA = operandsA[k];
-
-                    //walk the queue back and remove all previous operations on these references
-                    loop_B: for (let j = i - 1; j >= 0; j--) {
-                        const opB = queue[j];
-                        const operandsB = opB.operands;
-                        const operatorB = opB.operator;
-                        if (operatorB === OperationType.WriteAttribute) {
-                            const refB = operandsB[0];
-                            if (refA === refB) {
-                                //cut operation
-                                queue.splice(j, 1);
-                                i--;
-                            }
-                        } else if (operatorB === OperationType.Add) {
-                            for (let m = 0, ml = operandsB.length; m < ml; m++) {
-                                const refB = operandsB[m];
-                                if (refA === refB) {
-                                    let jump = 0;
-                                    //delete operation and add operation cancel each other out
-                                    if (kl > 1) {
-                                        operandsA.splice(k, 1);
-                                        kl--;
-                                        k--;
-                                    } else {
-                                        queue.splice(i, 1);
-                                        i--;
-                                        jump |= 2;
-                                    }
-
-                                    if (ml > 1) {
-                                        operandsB.splice(m, 1);
-                                        m--;
-                                        ml--;
-                                    } else {
-                                        //cut operation from the queue
-                                        queue.splice(j, 1);
-                                        i--;
-                                        jump |= 1;
-                                    }
-
-                                    if ((jump & 2) !== 0) {
-                                        continue loop_Main;
-                                    } else if (jump !== 0) {
-                                        continue loop_B;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            } else if (opA.operator === OperationType.WriteAttribute) {
-                //find other operations that modify the same attribute, any previous operations are redundant at this point
-                const refA = operandsA[0];
-                const attributeIndexA = operandsA[1];
-                //walk the queue back and remove all previous operations on these references
-                for (let j = i - 1; j >= 0; j--) {
-                    const opB = queue[j];
-                    if (opB.operator !== OperationType.WriteAttribute) {
-                        //ignore
-                        continue;
-                    }
-
-                    const operandsB = opB.operands;
-                    if (operandsB[0] === refA && operandsB[1] === attributeIndexA) {
-                        //operation will be overwritten anyway, cut it
-                        queue.splice(j, 1);
-                        i--;
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {Array.<Operation>} queue
-     */
-    function groupOperations(queue) {
-        let l = queue.length;
-        for (let i = 0; i < l; i++) {
-            const opA = queue[i];
-            const operatorA = opA.operator;
-            const operandsA = opA.operands;
-            if (operatorA === OperationType.Add || operatorA === OperationType.Remove) {
-                for (let j = i + 1; j < l; j++) {
-                    const opB = queue[j];
-                    if (opB.operator === operatorA) {
-                        const operandsB = opB.operands;
-                        const numOperands = operandsB.length;
-
-                        for (let k = 0; k < numOperands; k++) {
-                            const refB = operandsB[k];
-                            if (operandsA.indexOf(refB) === -1) {
-                                operandsA.push(refB);
-                            }
-                        }
-
-                        queue.splice(j, 1);
-                        j--;
-                        l--;
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * @param {Array.<Operation>} queue
-     */
-    function sortOperations(queue) {
-        queue.sort(function (a, b) {
-            const operatorA = a.operator;
-            const operatorB = b.operator;
-
-            //it's important that Add and Remove operations are sorted to the front of the queue, before Write operations
-            if (operatorA < operatorB) {
-                return -1;
-            } else if (operatorB > operatorA) {
-                return 1;
-            }
-
-            if (operatorA !== OperationType.WriteAttribute) {
-                return 0;
-            }
-
-            const attributeIndexA = a.operands[1];
-            const attributeIndexB = b.operands[1];
-
-            //sort write operations by buffer index
-            return attributeIndexB - attributeIndexA;
-        });
-    }
-
-    cutRedundantOperations(queue);
-    groupOperations(queue);
-    sortOperations(queue);
+    optimizeCommandQueue(this.commandQueue);
 };
 
 /**
@@ -869,7 +633,5 @@ ParticleGroup.prototype.setSize = function (newSize) {
 };
 
 export {
-    ParticleGroup,
-    ParticleAttributeType,
-    ParticleDataType
+    ParticleGroup
 };

package/engine/graphics/particles/particular/group/ParticleGroup.spec.js

@@ -1,6 +1,8 @@
-import { ParticleAttributeType, ParticleDataType, ParticleGroup, } from "./ParticleGroup.js";
+import { ParticleGroup, } from "./ParticleGroup.js";
 import { ParticleSpecification } from "./ParticleSpecification.js";
 import { ParticleAttribute } from "./ParticleAttribute.js";
+import { ParticleDataType } from "./ParticleDataType.js";
+import { ParticleAttributeType } from "./ParticleAttributeType.js";
 
 test("After calling grow(1) size is increased by 1", () => {
     const spec = new ParticleSpecification();

package/engine/graphics/particles/particular/group/ParticleSpecification.js

@@ -1,9 +1,7 @@
-import { ParticleGroup } from "./ParticleGroup.js";
-
-
 /**
  *
  * @constructor
+ * @deprecated use {@link VertexDataSpec} instead
  */
 export function ParticleSpecification() {
     /**
@@ -13,6 +11,25 @@ export function ParticleSpecification() {
     this.attributes = [];
 }
 
+/**
+ *
+ * @param {string} name
+ * @return {undefined|ParticleAttribute}
+ */
+ParticleSpecification.prototype.getByName = function (name) {
+    const attributes = this.attributes;
+    const n = attributes.length;
+    for (let i = 0; i < n; i++) {
+        const attribute = attributes[i];
+
+        if (attribute.name === name) {
+            return attribute;
+        }
+    }
+
+    return undefined;
+};
+
 /**
  *
  * @param {ParticleAttribute} attribute
@@ -20,9 +37,7 @@ export function ParticleSpecification() {
  */
 ParticleSpecification.prototype.add = function (attribute) {
     //check uniqueness of name
-    if (this.attributes.some(function (a) {
-        return a.name === attribute.name;
-    })) {
+    if (this.getByName(attribute.name) !== undefined) {
         throw new Error(`Attribute named '${attribute.name}' already exists`);
     }
 
@@ -31,11 +46,3 @@ ParticleSpecification.prototype.add = function (attribute) {
     //for chaining, return self
     return this;
 };
-
-/**
- *
- * @return {ParticleGroup}
- */
-ParticleSpecification.prototype.build = function () {
-    return new ParticleGroup(this);
-};

package/engine/graphics/particles/particular/group/itemSizeFromAttributeType.js

@@ -0,0 +1,20 @@
+import { ParticleAttributeType } from "./ParticleAttributeType.js";
+
+/**
+ *
+ * @param {ParticleAttributeType} type
+ */
+export function itemSizeFromAttributeType(type) {
+    switch (type) {
+        case ParticleAttributeType.Scalar:
+            return 1;
+        case ParticleAttributeType.Vector2:
+            return 2;
+        case ParticleAttributeType.Vector3:
+            return 3;
+        case ParticleAttributeType.Vector4:
+            return 4;
+        default:
+            throw new Error(`Unsupported attribute type: ${type}`);
+    }
+}

package/engine/graphics/particles/particular/group/optimizeCommandQueue.js

@@ -0,0 +1,162 @@
+import { OperationType } from "./OperationType.js";
+
+/**
+ *
+ * @param {Operation[]} queue
+ */
+export function optimizeCommandQueue(queue) {
+
+    /**
+     * TODO this is pretty slow and should be optimized
+     * @param {Array.<Operation>} queue
+     */
+    function cutRedundantOperations(queue) {
+        const queueLength = queue.length;
+        loop_Main: for (let i = queueLength - 1; i >= 0; i--) {
+            const opA = queue[i];
+            if (opA.operator === OperationType.Add) {
+                //nothing to do
+                continue;
+            }
+            const operandsA = opA.operands;
+            if (opA.operator === OperationType.Remove) {
+                //hunt and delete operations before this remove that affect deleted references
+                for (let k = 0, kl = operandsA.length; k < kl; k++) {
+                    const refA = operandsA[k];
+
+                    //walk the queue back and remove all previous operations on these references
+                    loop_B: for (let j = i - 1; j >= 0; j--) {
+                        const opB = queue[j];
+                        const operandsB = opB.operands;
+                        const operatorB = opB.operator;
+                        if (operatorB === OperationType.WriteAttribute) {
+                            const refB = operandsB[0];
+                            if (refA === refB) {
+                                //cut operation
+                                queue.splice(j, 1);
+                                i--;
+                            }
+                        } else if (operatorB === OperationType.Add) {
+                            for (let m = 0, ml = operandsB.length; m < ml; m++) {
+                                const refB = operandsB[m];
+                                if (refA === refB) {
+                                    let jump = 0;
+                                    //delete operation and add operation cancel each other out
+                                    if (kl > 1) {
+                                        operandsA.splice(k, 1);
+                                        kl--;
+                                        k--;
+                                    } else {
+                                        queue.splice(i, 1);
+                                        i--;
+                                        jump |= 2;
+                                    }
+
+                                    if (ml > 1) {
+                                        operandsB.splice(m, 1);
+                                        m--;
+                                        ml--;
+                                    } else {
+                                        //cut operation from the queue
+                                        queue.splice(j, 1);
+                                        i--;
+                                        jump |= 1;
+                                    }
+
+                                    if ((jump & 2) !== 0) {
+                                        continue loop_Main;
+                                    } else if (jump !== 0) {
+                                        continue loop_B;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } else if (opA.operator === OperationType.WriteAttribute) {
+                //find other operations that modify the same attribute, any previous operations are redundant at this point
+                const refA = operandsA[0];
+                const attributeIndexA = operandsA[1];
+                //walk the queue back and remove all previous operations on these references
+                for (let j = i - 1; j >= 0; j--) {
+                    const opB = queue[j];
+                    if (opB.operator !== OperationType.WriteAttribute) {
+                        //ignore
+                        continue;
+                    }
+
+                    const operandsB = opB.operands;
+                    if (operandsB[0] === refA && operandsB[1] === attributeIndexA) {
+                        //operation will be overwritten anyway, cut it
+                        queue.splice(j, 1);
+                        i--;
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {Array.<Operation>} queue
+     */
+    function groupOperations(queue) {
+        let l = queue.length;
+        for (let i = 0; i < l; i++) {
+            const opA = queue[i];
+            const operatorA = opA.operator;
+            const operandsA = opA.operands;
+            if (operatorA === OperationType.Add || operatorA === OperationType.Remove) {
+                for (let j = i + 1; j < l; j++) {
+                    const opB = queue[j];
+                    if (opB.operator === operatorA) {
+                        const operandsB = opB.operands;
+                        const numOperands = operandsB.length;
+
+                        for (let k = 0; k < numOperands; k++) {
+                            const refB = operandsB[k];
+                            if (operandsA.indexOf(refB) === -1) {
+                                operandsA.push(refB);
+                            }
+                        }
+
+                        queue.splice(j, 1);
+                        j--;
+                        l--;
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * @param {Array.<Operation>} queue
+     */
+    function sortOperations(queue) {
+        queue.sort(function (a, b) {
+            const operatorA = a.operator;
+            const operatorB = b.operator;
+
+            //it's important that Add and Remove operations are sorted to the front of the queue, before Write operations
+            if (operatorA < operatorB) {
+                return -1;
+            } else if (operatorB > operatorA) {
+                return 1;
+            }
+
+            if (operatorA !== OperationType.WriteAttribute) {
+                return 0;
+            }
+
+            const attributeIndexA = a.operands[1];
+            const attributeIndexB = b.operands[1];
+
+            //sort write operations by buffer index
+            return attributeIndexB - attributeIndexA;
+        });
+    }
+
+    cutRedundantOperations(queue);
+    groupOperations(queue);
+    sortOperations(queue);
+}

package/engine/graphics/particles/particular/group/typedArrayConstructorFromDataType.js

@@ -0,0 +1,19 @@
+import { ParticleDataType } from "./ParticleDataType.js";
+
+/**
+ *
+ * @param {ParticleDataType} type
+ * @returns {*}
+ */
+export function typedArrayConstructorFromDataType(type) {
+    switch (type) {
+        case ParticleDataType.Float32:
+            return Float32Array;
+        case ParticleDataType.Float64:
+            return Float64Array;
+        case ParticleDataType.Uint8:
+            return Uint8Array;
+        default:
+            throw new Error(`Unsupported type: ${type}`);
+    }
+}

package/engine/graphics/render/buffer/buffers/prototypeNormalFrameBuffer.js

@@ -108,7 +108,7 @@ function makeConfig(engine) {
         new ClingToTerrainSystem(),
         new TerrainSystem(graphics, assetManager),
         new WaterSystem(graphics),
-        new Trail2DSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
         new Foliage2System(assetManager, graphics),
         new ViewportPositionSystem(graphics.viewport.size),
         new GridPosition2TransformSystem(),
@@ -326,7 +326,7 @@ function main(engine) {
                     position: {
                         x: 60 + i * 10,
                         y: 0,
-                        z: 30 + j*10
+                        z: 30 + j * 10
                     },
                     scale: {
                         x: 1,

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

@@ -50,7 +50,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
          * @type {boolean}
          * @private
          */
-        this.__use_normals = true;
+        this.__use_normals = false;
 
         /**
          * Resolution scale at which AO is to be rendered. Higher scale will lead to sharper and better looking results

package/engine/graphics/render/buffer/slot/parameter/ProgramValueSlotParameter.js

@@ -1,6 +1,7 @@
-import { computeHashFloat, computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
 import { ProgramValueSlotParameterType } from "./ProgramValueSlotParameterType.js";
 import { computeStringHash } from "../../../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../../core/math/hash/computeHashFloat.js";
 
 /**
  *

package/engine/graphics/render/buffer/slot/parameter/ProgramValueSlotParameterSet.js

@@ -1,4 +1,4 @@
-import { computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 export class ProgramValueSlotParameterSet {
     constructor() {