@woosh/meep-engine 2.33.19 → 2.33.23

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

@@ -68,6 +68,7 @@ function ParticleLayer() {
      * @type {number}
      */
     this.emissionRate = 1;
+
     /**
      * When layer is added - it will immediately emit this number of particles
      * @type {number}
@@ -97,6 +98,11 @@ function ParticleLayer() {
      * @type {ConicRay}
      */
     this.particleVelocityDirection = new ConicRay();
+
+    /**
+     *
+     * @type {NumericInterval}
+     */
     this.particleSpeed = new NumericInterval(0, 0);
 
     /**
@@ -111,7 +117,6 @@ function ParticleLayer() {
      */
     this.isEmitting = true;
 
-
     /**
      * Simulation steps that are to be applied
      * @type {List<SimulationStepDefinition>}
@@ -173,7 +178,12 @@ ParticleLayer.prototype.computePointBoundingBox = function (result) {
     //displace by current position
     const position = this.position;
 
-    computeConeBoundingBox(aabb3, position.x, position.y, position.z, direction.x, direction.y, direction.z, particleVelocityDirection.angle, maxDisplacement);
+    computeConeBoundingBox(
+        aabb3,
+        position.x, position.y, position.z,
+        direction.x, direction.y, direction.z,
+        particleVelocityDirection.angle, maxDisplacement
+    );
 
     x0 = aabb3.x0;
     y0 = aabb3.y0;

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

@@ -0,0 +1,37 @@
+import { EmissionShapeType } from "./EmissionShapeType.js";
+import { randomPointInPoint } from "../../../../../../core/geom/random/randomPointInPoint.js";
+import { EmissionFromType } from "./EmissionFromType.js";
+import { randomPointInSphere } from "../../../../../../core/geom/random/randomPointInSphere.js";
+import { randomPointOnSphere } from "../../../../../../core/geom/random/randomPointOnSphere.js";
+import { randomPointInBox } from "../../../../../../core/geom/random/randomPointInBox.js";
+import { randomPointOnBox } from "../../../../../../core/geom/random/randomPointOnBox.js";
+
+/**
+ *
+ * @param {EmissionFromType} emissionType
+ * @param {EmissionShapeType} emissionShape
+ * @returns {function(random: function, result:Vector3):void}
+ */
+export function computeEmissionFunction(emissionType, emissionShape) {
+    if (emissionShape === EmissionShapeType.Point) {
+        return randomPointInPoint;
+    } else if (emissionShape === EmissionShapeType.Sphere) {
+        if (emissionType === EmissionFromType.Volume) {
+            return randomPointInSphere;
+        } else if (emissionType === EmissionFromType.Shell) {
+            return randomPointOnSphere;
+        } else {
+            throw new TypeError('Unsupported EmissionFrom Type');
+        }
+    } else if (emissionShape === EmissionShapeType.Box) {
+        if (emissionType === EmissionFromType.Volume) {
+            return randomPointInBox;
+        } else if (emissionType === EmissionFromType.Shell) {
+            return randomPointOnBox;
+        } else {
+            throw new TypeError('Unsupported EmissionFrom Type');
+        }
+    } else {
+        throw new TypeError('Unsupported emission shape');
+    }
+}

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

@@ -0,0 +1,25 @@
+/**
+ *
+ * @param {number} index
+ * @param {number[]|Float32Array} positionArray
+ * @param {Vector3} planeNormal
+ * @return {number}
+ */
+export function distance_to_camera(index, positionArray, planeNormal) {
+    const address = index * 3;
+
+    // extract position components of the particle
+    const x = positionArray[address];
+    const y = positionArray[address + 1];
+    const z = positionArray[address + 2];
+
+    const planeNormalX = planeNormal.x;
+    const planeNormalY = planeNormal.y;
+    const planeNormalZ = planeNormal.z;
+
+    // compute dot product
+    const dot = x * planeNormalX + y * planeNormalY + z * planeNormalZ;
+
+    // use dot product instead of the actual distance to save computation. Difference is going to be constant
+    return dot;
+}

package/engine/graphics/particles/particular/engine/shader/ShaderManager.js

@@ -115,6 +115,8 @@ export class ShaderManager {
             anisotropy: 0
         });
 
