@woosh/meep-engine 2.33.24 → 2.33.28

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

@@ -41,6 +41,7 @@ import { randomFloatBetween } from "../../../../core/math/random/randomFloatBetw
 import Signal from "../../../../core/events/signal/Signal.js";
 import SimplexNoise from "simplex-noise";
 import Stats from "three/examples/jsm/libs/stats.module.js";
+import { threeUpdateTransform } from "../../util/threeUpdateTransform.js";
 
 const on_render = new Signal();
 
@@ -50,6 +51,7 @@ const camera = new PerspectiveCamera(30);
 camera.position.z = 1;
 
 camera.layers.enable(3);
+camera.layers.enable(4);
 // camera.layers.enable(1);
 
 camera.near = 1;
@@ -69,6 +71,8 @@ window.lights = lm;
 const random = seededRandom(0);
 
 const scene = new Scene();
+scene.matrixAutoUpdate = false;
+scene.autoUpdate = false;
 
 const sphere_geometry = new OctahedronBufferGeometry(1, 2);
 const sphere_geometry_shell = makeHelperSphereGeometry(1);
@@ -139,6 +143,10 @@ function addKnot(position, scale, rotation) {
     group.add(mesh);
     group.add(outline);
 
+    group.matrixAutoUpdate = false;
+
+    threeUpdateTransform(group);
+
     scene.add(group);
 }
 
@@ -234,7 +242,10 @@ function addPointLight({
     const mesh_center_0 = new Mesh(sphere_geometry, new MeshBasicMaterial({
         color: color_uint
     }));
+    mesh_center_0.layers.disableAll();
+    mesh_center_0.layers.set(4);
     mesh_center_0.scale.setScalar(0.02);
+    mesh_center_0.matrixAutoUpdate = false;
 
     visual_group.add(mesh_center_0);
 
@@ -244,6 +255,9 @@ function addPointLight({
         opacity: 0.033
     }));
     mesh_center_1.scale.setScalar(0.1);
+    mesh_center_1.layers.disableAll();
+    mesh_center_1.layers.set(4);
+    mesh_center_1.matrixAutoUpdate = false;
 
     visual_group.add(mesh_center_1);
 
@@ -251,6 +265,9 @@ function addPointLight({
     visual_group.add(mesh);
     visual_group.position.set(p.x, p.y, p.z);
 
+    threeUpdateTransform(visual_group);
+    visual_group.matrixAutoUpdate = false;
+
     scene.add(visual_group);
 
     if (wander) {
@@ -277,6 +294,8 @@ function addPointLight({
                 p.y,
                 p.z,
             );
+
+            threeUpdateTransform(visual_group);
         });
     }
 }
@@ -313,12 +332,14 @@ function prepare_scene_0() {
         );
     }
 
+    const bounds_size_2 = 15;
+
     for (let i = 0; i < 500; i++) {
 
         addKnot([
-            randomFloatBetween(random, -bounds_size, bounds_size),
-            randomFloatBetween(random, -bounds_size, bounds_size),
-            randomFloatBetween(random, -bounds_size, bounds_size)
+            randomFloatBetween(random, -bounds_size_2, bounds_size_2),
+            randomFloatBetween(random, -bounds_size_2, bounds_size_2),
+            randomFloatBetween(random, -bounds_size_2, bounds_size_2)
         ], 0.5, [
             randomFloatBetween(random, 0, Math.PI),
             randomFloatBetween(random, 0, Math.PI),
@@ -454,6 +475,8 @@ function addSponza() {
 
         });
 
+        threeUpdateTransform(m_0);
+
         scene.add(m_0);
 
         const m_1 = gltf.scene.clone(true);
@@ -466,6 +489,8 @@ function addSponza() {
 
         });
 
+        threeUpdateTransform(m_1);
+
         scene.add(m_1);
 
     });
@@ -599,7 +624,7 @@ fp_materials.forEach(m => {
 
     renderer.getSize(v2);
 
-    m.uniforms.resolution.value.set(
+    m.uniforms.fp_resolution.value.set(
         v2.x * window.devicePixelRatio, v2.y * window.devicePixelRatio
     );
 
@@ -668,7 +693,7 @@ function animate() {
         m.uniforms.fp_f_camera_far.value = camera.far;
 
 
-        m.uniforms.resolution.value.set(scratch_v2.x, scratch_v2.y);
+        m.uniforms.fp_resolution.value.set(scratch_v2.x, scratch_v2.y);
     });
 
     lightClusterWidget.update();
@@ -735,7 +760,7 @@ function draw_camera_view_planes() {
     });
 }
 
