@woosh/meep-engine 3.0.0 → 3.0.2

package/src/engine/graphics/geometry/AttributeData.js

@@ -0,0 +1,84 @@
+import { assert } from "../../../core/assert.js";
+import {
+    compute_typed_array_constructor_from_data_type
+} from "../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
+
+/**
+ * An {@link AttributeSpec} and the elements stored under it.
+ *
+ * The spec says what one item is — how many components, in what type, whether integer values are
+ * read back normalized — and the array holds `count` of them end to end. Nothing here knows about a
+ * renderer: uploading is the business of whoever is drawing, and a consumer that re-reads the array
+ * every frame has nothing to be told.
+ */
+export class AttributeData {
+    /**
+     * @type {AttributeSpec}
+     */
+    spec;
+
+    /**
+     * `count * spec.itemSize` elements, item-major.
+     *
+     * @type {Float32Array|Float64Array|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array}
+     */
+    array;
+
+    /**
+     * @param {AttributeSpec} spec
+     * @param {Float32Array|Float64Array|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array} array
+     */
+    constructor(spec, array) {
+        assert.defined(spec, 'spec');
+        assert.defined(array, 'array');
+
+        this.spec = spec;
+        this.array = array;
+    }
+
+    /**
+     * @returns {string}
+     */
+    get name() {
+        return this.spec.name;
+    }
+
+    /**
+     * @returns {number}
+     */
+    get itemSize() {
+        return this.spec.itemSize;
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    get normalized() {
+        return this.spec.normalized;
+    }
+
+    /**
+     * How many items the array has room for.
+     *
+     * @returns {number}
+     */
+    get count() {
+        return this.array.length / this.spec.itemSize;
+    }
+
+    /**
+     * Allocate storage for `count` items of `spec`.
+     *
+     * @param {AttributeSpec} spec
+     * @param {number} count
+     * @returns {AttributeData}
+     */
+    static allocate(spec, count) {
+        assert.defined(spec, 'spec');
+        assert.isNonNegativeInteger(count, 'count');
+
+        const TypedArray = compute_typed_array_constructor_from_data_type(spec.type);
+
+        return new AttributeData(spec, new TypedArray(spec.itemSize * count));
+    }
+}

package/src/engine/graphics/geometry/buffered/computeBufferAttributeHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeBufferAttributeHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeBufferAttributeHash.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,sDAHW,MAAM,eAAe,GACnB,MAAM,CAgBlB"}
+{"version":3,"file":"computeBufferAttributeHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeBufferAttributeHash.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,8EAFa,MAAM,CAgBlB"}

package/src/engine/graphics/geometry/buffered/computeGeometryEquality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeGeometryEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryEquality.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,2CAJW,MAAM,cAAc,KACpB,MAAM,cAAc,GAClB,OAAO,CAmDnB"}
+{"version":3,"file":"computeGeometryEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryEquality.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,2FAFa,OAAO,CAmDnB"}

package/src/engine/graphics/geometry/buffered/computeGeometryHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeGeometryHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryHash.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,8CAHW,MAAM,cAAc,GAClB,MAAM,CAmBlB"}
+{"version":3,"file":"computeGeometryHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryHash.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,qEAFa,MAAM,CAmBlB"}

package/src/engine/graphics/geometry/buffered/compute_buffer_geometry_byte_size.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_buffer_geometry_byte_size.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/compute_buffer_geometry_byte_size.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qDAHW,MAAM,cAAc,GAClB,MAAM,CAmBlB"}
+{"version":3,"file":"compute_buffer_geometry_byte_size.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/compute_buffer_geometry_byte_size.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4EAFa,MAAM,CAmBlB"}

package/src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_indexed.d.ts

@@ -1,5 +1,9 @@
 /**
- * based on code from THREE.js
+ * A port of three's `BufferGeometry.computeVertexNormals` indexed path, over flat arrays
+ * rather than attributes.
+ *
+ * Derived from three.js (https://github.com/mrdoob/three.js), Copyright (c) 2010-2024 three.js authors, MIT licence.
+ *
  * Prior to calling this function, normals need to be set to 0
  * @param {Array.<number>|Float32Array} positions
  * @param {Array.<number>|Float32Array} normals

package/src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_indexed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_compute_vertex_normals_indexed.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_indexed.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,mEAJW,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,QAgC3D"}
+{"version":3,"file":"geometry_compute_vertex_normals_indexed.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_indexed.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,mEAJW,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,QAgC3D"}

package/src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_indexed.js

@@ -1,45 +1,49 @@
-import { v3_add_array } from "../../../../core/geom/vec3/v3_add_array.js";
-import { geometry_construct_triangle_normal } from "../geometry_construct_triangle_normal.js";
-import { v3_array_normalize_many } from "./v3_array_normalize_many.js";
-
-const scratch_v3 = new Float64Array(3);
-
-/**
- * based on code from THREE.js
- * Prior to calling this function, normals need to be set to 0
- * @param {Array.<number>|Float32Array} positions
- * @param {Array.<number>|Float32Array} normals
- * @param {Array.<number>|Uint32Array|Uint16Array|Uint8Array} indices
- */
-export function geometry_compute_vertex_normals_indexed(
-    positions,
-    normals,
-    indices
-) {
-
-    const index_length = indices.length;
-    for (let i = 0; i < index_length; i += 3) {
-
-        const a = indices[i];
-        const b = indices[i + 1];
-        const c = indices[i + 2];
-
-
-        geometry_construct_triangle_normal(
-            scratch_v3, 0,
-            a, b, c, positions
-        );
-
-        // accumulate
-
-        v3_add_array(normals, a * 3, scratch_v3, 0);
-        v3_add_array(normals, b * 3, scratch_v3, 0);
-        v3_add_array(normals, c * 3, scratch_v3, 0);
-
-    }
-
-    // restore unit magnitude
-
-    v3_array_normalize_many(normals);
-}
-
+import { v3_add_array } from "../../../../core/geom/vec3/v3_add_array.js";
+import { geometry_construct_triangle_normal } from "../geometry_construct_triangle_normal.js";
+import { v3_array_normalize_many } from "./v3_array_normalize_many.js";
+
+const scratch_v3 = new Float64Array(3);
+
+/**
+ * A port of three's `BufferGeometry.computeVertexNormals` indexed path, over flat arrays
+ * rather than attributes.
+ *
+ * Derived from three.js (https://github.com/mrdoob/three.js), Copyright (c) 2010-2024 three.js authors, MIT licence.
+ *
+ * Prior to calling this function, normals need to be set to 0
+ * @param {Array.<number>|Float32Array} positions
+ * @param {Array.<number>|Float32Array} normals
+ * @param {Array.<number>|Uint32Array|Uint16Array|Uint8Array} indices
+ */
+export function geometry_compute_vertex_normals_indexed(
+    positions,
+    normals,
+    indices
+) {
+
+    const index_length = indices.length;
+    for (let i = 0; i < index_length; i += 3) {
+
+        const a = indices[i];
+        const b = indices[i + 1];
+        const c = indices[i + 2];
+
+
+        geometry_construct_triangle_normal(
+            scratch_v3, 0,
+            a, b, c, positions
+        );
+
+        // accumulate
+
+        v3_add_array(normals, a * 3, scratch_v3, 0);
+        v3_add_array(normals, b * 3, scratch_v3, 0);
+        v3_add_array(normals, c * 3, scratch_v3, 0);
+
+    }
+
+    // restore unit magnitude
+
+    v3_array_normalize_many(normals);
+}
+

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.d.ts

@@ -1,10 +1,20 @@
+/**
+ * CPU spatial queries over a {@link Geometry}'s own triangles — a raycast, and an overlap against a
+ * clipping volume — accelerated by a triangle BVH built on first ask and cached per geometry.
+ *
+ * **This is the CPU side, and it is not what picking uses.** Picking under Shade reads the
+ * visibility buffer (I-9); this answers for callers that need a surface point rather than an entity,
+ * on geometry the CPU already holds — a generated primitive, a trail, a tile, anything a tool built.
+ *
+ * **A `MeshletGeometry` cannot be asked.** Its triangles are quantized inside meshlet pages;
+ * `geometry_build_from_meshlet_geometry` decodes one back into a `Geometry`, and that decode is the
+ * caller's to make and to hold on to, because it is far more expensive than the tree built over it.
+ */
 export class GeometrySpatialQueryAccelerator {
-    constructor(cache_size?: number);
     /**
-     * @private
-     * @type {Cache<THREE.BufferGeometry, BinaryUint32BVH>}
+     * @param {number} [cache_size] in bytes
      */
-    private cache;
+    constructor(cache_size?: number);
     /**
      *
      * @param {number} value in bytes
@@ -16,24 +26,27 @@ export class GeometrySpatialQueryAccelerator {
      */
     get cache_size(): number;
     /**
+     * Does any triangle of the geometry lie inside the volume the planes bound?
      *
-     * @param {THREE.BufferGeometry} geometry
-     * @param {Plane[]} planes
+     * @param {Geometry} geometry
+     * @param {number[]|Float32Array} planes 4-tuples of `normal_x, normal_y, normal_z, constant`; a point is inside when the dot product plus the constant is non-negative for every plane
+     * @param {number} planes_offset
+     * @param {number} plane_count
      * @returns {boolean} true means some overlap exists, false otherwise
      */
-    queryContainmentViaClippingPlanes(geometry: THREE.BufferGeometry, planes: Plane[]): boolean;
+    queryContainmentViaClippingPlanes(geometry: Geometry, planes: number[] | Float32Array, planes_offset: number, plane_count: number): boolean;
     /**
      *
      * @param {SurfacePoint3} destination
-     * @param {THREE.BufferGeometry} geometry
+     * @param {Geometry} geometry
      * @param {number[]|ArrayLike<number>|Float32Array} ray 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
      * @return {boolean}
      */
-    queryRaycastNearest_array(destination: SurfacePoint3, geometry: THREE.BufferGeometry, ray: number[] | ArrayLike<number> | Float32Array): boolean;
+    queryRaycastNearest_array(destination: SurfacePoint3, geometry: Geometry, ray: number[] | ArrayLike<number> | Float32Array): boolean;
     /**
      *
      * @param {SurfacePoint3} destination
-     * @param {THREE.BufferGeometry} geometry
+     * @param {Geometry} geometry
      * @param {number} ray_origin_x
      * @param {number} ray_origin_y
      * @param {number} ray_origin_z
@@ -42,34 +55,33 @@ export class GeometrySpatialQueryAccelerator {
      * @param {number} ray_direction_z
      * @return {boolean}
      */
-    queryRaycastNearest_primitive(destination: SurfacePoint3, geometry: THREE.BufferGeometry, ray_origin_x: number, ray_origin_y: number, ray_origin_z: number, ray_direction_x: number, ray_direction_y: number, ray_direction_z: number): boolean;
+    queryRaycastNearest_primitive(destination: SurfacePoint3, geometry: Geometry, ray_origin_x: number, ray_origin_y: number, ray_origin_z: number, ray_direction_x: number, ray_direction_y: number, ray_direction_z: number): boolean;
     /**
      * Get the nearest ray intersection
      * @param {SurfacePoint3} destination
-     * @param {THREE.BufferGeometry} geometry
+     * @param {Geometry} geometry
      * @param {Vector3} ray_origin
      * @param {Vector3} ray_direction
      * @returns {boolean} true if hit detected, false otherwise
      */
-    queryRaycastNearest(destination: SurfacePoint3, geometry: THREE.BufferGeometry, ray_origin: Vector3, ray_direction: Vector3): boolean;
+    queryRaycastNearest(destination: SurfacePoint3, geometry: Geometry, ray_origin: Vector3, ray_direction: Vector3): boolean;
     /**
-     * Destroys cache for a given geometry, useful for when geometry changes and cache needs to be invalidated
-     * @param {THREE.BufferGeometry} geometry
+     * Drop a geometry's tree, releasing the memory it holds.
+     *
+     * Not needed to pick up an edit — a query does that off the geometry's own version — this is for
+     * a geometry that will not be asked again.
+     *
+     * @param {Geometry} geometry
      * @returns {boolean}
      */
-    cache_remove_geometry(geometry: THREE.BufferGeometry): boolean;
+    cache_remove_geometry(geometry: Geometry): boolean;
     /**
      * NOTE: do not modify the BVH
-     * @param {THREE.BufferGeometry} geometry
-     * @returns {BinaryUint32BVH}
-     */
-    acquire_bvh(geometry: THREE.BufferGeometry): BinaryUint32BVH;
-    /**
-     * @private
-     * @param {THREE.BufferGeometry} geometry
+     * @param {Geometry} geometry
      * @returns {BinaryUint32BVH}
      */
-    private __build_bvh;
+    acquire_bvh(geometry: Geometry): BinaryUint32BVH;
+    #private;
 }
 export namespace GeometrySpatialQueryAccelerator {
     let INSTANCE: GeometrySpatialQueryAccelerator;

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GeometrySpatialQueryAccelerator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js"],"names":[],"mappings":"AAiBA;IACI,iCA4BC;IArBG;;;OAGG;IACH,cAeE;IAIN;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,4CAJW,MAAM,cAAc,UACpB,OAAO,GACL,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,gEAJW,MAAM,cAAc,OACpB,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACtC,OAAO,CASlB;IAED;;;;;;;;;;;OAWG;IACH,oEATW,MAAM,cAAc,gBACpB,MAAM,gBACN,MAAM,gBACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,GACL,OAAO,CAyDlB;IAED;;;;;;;OAOG;IACH,0DALW,MAAM,cAAc,gDAGlB,OAAO,CAcnB;IAED;;;;OAIG;IACH,gCAHW,MAAM,cAAc,GAClB,OAAO,CAMnB;IAED;;;;OAIG;IACH,sBAHW,MAAM,cAAc,GAClB,eAAe,CAiB3B;IAED;;;;OAIG;IACH,oBAyBC;CAEJ;;kBAIS,+BAA+B;;gCA5RT,sDAAsD"}
+{"version":3,"file":"GeometrySpatialQueryAccelerator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;GAWG;AACH;IAMI;;OAEG;IACH,yBAFW,MAAM,EA0BhB;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;;;OAQG;IACH,8DALW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;;OAMG;IACH,+EAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACtC,OAAO,CASlB;IAED;;;;;;;;;;;OAWG;IACH,4FARW,MAAM,gBACN,MAAM,gBACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,GACL,OAAO,CAuBlB;IAED;;;;;;;OAOG;IACH,kHAFa,OAAO,CAcnB;IAED;;;;;;;;OAQG;IACH,2CAFa,OAAO,CAMnB;IAED;;;;OAIG;IACH,iCAFa,eAAe,CAuB3B;;CAsBJ;;kBAIS,+BAA+B;;gCA5RT,sDAAsD"}