+        this.spriteTexture.name = 'Sprite sheet';
+
         /**
          *
          * @type {Texture|null}
@@ -284,37 +286,14 @@ export class ShaderManager {
 
                 console.warn('Recomputing hashes ... ');
 
-                this.recordGraveyard.updateHashes();
-                this.materialMap.updateHashes();
+                this.recordGraveyard.rebuild();
+                this.materialMap.rebuild();
             }
 
             this.materialMap.delete(bestKey);
         }
     }
 
-    /**
-     *
-     * @param {MaterialRecord} entry
-     */
-    destroyMaterialRecord(entry) {
-
-        const parameters = entry.parameters.asArray();
-
-        //remove parameters from parameter sheet
-        for (let i = 0; i < parameters.length; i++) {
-            const particleParameter = parameters[i];
-            this.parameterSheet.remove(particleParameter);
-        }
-
-        //unlink signal bindings
-        entry.signalBindings.forEach(function (binding) {
-            binding.unlink();
-        });
-
-        //decommission material
-        entry.material.dispose();
-    }
-
     /**
      *
      * @param {ParticleEmitter} emitter
@@ -369,6 +348,7 @@ export class ShaderManager {
         const cameraNear = camera.near;
         const cameraFar = camera.far;
 
+        // TODO use a shader uniform structure to avoid iteration
         this.materialMap.forEach(function (entry) {
             const uniforms = entry.material.uniforms;
 
@@ -386,6 +366,7 @@ export class ShaderManager {
     setDepthTexture(texture) {
         this.depthTexture = texture;
 
+        // TODO use a shader uniform structure to avoid iteration
         this.materialMap.forEach(function (entry) {
             const material = entry.material;
             material.uniforms.tDepth.value = texture;
@@ -400,6 +381,7 @@ export class ShaderManager {
     setViewportSize(x, y) {
         this.viewportSize.set(x, y);
 
+        // TODO use a shader uniform structure to avoid iteration
         this.materialMap.forEach(function (entry) {
             entry.material.uniforms.resolution.value.set(x, y);
         });

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/forward_plus/LightManager.js

@@ -508,6 +508,7 @@ export class LightManager {
         let lookup_address_offset = 0;
         let i_x_0, i_y_0, i_z_0;
 
+        // clear cache
         LOOKUP_CACHE.fill(0xFFFFFFFF);
 
         for (i_z_0 = 0; i_z_0 < tr_z; i_z_0++) {
@@ -529,7 +530,6 @@ export class LightManager {
                 read_plane_pair(cluster_planes, y_plane_index_offset_0, scratch_frustum_planes, 8);
 
                 for (i_x_0 = 0; i_x_0 < tr_x; i_x_0++) {
-                    const i_x_1 = i_x_0 + 1;
 
                     // construct x planes
 
@@ -551,6 +551,8 @@ export class LightManager {
                     const frustum_point_index_011 = i_z_1 * tr_xy_1 + i_y_1 * tr_x_1 + i_x_0;
                     read_frustum_corner(cluster_frustum_points, frustum_point_index_011, scratch_corners, 9);
 
+                    const i_x_1 = i_x_0 + 1;
+
                     const frustum_point_index_100 = i_z_0 * tr_xy_1 + i_y_0 * tr_x_1 + i_x_1;
                     read_frustum_corner(cluster_frustum_points, frustum_point_index_100, scratch_corners, 12);
 
@@ -565,7 +567,13 @@ export class LightManager {
 
 
                     // at this point we have a fully constructed cluster, we can query lights within the cluster
-                    const match_count = queryBVH_Frustum(scratch_light_nodes, 0, bvh, scratch_frustum_planes, scratch_corners);
+                    const match_count = queryBVH_Frustum(
+                        scratch_light_nodes,
+                        0,
+                        bvh,
+                        scratch_frustum_planes,
+                        scratch_corners
+                    );
 
                     const tile_index = (i_z_0 * tile_slice_size) + (i_y_0 * tr_x) + (tr_x - i_x_1);
 

package/engine/graphics/render/forward_plus/computeFrustumCorners.js

@@ -1,14 +1,4 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
-import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/geom/3d/plane_computeConvex3PlaneIntersection.js";
-
-const v_000 = new Vector3();
-const v_001 = new Vector3();
-const v_010 = new Vector3();
-const v_011 = new Vector3();
-const v_100 = new Vector3();
-const v_101 = new Vector3();
-const v_110 = new Vector3();
-const v_111 = new Vector3();
+import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 
 /**
  *
@@ -18,68 +8,60 @@ const v_111 = new Vector3();
 export function computeFrustumCorners(result, planes) {
 
     const plane_x0 = planes[0];
-    const plane_x1 = planes[1];
-
     const plane_y0 = planes[2];
-    const plane_y1 = planes[3];
-
     const plane_z0 = planes[4];
-    const plane_z1 = planes[5];
 
-    plane_three_computeConvex3PlaneIntersection(v_000,
+    plane_three_computeConvex3PlaneIntersection(result, 0,
         plane_x0,
         plane_y0,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_001,
+    const plane_z1 = planes[5];
+
+    plane_three_computeConvex3PlaneIntersection(result, 3,
         plane_x0,
         plane_y0,
         plane_z1
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_010,
+    const plane_y1 = planes[3];
+
+    plane_three_computeConvex3PlaneIntersection(result, 6,
         plane_x0,
         plane_y1,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_011,
+    plane_three_computeConvex3PlaneIntersection(result, 9,
         plane_x0,
         plane_y1,
         plane_z1
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_100,
+    const plane_x1 = planes[1];
+
+    plane_three_computeConvex3PlaneIntersection(result, 12,
         plane_x1,
         plane_y0,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_101,
+    plane_three_computeConvex3PlaneIntersection(result, 15,
         plane_x1,
         plane_y0,
         plane_z1
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_110,
+    plane_three_computeConvex3PlaneIntersection(result, 18,
         plane_x1,
         plane_y1,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(v_111,
+    plane_three_computeConvex3PlaneIntersection(result, 21,
         plane_x1,
         plane_y1,
         plane_z1
     );
-
-    v_000.writeToArray(result, 0);
-    v_001.writeToArray(result, 3);
-    v_010.writeToArray(result, 6);
-    v_011.writeToArray(result, 9);
-    v_100.writeToArray(result, 12);
-    v_101.writeToArray(result, 15);
-    v_110.writeToArray(result, 18);
-    v_111.writeToArray(result, 21);
 }

package/engine/graphics/render/forward_plus/plugin/MaterialTransformer.js

@@ -61,12 +61,22 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
     }
 
     transform(source) {
+        let result = source;
+
         if (isLitMaterial(source)) {
 
-            source.onBeforeCompile = composeCompile(source.onBeforeCompile, this.__on_before_compile);
+            result = source.clone();
+            // inherit uniforms directly
+
+            if (source.isShaderMaterial) {
+                result.uniforms = source.uniforms;
+                result.defines = source.defines;
+            }
+
+            result.onBeforeCompile = composeCompile(source.onBeforeCompile, this.__on_before_compile);
 
         }
 
-        return source;
+        return result;
     }
 }

package/engine/graphics/render/forward_plus/plugin/ptototypeFPPlugin.js

@@ -125,7 +125,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(),

package/engine/graphics/render/forward_plus/prototypeLightManager.js

@@ -98,10 +98,10 @@ function getFPStandard() {
 }
 
 const material_fp_standard = new FPlusStandardMaterial({
-                                                           color: 0xFFFF00,
-                                                           polygonOffset: true,
-                                                           depthWrite: false
-                                                       });
+    color: 0xFFFF00,
+    polygonOffset: true,
+    depthWrite: false
+});
 
 fp_materials.push(material_fp_standard);
 
@@ -200,14 +200,14 @@ function addPointLight(position, radius, color, intensity = 1) {
     lm.addLight(light);
 
     const sphere_material = new LineBasicMaterial({
-                                                      depthTest: true,
-                                                      depthWrite: false,
-                                                      transparent: true,
-                                                      linewidth: 1,
-                                                      fog: false,
-                                                      color: light.color.toUint(),
-                                                      opacity: min2(intensity, 1)
-                                                  });
+        depthTest: true,
+        depthWrite: false,
+        transparent: true,
+        linewidth: 1,
+        fog: false,
+        color: light.color.toUint(),
+        opacity: min2(intensity, 1)
+    });
 
     const mesh = new Line(sphere_geometry, sphere_material);
 
@@ -233,39 +233,41 @@ function prepare_scene_0() {
 
     controls.minDistance = 2;
 
-    for (let i = 0; i < 500; i++) {
-        const radius = randomFloatBetween(random, 4, 4);
+    const bounds_size = 15;
+
+    for (let i = 0; i < 5000; i++) {
+        const radius = randomFloatBetween(random, 2, 2);
         const intensity = randomFloatBetween(random, 2, 2);
         addPointLight([
-                          randomFloatBetween(random, -20, 20),
-                          randomFloatBetween(random, -20, 20),
-                          randomFloatBetween(random, -20, 20),
-                      ],
-                      radius,
-                      `hsv(${random().toFixed(4)}, 0.8, 1)`,
-                      intensity
+                randomFloatBetween(random, -bounds_size, bounds_size),
+                randomFloatBetween(random, -bounds_size, bounds_size),
+                randomFloatBetween(random, -bounds_size, bounds_size),
+            ],
+            radius,
+            `hsv(${random().toFixed(4)}, 0.8, 1)`,
+            intensity
         );
     }
 
     for (let i = 0; i < 500; i++) {
 
         addKnot([
-                    randomFloatBetween(random, -20, 20),
-                    randomFloatBetween(random, -20, 20),
-                    randomFloatBetween(random, -20, 20)
-                ], 0.5, [
-                    randomFloatBetween(random, 0, Math.PI),
-                    randomFloatBetween(random, 0, Math.PI),
-                    randomFloatBetween(random, 0, Math.PI)
-                ]);
+            randomFloatBetween(random, -bounds_size, bounds_size),
+            randomFloatBetween(random, -bounds_size, bounds_size),
+            randomFloatBetween(random, -bounds_size, bounds_size)
+        ], 0.5, [
+            randomFloatBetween(random, 0, Math.PI),
+            randomFloatBetween(random, 0, Math.PI),
+            randomFloatBetween(random, 0, Math.PI)
+        ]);
     }
 }
 
 function prepare_scene_1() {
     addPointLight([
-                      0, 0, -3
-                  ], 1,
-                  0xFF0000
+            0, 0, -3
+        ], 1,
+        0xFF0000
     );
 
     // tight planes around the light
@@ -278,9 +280,9 @@ function prepare_scene_1() {
 
 function prepare_scene_3() {
     addPointLight([
-                      0, 0, -4
-                  ], 1,
-                  0xFF0000
+            0, 0, -4
+        ], 1,
+        0xFF0000
     );
 
     // tight planes around the light
@@ -288,8 +290,8 @@ function prepare_scene_3() {
     camera.far = 7;
 
     addKnot([
-                0, 0, -4
-            ], 1, [0, 0, 0]);
+        0, 0, -4
+    ], 1, [0, 0, 0]);
 
     // camera.position.set(0, 0, 0);
     camera.lookAt(0, 0, -5);
@@ -297,16 +299,16 @@ function prepare_scene_3() {
 
 function prepare_scene_2() {
     addPointLight([
-                      1.5, 0, -4
-                  ], 1.5,
-                  0xFF0000,
-                  1
+            1.5, 0, -4
+        ], 1.5,
+        0xFF0000,
+        1
     );
     addPointLight([
-                      -1.5, 0, -4
-                  ], 1.5,
-                  0x00FF00,
-                  1
+            -1.5, 0, -4
+        ], 1.5,
+        0x00FF00,
+        1
     );
 
     addKnot([0, 0, -5], 1, [0, 0, 0]);
@@ -324,16 +326,16 @@ function prepare_scene_5() {
 
 
     addPointLight([
-                      1.5 + offset.x, 0 + offset.y, -4 + offset.z
-                  ], 1.5,
-                  0xFF0000,
-                  10
+            1.5 + offset.x, 0 + offset.y, -4 + offset.z
+        ], 1.5,
+        0xFF0000,
+        10
     );
     addPointLight([
-                      -1.5 + offset.x, 0 + offset.y, -4 + offset.z
-                  ], 1.5,
-                  0x00FF00,
-                  10
+            -1.5 + offset.x, 0 + offset.y, -4 + offset.z
+        ], 1.5,
+        0x00FF00,
+        10
     );
 
     addKnot(
@@ -355,7 +357,6 @@ function prepare_scene_5() {
 }
 
 
-
 function addSponza() {
     const loader = new GLTFLoader();
 
@@ -420,13 +421,13 @@ function prepare_scene_4() {
     for (let i = 0; i < 2000; i++) {
         const radius = randomFloatBetween(random, 2, 2);
         addPointLight([
-                          randomFloatBetween(random, -18, 18),
-                          randomFloatBetween(random, -3, 16),
-                          randomFloatBetween(random, -11, 11),
-                      ],
-                      radius,
-                      `hsv(${random().toFixed(4)}, 0.8, 1)`,
-                      randomFloatBetween(random, 3, 3)
+                randomFloatBetween(random, -18, 18),
+                randomFloatBetween(random, -3, 16),
+                randomFloatBetween(random, -11, 11),
+            ],
+            radius,
+            `hsv(${random().toFixed(4)}, 0.8, 1)`,
+            randomFloatBetween(random, 3, 3)
         );
     }
 
@@ -460,13 +461,13 @@ function prepare_scene_6() {
 
 
     addPointLight([
-                      11,
-                      1,
-                      0,
-                  ],
-                  2,
-                  `hsv(0.5, 0.8, 1)`,
-                  3
+            11,
+            1,
+            0,
+        ],
+        2,
+        `hsv(0.5, 0.8, 1)`,
+        3
     );
 
     //
@@ -488,9 +489,9 @@ function prepare_scene_6() {
 
 function prepare_scene_7() {
     addSpotLight([
-                     0, 0, -3
-                 ], [0, 0, 1],
-                 0xFF0000
+            0, 0, -3
+        ], [0, 0, 1],
+        0xFF0000
     );
 
     // tight planes around the light
@@ -513,8 +514,8 @@ console.log("done");
 
 
 const renderer = new WebGLRenderer({
-                                       antialias: true
-                                   });
+    antialias: true
+});
 // renderer.shadowMap.type = VSMShadowMap;
 // renderer.shadowMap.enabled = true;
 renderer.sortObjects = false;
@@ -679,32 +680,32 @@ renderer.domElement.addEventListener(MouseEvents.DoubleClick, () => {
 });
 
 domify(lightClusterWidget.domElement).css({
-                                              position: "absolute",
-                                              zIndex: 2,
-                                              bottom: 0,
-                                              right: 0
-                                          });
+    position: "absolute",
+    zIndex: 2,
+    bottom: 0,
+    right: 0
+});
 
 document.body.appendChild(lightClusterWidget.domElement);
 
 const debugger_button = new ButtonView({
-                                           action() {
-                                               if (screenGrid.domElement.parentNode !== null) {
-                                                   document.body.removeChild(screenGrid.domElement);
-                                               } else {
-                                                   document.body.appendChild(screenGrid.domElement);
-                                               }
-                                           },
-                                           name: "debugger",
-                                           css: {
-                                               position: "absolute",
-                                               color: "white",
-                                               background: "rgba(0,0,0,0.5)",
-                                               zIndex: 2,
-                                               top: 0,
-                                               left: 0
-                                           }
-                                       });
+    action() {
+        if (screenGrid.domElement.parentNode !== null) {
+            document.body.removeChild(screenGrid.domElement);
+        } else {
+            document.body.appendChild(screenGrid.domElement);
+        }
+    },
+    name: "debugger",
+    css: {
+        position: "absolute",
+        color: "white",
+        background: "rgba(0,0,0,0.5)",
+        zIndex: 2,
+        top: 0,
+        left: 0
+    }
+});
 
 debugger_button.link();