@woosh/meep-engine 2.33.23 → 2.33.27

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

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param {OperationType} operator
+ * @param {Array} operands
+ * @constructor
+ */
+export function Operation(operator, operands) {
+    /**
+     *
+     * @type {OperationType}
+     */
+    this.operator = operator;
+    /**
+     *
+     * @type {Array}
+     */
+    this.operands = operands;
+}

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

@@ -0,0 +1,9 @@
+/**
+ *
+ * @enum {number}
+ */
+export const OperationType = {
+    Remove: 0,
+    Add: 1,
+    WriteAttribute: 2
+};

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

@@ -3,6 +3,7 @@
  * @param {string} name
  * @param {ParticleAttributeType} attributeType
  * @param {ParticleDataType} dataType
+ * @deprecated use {@link AttributeSpec} instead
  * @constructor
  */
 export function ParticleAttribute(name, attributeType, dataType) {
@@ -21,4 +22,4 @@ export function ParticleAttribute(name, attributeType, dataType) {
      * @type {ParticleDataType}
      */
     this.dataType = dataType;
-}
+}

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

@@ -0,0 +1,11 @@
+/**
+ *
+ * @enum {number}
+ */
+const ParticleAttributeType = {
+    Scalar: 1,
+    Vector2: 2,
+    Vector3: 3,
+    Vector4: 4
+};
+export { ParticleAttributeType };

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

@@ -0,0 +1,10 @@
+/**
+ *
+ * @enum {number}
+ */
+const ParticleDataType = {
+    Float32: 0,
+    Float64: 1,
+    Uint8: 2
+};
+export { ParticleDataType };

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/simple-fx/ao/AmbientOcclusionPostProcessEffect.js

@@ -1,4 +1,3 @@
-import { max2 } from "../../../../../../core/math/max2.js";
 import { EnginePlugin } from "../../../../../plugin/EnginePlugin.js";
 import {
     LinearFilter,
@@ -14,6 +13,7 @@ import { BlendingType } from "../../../../texture/sampler/BlendingType.js";
 import { DepthLimitedBlur } from "../DepthLimitedBlur.js";
 import { renderScreenSpace } from "../../../utils/renderScreenSpace.js";
 import { StandardFrameBuffers } from "../../../../StandardFrameBuffers.js";
+import { CompositingStages } from "../../../../composit/CompositingStages.js";
 
 export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
     constructor() {
@@ -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
@@ -160,9 +160,9 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         uniforms.bias.value = 0.5;
         uniforms.intensity.value = 0.18;
 
-        const depth_range = far - near;
-
-        uniforms.scale.value = 5 * max2(1, depth_range / 30);
+        // scale is divided by camera far in the shader, we unbias it here
+        // TODO remove this term from the shader
+        uniforms.scale.value = far * 0.25;
 
         uniforms.kernelRadius.value = 30;
         uniforms.minResolution.value = 0;
@@ -184,12 +184,14 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
 
     /**
      *
-     * @param {WebGLRenderer} renderer
-     * @param {Camera} camera
-     * @param {Scene} scene
      * @private
      */
-    __render(renderer, camera, scene) {
+    __render() {
+        const engine = this.engine;
+        const graphics = engine.graphics;
+
+        const renderer = graphics.renderer;
+
         this.__prepare_draw();
 
         const __old_state_rt = renderer.getRenderTarget();
@@ -295,6 +297,9 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         this.__composit_layer = graphics.layerComposer.createLayer({}, BlendingType.Multiply);
         this.__composit_layer.name = 'Ambient Occlusion';
 
+        // apply ambient occlusion on opaque pass, otherwise it would occlude transparent geometry
+        this.__composit_layer.stage = CompositingStages.POST_OPAQUE;
+
         const material = this.__material;
         const uniforms = material.uniforms;
 
@@ -309,7 +314,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
             this.setNormalBufferUsage(true);
         }
 
-        graphics.on.preComposite.add(this.__render, this);
+        this.__composit_layer.on.preRender.add(this.__render, this);
         graphics.viewport.size.onChanged.add(this.__update_render_target_size, this);
 
         this.__update_render_target_size();
@@ -330,7 +335,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         // remove the layer
         graphics.layerComposer.remove(this.__composit_layer);
 
-        graphics.on.preComposite.remove(this.__render, this);
+        this.__composit_layer.on.preRender.remove(this.__render, this);
         graphics.viewport.size.onChanged.add(this.__update_render_target_size, this);
 
         return super.shutdown();