-prepare_scene_4();
+prepare_scene_0();
 animate();
 
 // draw_camera_view_planes();

package/engine/graphics/render/forward_plus/query/point_light_inside_volume.js

@@ -42,21 +42,22 @@ export function point_light_inside_volume(
         if (distance < 0) {
             // center of the sphere is below the plane
 
-            if (distance < -radius) {
-                // sphere is entirely below the plane
+            if (distance >= -radius) {
 
-                // query_bvh_frustum_from_objects.rejection_sphere_count++;
+                // sphere intersects the plane
 
-                return false;
-            }
+                outside_plane_count++;
 
-            // sphere intersects the plane
+                const plane_bit_mask = 1 << j;
 
-            outside_plane_count++;
+                outside_plane_bitfield |= plane_bit_mask;
+            } else {
+                // sphere is entirely below the plane
 
-            const plane_bit_mask = 1 << j;
+                // query_bvh_frustum_from_objects.rejection_sphere_count++;
 
-            outside_plane_bitfield |= plane_bit_mask;
+                return false;
+            }
         }
 
     }

package/engine/graphics/shaders/TerrainShader.js

@@ -121,7 +121,6 @@ function fragment() {
     uniform float opacity;
     
     varying vec3 vViewPosition;
-
    
 
     #include <common>
@@ -364,10 +363,10 @@ function fragment() {
         
         vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
                     
-        pc_fragColor  = vec4( outgoingLight, diffuseColor.a );
+        gl_FragColor  = vec4( outgoingLight, diffuseColor.a );
       
         #if defined( TONE_MAPPING )
-            pc_fragColor.rgb = toneMapping( pc_fragColor.rgb );
+            gl_FragColor.rgb = toneMapping( pc_fragColor.rgb );
         #endif
         
         //encode fragment
@@ -378,12 +377,12 @@ function fragment() {
             #else
                 float fogFactor = smoothstep( fogNear, fogFar, fogDepth );
             #endif
-            pc_fragColor.rgb = mix( pc_fragColor.rgb, fogColor, fogFactor );
+            gl_FragColor.rgb = mix( pc_fragColor.rgb, fogColor, fogFactor );
         #endif
         
         #ifdef PREMULTIPLIED_ALPHA
             // Get get normal blending with premultipled, use with CustomBlending, OneFactor, OneMinusSrcAlphaFactor, AddEquation.
-            pc_fragColor.rgb *= pc_fragColor.a;
+            gl_FragColor.rgb *= pc_fragColor.a;
         #endif
         
         #ifdef DITHERING

package/engine/graphics/shadows/ShadowMapRenderer.js

@@ -173,13 +173,19 @@ export class ShadowMapRenderer {
 
         if (shadow.map === null) {
 
-            const pars = { format: RGBAFormat };
+            const pars = {
+                format: RGBAFormat,
+                scissorTest: false,
+                stencilBuffer: false
+            };
 
             if (!shadow.isPointLightShadow && renderer.shadowMap.type === VSMShadowMap) {
                 pars.minFilter = LinearFilter;
                 pars.magFilter = LinearFilter;
 
-                shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars);
+                shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, Object.assign({
+                    depthBuffer: false
+                }, pars));
 
             } else {
                 pars.minFilter = NearestFilter;

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

@@ -6,6 +6,7 @@ import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { HashMap } from "../../../../core/collection/HashMap.js";
 import { strictEquals } from "../../../../core/function/Functions.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { copy_Sampler2D_channel_data } from "../sampler/copy_Sampler2D_channel_data.js";
 
 const CACHE_SIZE = 4194304;
 
@@ -139,10 +140,20 @@ export class ManagedAtlas {
 
                     const image = asset.create();
 
+                    const source = new Sampler2D(image.data, image.itemSize, image.width, image.height);
                     //assert.equal(atlas.patches.filter(p => p.sampler.data === image.data).length, 0, "Atlas already contains this asset data");
 
                     //build sampler
-                    const sampler = new Sampler2D(image.data, 4, image.width, image.height);
+                    let sampler;
+
+                    if (source.itemSize !== 4) {
+                        // source image is not in RGBA layout, resample
+                        sampler = Sampler2D.uint8(4, image.width, image.height);
+                        copy_Sampler2D_channel_data(source, sampler)
+                    } else {
+                        sampler = source;
+                    }
+
                     const patch = atlas.add(sampler);
 
                     //record active patch

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

@@ -164,11 +164,13 @@ export function Sampler2D(data = [], itemSize = 1, width = 0, height = 0) {
      * @type {Number}
      */
     this.height = height;
+
     /**
-     *
+     * Number of channels
      * @type {Number}
      */
     this.itemSize = itemSize;
+
     /**
      *
      * @type {Array<number>|Uint8Array|Uint16Array|Int8Array|Float32Array|Float64Array}

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

@@ -17,7 +17,7 @@ const DEFAULT_TEXTURE_HEIGHT = 512;
  * @return {Sampler2D}
  */
 export function convertTexture2Sampler2D(texture, width, height, flipY = true) {
-
+    // TODO take channel count into account
 
     if (width === undefined || height === undefined) {
 

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

@@ -0,0 +1,66 @@
+/**
+ * Allows copying data from one sampler to another with unequal number of channels (a.itemSize !== b.itemSize)
+ * @example convert RGBA to RGB or R to RGB
+ * @param {Sampler2D} source
+ * @param {Sampler2D} destination
+ */
+export function copy_Sampler2D_channel_data(source, destination) {
+    if (source.width !== destination.width || source.height !== destination.height) {
+        throw new Error('Source and destination dimensions do not match');
+    }
+
+    const source_item_size = source.itemSize;
+    const destination_item_size = destination.itemSize;
+
+    const pixel_count = source.width * source.height;
+
+    const destination_data = destination.data;
+    const source_data = source.data;
+
+    let i, j;
+
+    if (source_item_size === destination_item_size) {
+        // just copy data chunk
+        destination_data.set(source_data);
+
+    } else if (source_item_size > destination_item_size) {
+
+        for (i = 0; i < pixel_count; i++) {
+            const source_sample_offset = i * source_item_size;
+            const destination_sample_offset = i * destination_item_size;
+
+            for (j = 0; j < destination_item_size; j++) {
+                destination_data[destination_sample_offset + j] = source_data[source_sample_offset + j];
+            }
+        }
+
+    } else if (source_item_size === 3 && destination_item_size === 4) {
+        // RGB -> RGBA
+        for (i = 0; i < pixel_count; i++) {
+            const i3 = i * 3;
+            const i4 = i * 4;
+
+            destination_data[i4] = source_data[i3];
+            destination_data[i4 + 1] = source_data[i3 + 1];
+            destination_data[i4 + 2] = source_data[i3 + 2];
+
+            destination_data[i4] = 255; // fill alpha
+        }
+    } else if (source_item_size === 2 && destination_item_size === 4) {
+        //RA -> RGBA
+        for (i = 0; i < pixel_count; i++) {
+            const i2 = i * 2;
+            const i4 = i * 4;
+
+            const r = source_data[i2];
+
+            destination_data[i4] = r;
+            destination_data[i4 + 1] = r;
+            destination_data[i4 + 2] = r;
+
+            destination_data[i4 + 3] = source_data[i2 + 1]; // fill alpha
+        }
+    } else {
+        throw new Error('Unsupported channel layout combination');
+    }
+}

package/engine/graphics/util/composeMatrix4.js

@@ -1,13 +1,11 @@
 /**
  *
- * @param {Matrix4} result
+ * @param {number[]|Float32Array|mat4} result
  * @param {Vector3} position
  * @param {Quaternion} rotation
  * @param {Vector3} scale
  */
-export function composeMatrix4(result, position, rotation, scale) {
-    const te = result.elements;
-
+export function compose_matrix4_array(result, position, rotation, scale) {
     const x = rotation.x;
     const y = rotation.y;
     const z = rotation.z;
@@ -33,23 +31,35 @@ export function composeMatrix4(result, position, rotation, scale) {
     const sy = scale.y;
     const sz = scale.z;
 
-    te[0] = (1 - (yy + zz)) * sx;
-    te[1] = (xy + wz) * sx;
-    te[2] = (xz - wy) * sx;
-    te[3] = 0;
-
-    te[4] = (xy - wz) * sy;
-    te[5] = (1 - (xx + zz)) * sy;
-    te[6] = (yz + wx) * sy;
-    te[7] = 0;
-
-    te[8] = (xz + wy) * sz;
-    te[9] = (yz - wx) * sz;
-    te[10] = (1 - (xx + yy)) * sz;
-    te[11] = 0;
-
-    te[12] = position.x;
-    te[13] = position.y;
-    te[14] = position.z;
-    te[15] = 1;
+    result[0] = (1 - (yy + zz)) * sx;
+    result[1] = (xy + wz) * sx;
+    result[2] = (xz - wy) * sx;
+    result[3] = 0;
+
+    result[4] = (xy - wz) * sy;
+    result[5] = (1 - (xx + zz)) * sy;
+    result[6] = (yz + wx) * sy;
+    result[7] = 0;
+
+    result[8] = (xz + wy) * sz;
+    result[9] = (yz - wx) * sz;
+    result[10] = (1 - (xx + yy)) * sz;
+    result[11] = 0;
+
+    result[12] = position.x;
+    result[13] = position.y;
+    result[14] = position.z;
+    result[15] = 1;
+}
+
+/**
+ *
+ * @param {Matrix4} result
+ * @param {Vector3} position
+ * @param {Quaternion} rotation
+ * @param {Vector3} scale
+ */
+export function composeMatrix4(result, position, rotation, scale) {
+    const te = result.elements;
+    compose_matrix4_array(te, position, rotation, scale);
 }

package/engine/graphics/util/decompose_matrix_4_array.js

@@ -0,0 +1,61 @@
+/**
+ *
+ * @param {number[]} m
+ * @param {Vector3} position
+ * @param {Quaternion} rotation
+ * @param {Vector3} scale
+ */
+export function decompose_matrix_4_array(m, position, rotation, scale) {
+    const m11 = m[0];
+    const m12 = m[1];
+    const m13 = m[2];
+
+    const m21 = m[4];
+    const m22 = m[5];
+    const m23 = m[6];
+
+    const m31 = m[8];
+    const m32 = m[9];
+    const m33 = m[10];
+
+    const scale_x = Math.hypot(m11, m12, m13);
+    const scale_y = Math.hypot(m21, m22, m23);
+    const scale_z = Math.hypot(m31, m32, m33);
+
+    // extract rotation
+    const is1 = 1 / scale_x;
+    const is2 = 1 / scale_y;
+    const is3 = 1 / scale_z;
+
+    const sm11 = m11 * is1;
+    const sm12 = m12 * is1;
+    const sm13 = m13 * is1;
+
+    const sm21 = m21 * is2;
+    const sm22 = m22 * is2;
+    const sm23 = m23 * is2;
+
+    const sm31 = m31 * is3;
+    const sm32 = m32 * is3;
+    const sm33 = m33 * is3;
+
+    // write out results
+
+    position.set(
+        m[12],
+        m[13],
+        m[14]
+    );
+
+    scale.set(
+        scale_x,
+        scale_y,
+        scale_z
+    );
+
+    rotation.__setFromRotationMatrix(
+        sm11, sm21, sm31,
+        sm12, sm22, sm32,
+        sm13, sm23, sm33
+    );
+}

package/engine/intelligence/behavior/ecs/BehaviorComponent.js

@@ -1,5 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import { ClockChannelType } from "./ClockChannelType.js";
+import { RepeatBehavior } from "../decorator/RepeatBehavior.js";
+import { ActionBehavior } from "../primitive/ActionBehavior.js";
 
 export const BehaviorComponentFlag = {
     AllowSleep: 1
@@ -25,24 +27,38 @@ export class BehaviorComponent {
          */
         this.flags = 0;
     }
-}
 
-/**
- *
- * @param {Behavior} b
- * @returns {BehaviorComponent}
- */
-BehaviorComponent.fromOne = function (b) {
-    assert.notEqual(b, undefined, 'behavior is undefined');
-    assert.notEqual(b, null, 'behavior is null');
-    assert.equal(b.isBehavior, true, 'b.isBehavior !== true');
 
-    const result = new BehaviorComponent();
+    /**
+     *
+     * @param {function} f
+     * @param {*} [thisArg]
+     * @returns {BehaviorComponent}
+     */
+    static looping_function(f, thisArg) {
+        return BehaviorComponent.fromOne(RepeatBehavior.from(
+            new ActionBehavior(f, thisArg)
+        ));
+    }
 
-    result.list.push(b);
+    /**
+     *
+     * @param {Behavior} b
+     * @returns {BehaviorComponent}
+     */
+    static fromOne(b) {
+        assert.notEqual(b, undefined, 'behavior is undefined');
+        assert.notEqual(b, null, 'behavior is null');
+        assert.equal(b.isBehavior, true, 'b.isBehavior !== true');
 
-    return result;
-};
+        const result = new BehaviorComponent();
+
+        result.list.push(b);
+
+        return result;
+
+    }
+}
 
 /**
  * @readonly

package/engine/knowledge/database/StaticKnowledgeDataTable.js

@@ -222,7 +222,7 @@ export class StaticKnowledgeDataTable {
             } catch (e) {
 
                 let id;
-                //attempt to extract talent ID
+                //attempt to extract item ID
                 try {
                     id = datum.id;
                 } catch (e) {
@@ -243,6 +243,11 @@ export class StaticKnowledgeDataTable {
                 return;
             }
 
+            if (this.contains(id)) {
+                console.error(`Duplicate id '${id}'`);
+                return;
+            }
+
             this.__json.set(id, datum);
 
             const added = this.add(element);

package/engine/navigation/ecs/components/Path.js

@@ -270,11 +270,6 @@ class Path {
     copy(other) {
         this.__data.copy(other.__data);
         this.interpolation = other.interpolation;
-
-        // Traversal variables
-        this.markerOffset = other.markerOffset;
-        this.markerIndex = other.markerIndex;
-        this.markerDistanceToNext = other.markerDistanceToNext;
     }
 
     /**

package/package.json

@@ -4,7 +4,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.24",
+  "version": "2.33.28",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",

package/view/minimap/gl/MinimapWorldGL.js

@@ -171,13 +171,20 @@ export class MinimapWorldGL {
     }
 
     update() {
-        this.layers.forEach(o => {
-            o.update(this.camera);
-            if (o.needsRender) {
+        const layers = this.layers;
+        const layer_count = layers.length;
+
+        for (let i = 0; i < layer_count; i++) {
+            const layer = layers[i];
+
+            layer.update(this.camera);
+
+            if (layer.needsRender) {
                 this.renderNeedsUpdate = true;
-                o.needsRender = false;
+                layer.needsRender = false;
             }
-        });
+
+        }
 
         if (this.renderNeedsUpdate) {
             this.render();

package/core/geom/3d/shape/CompositeShape.js

@@ -1,60 +0,0 @@
-import { AbstractShape3D } from "./AbstractShape3D.js";
-import { weightedRandomFromArray } from "../../../collection/array/weightedRandomFromArray.js";
-
-
-const scratch_array = [];
-
-/**
- *
- * @param {AbstractShape3D} shape
- * @return {number}
- */
-function getVolume(shape) {
-    return shape.volume;
-}
-
-export class CompositeShape extends AbstractShape3D {
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {AbstractShape3D[]}
-         */
-        this.children = [];
-    }
-
-    get volume() {
-        let r = 0;
-
-        const children = this.children;
-        const child_count = children.length;
-        for (let i = 0; i < child_count; i++) {
-            const child = children[i];
-
-            r += child.volume;
-        }
-
-        return r;
-    }
-
-    get surface_area(){
-        let r = 0;
-
-        const children = this.children;
-        const child_count = children.length;
-        for (let i = 0; i < child_count; i++) {
-            const child = children[i];
-
-            r += child.surface_area;
-        }
-
-        return r;
-    }
-
-    sample_random_point_in_volume(result, result_offset, random) {
-        const child = weightedRandomFromArray(this.children, random, getVolume);
-
-        return child.sample_random_point_in_volume(result, result_offset, random);
-    }
-}