@woosh/meep-engine 2.33.22 → 2.33.23

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();
 

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

@@ -67,7 +67,11 @@ biplanar_edge_mapping[0b100010] = 5 | (7 << 3);
  * @param {number[]} points
  * @return {boolean}
  */
-function detailed_sphere_frustum_intersection_test(radius, light_x, light_y, light_z, outside_plane_count, outside_plane_bitfield, points) {
+function detailed_sphere_frustum_intersection_test(
+    radius, light_x, light_y, light_z,
+    outside_plane_count, outside_plane_bitfield,
+    points
+) {
 
     const radius_sqr = radius * radius;
 
@@ -201,7 +205,11 @@ function point_light_inside_volume(light, points, planes) {
     if (outside_plane_count < 2) {
         return true;
     } else {
-        return detailed_sphere_frustum_intersection_test(radius, light_x, light_y, light_z, outside_plane_count, outside_plane_bitfield, points);
+        return detailed_sphere_frustum_intersection_test(
+            radius, light_x, light_y, light_z,
+            outside_plane_count, outside_plane_bitfield,
+            points
+        );
     }
 }
 
@@ -246,7 +254,11 @@ function spot_light_inside_volume(light, points, planes) {
  * @param {number[]|Float32Array|Float64Array} points
  * @returns {number} number of items added to the destination, non-negative integer
  */
-export function queryBVH_Frustum(destination, destination_offset, root, planes, points) {
+export function queryBVH_Frustum(
+    destination,
+    destination_offset,
+    root, planes, points
+) {
     let i = 0;
     let j = 0;
     // read out points
@@ -258,7 +270,7 @@ export function queryBVH_Frustum(destination, destination_offset, root, planes,
 
     stack_loop:while (stackPointer-- > stackOffset) {
 
-        queryBVH_Frustum.iteration_count++;
+        // queryBVH_Frustum.iteration_count++;
 
         const n = stack[stackPointer];
 
@@ -282,7 +294,7 @@ export function queryBVH_Frustum(destination, destination_offset, root, planes,
                 if (distanceAbovePlane < 0) {
                     // node is below the plane
 
-                    queryBVH_Frustum.rejection_count++;
+                    // queryBVH_Frustum.rejection_count++;
 
                     continue stack_loop;
                 }

package/engine/graphics/render/layers/RenderLayerUtils.js

@@ -1,4 +1,3 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
 import { computePointDistanceToPlane } from "../../../../core/geom/Plane.js";
 import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 
@@ -10,7 +9,11 @@ import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/ge
  */
 export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes, bias = 0) {
 
-    const p = new Vector3();
+    /**
+     *
+     * @type {number[]}
+     */
+    const p = [];
 
     const adjacentPlanePairs = [
         [],
@@ -38,7 +41,7 @@ export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes,
             const p0 = pair[0];
             const p1 = pair[1];
 
-            const planeIntersection = plane_three_computeConvex3PlaneIntersection(p, p0, p1, objectPlane);
+            const planeIntersection = plane_three_computeConvex3PlaneIntersection(p, 0, p0, p1, objectPlane);
 
             if (!planeIntersection) {
                 //no intersection
@@ -48,7 +51,7 @@ export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes,
 
             const plane_normal = nearPlane.normal;
 
-            const distanceToNearPlane = computePointDistanceToPlane(p.x, p.y, p.z, plane_normal.x, plane_normal.y, plane_normal.z, nearPlane.constant);
+            const distanceToNearPlane = computePointDistanceToPlane(p[0], p[1], p[2], plane_normal.x, plane_normal.y, plane_normal.z, nearPlane.constant);
 
             //update near and far plane distances
             if (distanceToNearPlane > 0 && distanceToNearPlane < range.near) {

package/engine/graphics/render/visibility/hiz/prototypeHiZ.js

@@ -112,7 +112,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/texture/atlas/AtlasPatch.js

@@ -5,12 +5,15 @@ import AABB2 from "../../../../core/geom/AABB2.js";
 export class AtlasPatch {
     constructor() {
         /**
-         *
+         * Position in the atlas where the raw patch data is found, excludes padding
+         * @readonly
          * @type {Vector2}
          */
         this.position = new Vector2(0, 0);
+
         /**
-         *
+         * Size in pixels of the patch, excludes padding
+         * @readonly
          * @type {Vector2}
          */
         this.size = new Vector2(0, 0);
@@ -34,11 +37,13 @@ export class AtlasPatch {
         this.sampler = null;
 
         /**
+         * @readonly
          * @type {Rectangle}
          */
         this.uv = new Rectangle(0, 0, 0, 0);
 
         /**
+         * Area in the atlas where patch along with the padding is packed into
          * Used for packing inside TextureAtlas. Do not modify manually
          * @readonly
          * @protected

package/engine/graphics/texture/atlas/TextureAtlas.js

@@ -82,8 +82,8 @@ export class TextureAtlas {
      * @returns {boolean}
      */
     contains(patch) {
-        assert.notEqual(patch, null, 'patch is null');
-        assert.notEqual(patch, undefined, 'patch is undefined');
+        assert.notNull(patch, 'patch');
+        assert.defined(patch, 'patch');
         assert.ok(patch.isAtlasPatch, 'patch argument is not an AtlasPatch');
 
         return this.patches.includes(patch);

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -493,7 +493,7 @@ Sampler2D.prototype.get = function (x, y, result) {
 
     const t = [];
 
-    this.sampleBilinear(x, y, t);
+    this.sampleBilinear(x, y, t, 0);
 
     if (result !== undefined) {
         result.readFromArray(t, 0);
@@ -655,14 +655,15 @@ Sampler2D.prototype.sampleChannelBicubic = function (x, y, channel) {
  * @param {number} x
  * @param {number} y
  * @param {number[]} result
+ * @param {number} result_offset
  */
-Sampler2D.prototype.sampleBilinear = function (x, y, result) {
+Sampler2D.prototype.sampleBilinear = function (x, y, result, result_offset) {
 
     const itemSize = this.itemSize;
 
     for (let i = 0; i < itemSize; i++) {
         //TODO this can be optimized greatly
-        result[i] = this.sampleChannelBilinear(x, y, i);
+        result[i + result_offset] = this.sampleChannelBilinear(x, y, i);
 
     }
 };
@@ -809,7 +810,7 @@ Sampler2D.prototype.sample = function (u, v, result) {
 
     const temp = [];
 
-    this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp);
+    this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp, 0);
 
     result.readFromArray(temp);
 
@@ -888,7 +889,7 @@ Sampler2D.prototype.makeArrayFiller = function (scale, offset) {
     }
 
     function fillDD2(index, array, x, y) {
-        sampler.sampleBilinear(x, y, v4);
+        sampler.sampleBilinear(x, y, v4, 0);
         const val = (v4[0] + offset) * scale | 0;
         array.fill(val, index, index + 3);
         array[index + 3] = (v4[1] + offset) * scale | 0;
@@ -896,7 +897,7 @@ Sampler2D.prototype.makeArrayFiller = function (scale, offset) {
 
     function fillDD3(index, array, x, y) {
 
-        sampler.sampleBilinear(x, y, v4);
+        sampler.sampleBilinear(x, y, v4, 0);
 
         array[index] = (v4[0] + offset) * scale | 0;
         array[index + 1] = (v4[1] + offset) * scale | 0;
@@ -905,7 +906,7 @@ Sampler2D.prototype.makeArrayFiller = function (scale, offset) {
     }
 
     function fillDD4(index, array, x, y) {
-        sampler.sampleBilinear(x, y, v4);
+        sampler.sampleBilinear(x, y, v4, 0);
         array[index] = (v4[0] + offset) * scale | 0;
         array[index + 1] = (v4[1] + offset) * scale | 0;
         array[index + 2] = (v4[2] + offset) * scale | 0;

package/engine/graphics/texture/sampler/scaleSampler2D.js

@@ -7,6 +7,7 @@ import { assert } from "../../../../core/assert.js";
  */
 export function scaleSampler2D(source, target) {
     const targetItemSize = target.itemSize;
+
     assert.equal(source.itemSize, targetItemSize, 'both source and target must have the same number of channels');
 
     const targetWidth = target.width;
@@ -18,32 +19,28 @@ export function scaleSampler2D(source, target) {
     const target_data = target.data;
 
     if (sourceWidth === targetWidth && sourceHeight === targetHeight) {
-        // exact size match
+        // exact size match, nothing to do
         target_data.set(source.data);
         return;
     }
 
-    const sample = [];
-
     const targetRowSize = targetItemSize * targetWidth;
 
+    const source_scale_x = sourceWidth / targetWidth;
+    const source_scale_y = sourceHeight / targetHeight;
+
     for (let y = 0; y < targetHeight; y++) {
 
-        const v = y / targetHeight;
 
+        const sample_y = y * source_scale_y;
         const target_row_address = y * targetRowSize;
 
         for (let x = 0; x < targetWidth; x++) {
 
-            const u = x / targetWidth;
-
-            source.sampleBilinear(u * sourceWidth, v * sourceHeight, sample);
 
             const target_offset = target_row_address + x * targetItemSize;
 
-            for (let i = 0; i < targetItemSize; i++) {
-                target_data[target_offset + i] = sample[i];
-            }
+            source.sampleBilinear(x * source_scale_x, sample_y, target_data, target_offset);
 
         }
     }

package/engine/graphics/trail/x/RibbonMaterialX.js

@@ -106,11 +106,11 @@ export class RibbonMaterialX extends ShaderMaterial {
                 uDiffuse: {
                     type: 't',
                     value: null
-                },
-                defines: {
-                    USE_TEXTURE: false
                 }
             },
+            defines: {
+                USE_TEXTURE: false
+            },
             blending: NormalBlending,
             transparent: true,
             depthWrite: false,

package/engine/graphics/trail/x/RibbonX.js

@@ -36,7 +36,6 @@ export class RibbonX {
          */
         this.__data = new RowFirstTable(ribbon_attributes_spec);
 
-
         /**
          * Index into current geometry segment that is at the END of the ribbon
          * @type {number}
@@ -66,6 +65,10 @@ export class RibbonX {
         this.__count = 0;
     }
 
+    dispose() {
+        this.__geometry.dispose();
+    }
+
     /**
      *
      * @returns {BufferGeometry}
@@ -350,6 +353,11 @@ export class RibbonX {
         this.setPointAttribute_Vector3(index, RIBBON_ATTRIBUTE_ADDRESS_COLOR, r, g, b);
     }
 
+    /**
+     *
+     * @param {number} index
+     * @param {number} value
+     */
     setPointAlpha(index, value) {
         const i2 = index * 2;
 
@@ -359,7 +367,11 @@ export class RibbonX {
         this.__ib_float32.needsUpdate = true;
     }
 
-
+    /**
+     *
+     * @param {number} index
+     * @param {number} value
+     */
     setPointThickness(index, value) {
         const i2 = index * 2;
 
@@ -377,6 +389,9 @@ export class RibbonX {
         assert.greaterThanOrEqual(count, 2, 'number of points in the ribbon must be at least 2 (to produce at least a single quad)');
         assert.isNonNegativeInteger(count, 'count');
 
+        // dispose of existing geometry
+        this.__geometry.dispose();
+
         const point_count = count * 2;
 
         if (this.__data.length > point_count) {