@woosh/meep-engine 2.39.5 → 2.39.9

package/engine/graphics/ecs/path/tube/TubePathStyle.js

@@ -5,6 +5,8 @@ import { MatcapMaterialDefinition } from "./MatcapMaterialDefinition.js";
 import { CapType } from "./CapType.js";
 import { StandardMaterialDefinition } from "./StandardMaterialDefinition.js";
 import { BasicMaterialDefinition } from "./BasicMaterialDefinition.js";
+import { PathNormalType } from "./PathNormalType.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
 
 const DEFAULT_COLOR = Object.freeze({ r: 1, g: 1, b: 1 });
 
@@ -51,8 +53,6 @@ export class TubePathStyle {
          */
         this.shape_normals = null;
 
-        // TODO expose shading style "flat/smooth"
-
         /**
          *
          * @type {number}
@@ -71,6 +71,17 @@ export class TubePathStyle {
          */
         this.receive_shadow = false;
 
+        /**
+         * @type {PathNormalType}
+         */
+        this.path_normal_type = PathNormalType.Automatic;
+
+        /**
+         *
+         * @type {Vector3}
+         */
+        this.path_normal = Vector3.up;
+
         /**
          * Which parts of the path to visualise, in normalized offsets
          * @example [ 0, 1 ] = whole path
@@ -120,7 +131,9 @@ export class TubePathStyle {
                  receive_shadow = false,
                  path_mask = [0, 1],
                  cap_type = CapType.None,
-                 shape
+                 shape,
+                 path_normal = Vector3.up,
+                 path_normal_type = PathNormalType.Automatic
              }) {
         assert.enum(material_type, TubeMaterialType, 'material_type');
         assert.isNumber(opacity, 'opacity');
@@ -135,6 +148,7 @@ export class TubePathStyle {
         assert.greaterThanOrEqual(path_mask.length, 2, 'path_mask length bust be at least 2');
         assert.ok(path_mask.length % 2 === 0, 'path_mask length bust be multiple of 2');
         assert.enum(cap_type, CapType, 'cap_type');
+        assert.enum(path_normal_type, PathNormalType, 'path_normal_type');
 
         if (shape === undefined) {
             // legacy API, using circle
@@ -177,6 +191,10 @@ export class TubePathStyle {
         }
 
         this.material.fromJSON(material);
+
+
+        this.path_normal.fromJSON(path_normal);
+        this.path_normal_type = path_normal_type;
     }
 }
 

package/engine/graphics/ecs/path/tube/build/build_geometry_catmullrom.js

@@ -1,6 +1,7 @@
 import { computeFrenetFrames } from "./computeFrenetFrames.js";
 import { makeTubeGeometry } from "./makeTubeGeometry.js";
 import Vector3 from "../../../../../../core/geom/Vector3.js";
+import { PathNormalType } from "../PathNormalType.js";
 
 /**
  *
@@ -63,7 +64,9 @@ export function build_geometry_catmullrom(
         added_points++;
     }
 
-    const frames = computeFrenetFrames(points_f32, false);
+    const normal_hint = style.path_normal_type === PathNormalType.FixedStart ? style.path_normal : undefined;
+
+    const frames = computeFrenetFrames(points_f32, false, normal_hint);
 
     return makeTubeGeometry(
         points_f32, frames.normals, frames.binormals, frames.tangents,

package/engine/graphics/ecs/path/tube/build/build_geometry_linear.js

@@ -1,6 +1,7 @@
 import { computeFrenetFrames } from "./computeFrenetFrames.js";
 import { makeTubeGeometry } from "./makeTubeGeometry.js";
 import Vector3 from "../../../../../../core/geom/Vector3.js";
+import { PathNormalType } from "../PathNormalType.js";
 
 
 const scratch_array_0 = [];
@@ -57,7 +58,9 @@ export function build_geometry_linear(
         points_added++;
     }
 
-    const frames = computeFrenetFrames(points, false);
+    const normal_hint = style.path_normal_type === PathNormalType.FixedStart ? style.path_normal : undefined;
+
+    const frames = computeFrenetFrames(points, false, normal_hint);
 
     return makeTubeGeometry(
         points, frames.normals, frames.binormals, frames.tangents,

package/engine/graphics/ecs/path/tube/build/computeFrenetFrames.js

@@ -5,13 +5,49 @@ import { clamp } from "../../../../../../core/math/clamp.js";
 import { vec3 } from "gl-matrix";
 import { array_copy } from "../../../../../../core/collection/array/copyArray.js";
 
+/**
+ * Compute a normal vector for Frenet frame based on a tangent (direction in which vertex points)
+ * @param {Vector3} result
+ * @param {Vector3} tangent
+ */
+function computeNormalHintFromTangent(result, tangent) {
+    let min = Number.MAX_VALUE;
+
+    const tx = Math.abs(tangent.x);
+    const ty = Math.abs(tangent.y);
+    const tz = Math.abs(tangent.z);
+
+    if (ty <= min) {
+
+        min = ty;
+        result.set(0, 1, 0);
+
+    }
+
+    if (tz < min) {
+
+        min = tz;
+        result.set(0, 0, 1);
+
+    }
+
+    if (tx < min) {
+
+        min = tx;
+        result.set(1, 0, 0);
+
+    }
+
+}
+
 /**
  * @see https://github.com/mrdoob/three.js/blob/c12c9a166a1369cdd58622fff2aff7e3a84305d7/src/extras/core/Curve.js#L260
  * @param {Float32Array|number[]} points
  * @param {boolean} [closed]
+ * @param {Vector3} [normal_hint]
  * @returns {{normals:Vector3[], binormals:Vector3[], tangents:Vector3[]}}
  */
-export function computeFrenetFrames(points, closed = false) {
+export function computeFrenetFrames(points, closed = false, normal_hint) {
     // see http://www.cs.indiana.edu/pub/techreports/TR425.pdf
 
     const normal = new Vector3();
@@ -82,30 +118,11 @@ export function computeFrenetFrames(points, closed = false) {
 
     normals[0] = new Vector3();
     binormals[0] = new Vector3();
-    let min = Number.MAX_VALUE;
-    const tx = Math.abs(tangents[0].x);
-    const ty = Math.abs(tangents[0].y);
-    const tz = Math.abs(tangents[0].z);
-
-    if (ty <= min) {
-
-        min = ty;
-        normal.set(0, 1, 0);
-
-    }
-
-    if (tz < min) {
-        min = tz;
-
-        normal.set(0, 0, 1);
-
-    }
-
-    if (tx < min) {
-
-        min = tx;
-        normal.set(1, 0, 0);
 
+    if (normal_hint !== undefined) {
+        normal.copy(normal_hint);
+    } else {
+        computeNormalHintFromTangent(normal, tangents[0]);
     }
 
     vec.crossVectors(tangents[0], normal).normalize();

package/engine/graphics/geometry/VertexDataSpec.js

@@ -20,6 +20,19 @@ export class VertexDataSpec {
         this.__hash = DEFAULT_HASH;
     }
 
+    /**
+     *
+     * @param {AttributeSpec} attributes
+     * @returns {VertexDataSpec}
+     */
+    static from(...attributes) {
+        const r = new VertexDataSpec();
+
+        r.addMany(attributes);
+
+        return r;
+    }
+
     /**
      *
      * @param {string} name
@@ -61,6 +74,17 @@ export class VertexDataSpec {
         return undefined;
     }
 
+    /**
+     *
+     * @param {AttributeSpec[]} attributes
+     */
+    addMany(attributes) {
+        const n = attributes.length;
+        for (let i = 0; i < n; i++) {
+            this.add(attributes[i]);
+        }
+    }
+
     /**
      *
      * @param {AttributeSpec} attribute

package/engine/graphics/geometry/buffered/query/RaycastNearestHitComputingVisitor.js

@@ -4,6 +4,7 @@ import Vector3 from "../../../../../core/geom/Vector3.js";
 import { computeTriangleRayIntersection } from "../../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import { GeometrySpatialAcceleratorVisitor } from "./GeometryVisitor.js";
 import { aabb3_intersects_ray } from "../../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
+import { assert } from "../../../../../core/assert.js";
 
 export class RaycastNearestHitComputingVisitor extends GeometrySpatialAcceleratorVisitor {
     constructor() {
@@ -18,14 +19,14 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
         this.__nearest_distance = Number.POSITIVE_INFINITY;
 
         /**
-         *
+         * @readonly
          * @type {SurfacePoint3}
          * @private
          */
         this.__nearest_hit = new SurfacePoint3();
 
         /**
-         *
+         * @readonly
          * @type {SurfacePoint3}
          * @private
          */
@@ -39,7 +40,18 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
          */
         this.__hit_found = false;
 
+        /**
+         * @readonly
+         * @type {Vector3}
+         * @private
+         */
         this.__ray_origin = new Vector3();
+
+        /**
+         * @readonly
+         * @type {Vector3}
+         * @private
+         */
         this.__ray_direction = new Vector3();
     }
 
@@ -98,6 +110,8 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
 
             const indices = this.__buffer_indices;
 
+            assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
+
             const a = indices[index3];
             const b = indices[index3 + 1];
             const c = indices[index3 + 2];
@@ -111,6 +125,10 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
             const b_address = b * stride + offset;
             const c_address = c * stride + offset;
 
+            assert.lessThan(a_address + 2, vertices.length, 'a-vertex overflow');
+            assert.lessThan(b_address + 2, vertices.length, 'b-vertex overflow');
+            assert.lessThan(c_address + 2, vertices.length, 'c-vertex overflow');
+
             const ax = vertices[a_address];
             const ay = vertices[a_address + 1];
             const az = vertices[a_address + 2];
@@ -123,8 +141,10 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
             const cy = vertices[c_address + 1];
             const cz = vertices[c_address + 2];
 
+            const temp_hit = this.__temp_hit;
+
             if (computeTriangleRayIntersection(
-                this.__temp_hit,
+                temp_hit,
                 rayOrigin.x,
                 rayOrigin.y,
                 rayOrigin.z,
@@ -135,10 +155,10 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
                 bx, by, bz,
                 cx, cy, cz
             )) {
-                const d = this.__temp_hit.position.distanceSqrTo(rayOrigin);
+                const d = temp_hit.position.distanceSqrTo(rayOrigin);
 
                 if (d < this.__nearest_distance) {
-                    this.__nearest_hit.copy(this.__temp_hit);
+                    this.__nearest_hit.copy(temp_hit);
                     this.__nearest_distance = d;
 
                     this.__hit_found = true;

package/engine/graphics/shaders/TerrainShader.js

@@ -99,7 +99,7 @@ function fragment() {
     precision highp sampler2DArray;
     
     uniform sampler2DArray splatWeightMap;
-    uniform float splatLayerCount;
+    uniform int splatLayerCount;
     
     uniform vec2 splatResolution;
    
@@ -280,13 +280,9 @@ function fragment() {
         float weightSum = 0.0;
         vec4 colorSum = vec4(0.0);
         
-        float m = 1.0 / splatLayerCount ;
-        
-        for( float i = 0.0; i < splatLayerCount; i++){
-               
-            float nI = i * m;
+        for( int i = 0; i < splatLayerCount; i++){
                
-            vec2 scale = texture2D(materialScalesMap, vec2(nI, 0.0) ).xy;
+            vec2 scale = texelFetch(materialScalesMap, ivec2(i, 0), 0 ).xy;
             
             vec2 layerUv = vUv * scale;
             

package/engine/knowledge/database/StaticKnowledgeDataTable.js

@@ -4,6 +4,33 @@ import Task from "../../../core/process/task/Task.js";
 import { assert } from "../../../core/assert.js";
 import TaskSignal from "../../../core/process/task/TaskSignal.js";
 
+let id_seed = 0;
+
+/**
+ *
+ * @param {{contains:function(string):boolean}} database
+ * @returns {string}
+ */
+function generate_id(database) {
+    let retries_left = 10000;
+    let id;
+
+    do {
+        id = id_seed.toString(16);
+
+        id_seed++;
+
+        retries_left--;
+
+        if (retries_left <= 0) {
+            throw new Error(`Couldn't find a unique ID after maximum number of attempts`);
+        }
+
+    } while (database.contains(id))
+
+    return id;
+}
+
 /**
  * Base class for managing various kinds of static game data
  * @template T
@@ -11,31 +38,31 @@ import TaskSignal from "../../../core/process/task/TaskSignal.js";
 export class StaticKnowledgeDataTable {
 
     /**
-     * @constructor
-     * @template T
+     * Elements mapped by their string ID
+     * @type {Object<T>}
      */
-    constructor() {
+    elements = {};
 
-        /**
-         * Elements mapped by their string ID
-         * @type {Object<T>}
-         */
-        this.elements = {};
+    /**
+     *
+     * @type {Map<string, object>}
+     * @protected
+     */
+    __json = new Map();
 
-        /**
-         *
-         * @type {Map<string, object>}
-         * @protected
-         */
-        this.__json = new Map();
+    /**
+     * Array representation of elements, useful for fast traversal
+     * @type {T[]}
+     * @protected
+     */
+    __array = [];
 
-        /**
-         * Array representation of elements, useful for fast traversal
-         * @type {T[]}
-         * @protected
-         */
-        this.__array = [];
-    }
+    /**
+     * Allow automatic ID generation when ID is not present
+     * @type {boolean}
+     * @protected
+     */
+    __automatic_ids = false;
 
     reset() {
         Object.keys(this.elements).forEach(id => {
@@ -208,11 +235,17 @@ export class StaticKnowledgeDataTable {
         const task = countTask(0, n, i => {
             const datum = data[i];
 
-            const id = datum.id;
+            let id = datum.id;
 
             if (typeof id !== "string") {
-                console.error(`datum.id must be a string, instead was '${typeof id}' (= ${id})`);
-                return;
+
+                if (this.__automatic_ids) {
+                    id = generate_id(this);
+                } else {
+                    console.error(`datum.id must be a string, instead was '${typeof id}' (= ${id})`);
+                    return;
+                }
+
             }
 
             let element;
@@ -221,15 +254,15 @@ export class StaticKnowledgeDataTable {
                 element = this.parse(datum);
             } catch (e) {
 
-                let id;
+                let _id;
                 //attempt to extract item ID
                 try {
-                    id = datum.id;
+                    _id = datum.id;
                 } catch (e) {
-                    id = 'ERROR';
+                    _id = 'ERROR';
                 }
 
-                console.error(`Failed to parse element (id=${id})`, e, datum);
+                console.error(`Failed to parse element (id=${_id})`, e, datum);
                 return;
             }
 
@@ -250,6 +283,11 @@ export class StaticKnowledgeDataTable {
 
             this.__json.set(id, datum);
 
+            if (datum.id !== id) {
+                // ID was generated, write it back into the element
+                element.id = id;
+            }
+
             const added = this.add(element);
 
             if (!added) {