@woosh/meep-engine 2.33.24 → 2.33.25

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);
         });
     }
 }
@@ -298,7 +317,7 @@ function prepare_scene_0() {
 
     const bounds_size = 15;
 
-    const light_radius = 5;
+    const light_radius = 2;
 
     for (let i = 0; i < 5000; i++) {
         const radius = randomFloatBetween(random, light_radius, light_radius);
@@ -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);
 
     });

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/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.25",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",