@woosh/meep-engine 2.128.23 → 2.129.0

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.128.23",
+  "version": "2.129.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/collection/array/typed/typed_array_value_denormalize.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Denormalizes the given value according to the given typed array.
+ *
+ * @param {number} value - The value to denormalize.
+ * @param {TypedArray} array - The typed array that defines the data type of the value.
+ * @return {number} The denormalize (float) value in the range `[0,1]`.
+ */
+export function typed_array_value_denormalize(value: number, array: TypedArray): number;
+//# sourceMappingURL=typed_array_value_denormalize.d.ts.map

package/src/core/collection/array/typed/typed_array_value_denormalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed_array_value_denormalize.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/typed_array_value_denormalize.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qDAJW,MAAM,sBAEL,MAAM,CAyCjB"}

package/src/core/collection/array/typed/typed_array_value_denormalize.js

@@ -0,0 +1,47 @@
+/**
+ * Denormalizes the given value according to the given typed array.
+ *
+ * @param {number} value - The value to denormalize.
+ * @param {TypedArray} array - The typed array that defines the data type of the value.
+ * @return {number} The denormalize (float) value in the range `[0,1]`.
+ */
+export function typed_array_value_denormalize( value, array ) {
+    // taken from https://github.com/mrdoob/three.js/blob/da275a4e00536723155b68518944de5eb7945550/src/math/MathUtils.js#L388
+
+    switch ( array.constructor ) {
+
+        case Float32Array:
+
+            return value;
+
+        case Uint32Array:
+
+            return value / 4294967295.0;
+
+        case Uint16Array:
+
+            return value / 65535.0;
+
+        case Uint8Array:
+
+            return value / 255.0;
+
+        case Int32Array:
+
+            return Math.max( value / 2147483647.0, - 1.0 );
+
+        case Int16Array:
+
+            return Math.max( value / 32767.0, - 1.0 );
+
+        case Int8Array:
+
+            return Math.max( value / 127.0, - 1.0 );
+
+        default:
+
+            throw new Error( 'Invalid component type.' );
+
+    }
+
+}

package/src/core/collection/array/typed/typed_array_value_normalize.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Normalizes the given value according to the given typed array.
+ *
+ * @param {number} value - The float value in the range `[0,1]` to normalize.
+ * @param {TypedArray} array - The typed array that defines the data type of the value.
+ * @return {number} The normalize value.
+ */
+export function typed_array_value_normalize(value: number, array: TypedArray): number;
+//# sourceMappingURL=typed_array_value_normalize.d.ts.map

package/src/core/collection/array/typed/typed_array_value_normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed_array_value_normalize.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/typed_array_value_normalize.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,mDAJW,MAAM,sBAEL,MAAM,CAyCjB"}

package/src/core/collection/array/typed/typed_array_value_normalize.js

@@ -0,0 +1,47 @@
+/**
+ * Normalizes the given value according to the given typed array.
+ *
+ * @param {number} value - The float value in the range `[0,1]` to normalize.
+ * @param {TypedArray} array - The typed array that defines the data type of the value.
+ * @return {number} The normalize value.
+ */
+export function typed_array_value_normalize(value, array) {
+    // taken from https://github.com/mrdoob/three.js/blob/da275a4e00536723155b68518944de5eb7945550/src/math/MathUtils.js#L435
+
+    switch (array.constructor) {
+
+        case Float32Array:
+
+            return value;
+
+        case Uint32Array:
+
+            return Math.round(value * 4294967295.0);
+
+        case Uint16Array:
+
+            return Math.round(value * 65535.0);
+
+        case Uint8Array:
+
+            return Math.round(value * 255.0);
+
+        case Int32Array:
+
+            return Math.round(value * 2147483647.0);
+
+        case Int16Array:
+
+            return Math.round(value * 32767.0);
+
+        case Int8Array:
+
+            return Math.round(value * 127.0);
+
+        default:
+
+            throw new Error('Invalid component type.');
+
+    }
+
+}

package/src/core/geom/3d/ray/Ray3.d.ts

@@ -105,5 +105,11 @@ export class Ray3 extends Float32Array {
      * @returns {number}
      */
     computeSignedDistance(x: number, y: number, z: number): number;
+    /**
+     * Useful for type checking
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isRay3: boolean;
 }
 //# sourceMappingURL=Ray3.d.ts.map

package/src/core/geom/3d/ray/Ray3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/Ray3.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IAkOI;;;;;;;;;;OAUG;IACH,sBATW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,UACN,MAAM,GACL,IAAI,CAqBf;IA/PD,cAKC;IAMD,mBAEC;IAND,gBAEC;IAGG,OAAW;IAOf;;;OAGG;IACH,yCAEC;IAVD,sCAEC;IAUD,uBAEC;IAED,uBAEC;IAED,uBAEC;IAGD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAQf;;;OAGG;IACH,4CAEC;IAVD,yCAEC;IAWD,0BAEC;IAED,0BAEC;IAED,0BAEC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAGf,2BAEC;IAED;;;;;;;OAOG;IACH,gCANW,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,OAAK,sBAC1B,MAAM,EAAE,GAAC,YAAY,OAAK,QA6BpC;IAED;;;OAGG;IACH,uBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,iBAFW,MAAM,EAAE,UAAM,YAAY,QAepC;IAED;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAInB;IAED;;;;;;;;;OASG;IACH,yBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAclB;CAiCJ"}
+{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/Ray3.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IAkOI;;;;;;;;;;OAUG;IACH,sBATW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,UACN,MAAM,GACL,IAAI,CAqBf;IA/PD,cAKC;IAMD,mBAEC;IAND,gBAEC;IAGG,OAAW;IAOf;;;OAGG;IACH,yCAEC;IAVD,sCAEC;IAUD,uBAEC;IAED,uBAEC;IAED,uBAEC;IAGD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAQf;;;OAGG;IACH,4CAEC;IAVD,yCAEC;IAWD,0BAEC;IAED,0BAEC;IAED,0BAEC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAGf,2BAEC;IAED;;;;;;;OAOG;IACH,gCANW,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,OAAK,sBAC1B,MAAM,EAAE,GAAC,YAAY,OAAK,QA6BpC;IAED;;;OAGG;IACH,uBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,iBAFW,MAAM,EAAE,UAAM,YAAY,QAepC;IAED;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAInB;IAED;;;;;;;;;OASG;IACH,yBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAclB;IAmCL;;;;OAIG;IACH,iBAFU,OAAO,CAEI;CAPpB"}

package/src/core/geom/3d/ray/Ray3.js

@@ -269,4 +269,11 @@ export class Ray3 extends Float32Array {
 
         return ray;
     }
-}
+}
+
+/**
+ * Useful for type checking
+ * @readonly
+ * @type {boolean}
+ */
+Ray3.prototype.isRay3 = true;

package/src/engine/ecs/terrain/tiles/TerrainTile.js

@@ -191,12 +191,12 @@ class TerrainTile {
         const geometry = this.geometry;
 
         const geometryIndices = geometry.getIndex().array;
-        const geometryPositions = geometry.getAttribute('position').array;
+        const attribute_position = geometry.getAttribute('position');
+        const position_array = attribute_position.array;
 
         let hit_found = bvh32_geometry_raycast(
-            result,
-            this.bvh,
-            geometryPositions, 0, 3,
+            result, this.bvh, position_array, 0, 3,
+            attribute_position.normalized,
             geometryIndices,
             _originX, _originY, _originZ,
             _directionX, _directionY, _directionZ

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

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {THREE.BufferAttribute} attribute
+ * @returns {THREE.BufferAttribute} returns denormalized attribute, if input is already denormalized returns input
+ */
+export function buffer_attribute_denormalize(attribute: THREE.BufferAttribute): THREE.BufferAttribute;
+import { BufferAttribute } from "three";
+//# sourceMappingURL=buffer_attribute_denormalize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_attribute_denormalize.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/buffer_attribute_denormalize.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wDAHW,qBAAqB,GACnB,qBAAqB,CA2DjC;gCAjE+B,OAAO"}

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

@@ -0,0 +1,66 @@
+import { BufferAttribute } from "three";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {THREE.BufferAttribute} attribute
+ * @returns {THREE.BufferAttribute} returns denormalized attribute, if input is already denormalized returns input
+ */
+export function buffer_attribute_denormalize(attribute) {
+    assert.notEqual(attribute.isInterleavedBufferAttribute, true, 'attribute must not be interleaved');
+
+    if (attribute.normalized) {
+        // already denormalized
+        return attribute;
+    }
+
+    const raw_data = attribute.array;
+    const input_array_type = raw_data.constructor;
+
+    if (input_array_type === Float32Array) {
+        // special case
+        return new BufferAttribute(raw_data, attribute.itemSize, false);
+    }
+
+    const value_count = attribute.count * attribute.itemSize;
+    const denormalized = new Float32Array(value_count);
+
+    // denormalization inlined for speed
+    switch (input_array_type) {
+        case Uint32Array:
+            for (let i = 0; i < value_count; i++) {
+                denormalized[i] = raw_data[i] / 0xffffffff;
+            }
+            break;
+        case Uint16Array:
+            for (let i = 0; i < value_count; i++) {
+                denormalized[i] = raw_data[i] / 0xffff;
+            }
+            break;
+        case Uint8Array:
+            for (let i = 0; i < value_count; i++) {
+                denormalized[i] = raw_data[i] / 0xff;
+            }
+            break;
+        case Int32Array:
+            for (let i = 0; i < value_count; i++) {
+                denormalized[i] = Math.max(raw_data[i] / 0x7fffffff, -1);
+            }
+            break;
+        case Int16Array:
+            for (let i = 0; i < value_count; i++) {
+                denormalized[i] = Math.max(raw_data[i] / 0x7fff, -1);
+            }
+            break;
+        case Int8Array:
+            for (let i = 0; i < value_count; i++) {
+                denormalized[i] = Math.max(raw_data[i] / 0x7f, -1);
+            }
+            break;
+        default:
+            throw new Error(`Unsupported data type ${input_array_type}`);
+    }
+
+    return new BufferAttribute(denormalized, attribute.itemSize, false);
+
+}

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":"AAgBA;IACI,iCAyBC;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,CAwDlB;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,oBAoBC;CAEJ;;kBAIS,+BAA+B;;gCAlRT,sDAAsD"}
+{"version":3,"file":"GeometrySpatialQueryAccelerator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js"],"names":[],"mappings":"AAiBA;IACI,iCAyBC;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,CA8ClB;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,oBAwBC;CAEJ;;kBAIS,+BAA+B;;gCA7QT,sDAAsD"}

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -4,6 +4,7 @@ import { Cache } from "../../../../../core/cache/Cache.js";
 import { read_three_planes_to_array } from "../../../../../core/geom/3d/frustum/read_three_planes_to_array.js";
 import { bvh32_from_indexed_geometry } from "../../bvh/buffered/bvh32_from_indexed_geometry.js";
 import { bvh32_from_unindexed_geometry } from "../../bvh/buffered/bvh32_from_unindexed_geometry.js";
+import { buffer_attribute_denormalize } from "../buffer_attribute_denormalize.js";
 import { deinterleaveBufferAttribute } from "../deinterleaveBufferAttribute.js";
 import { bvh32_geometry_overlap_clipping_volume } from "./bvh32_geometry_overlap_clipping_volume.js";
 import { bvh32_geometry_raycast } from "./bvh32_geometry_raycast.js";
@@ -97,7 +98,7 @@ export class GeometrySpatialQueryAccelerator {
 
         return bvh32_geometry_overlap_clipping_volume(
             bvh,
-            position_data, position_data_offset, stride,
+            position_data, position_data_offset, stride, position_attribute.normalized,
             geometryIndices,
             scratch_planes, 0, planes.length
         );
@@ -173,17 +174,7 @@ export class GeometrySpatialQueryAccelerator {
 
         }
 
-        return bvh32_geometry_raycast(
-            destination, bvh,
-            position_data, position_data_offset, stride,
-            geometryIndices,
-            ray_origin_x,
-            ray_origin_y,
-            ray_origin_z,
-            ray_direction_x,
-            ray_direction_y,
-            ray_direction_z
-        );
+        return bvh32_geometry_raycast(destination, bvh, position_data, position_data_offset, stride, position_attribute.normalized, geometryIndices, ray_origin_x, ray_origin_y, ray_origin_z, ray_direction_x, ray_direction_y, ray_direction_z);
 
     }
 
@@ -254,10 +245,14 @@ export class GeometrySpatialQueryAccelerator {
         const index_attribute = geometry.getIndex();
 
         const de_interleaved_position_attribute = deinterleaveBufferAttribute(position_attribute);
-        const vertices = de_interleaved_position_attribute.array;
+        const de_normalized_position_attribute = buffer_attribute_denormalize(de_interleaved_position_attribute);
+
+        const vertices = de_normalized_position_attribute.array;
 
         if (index_attribute === undefined || index_attribute === null) {
+
             bvh32_from_unindexed_geometry(bvh, vertices);
+
         } else {
 
             const de_interleaved_index_attribute = deinterleaveBufferAttribute(index_attribute);

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

@@ -4,11 +4,12 @@
  * @param {number[]|ArrayLike<number>} vertices
  * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
  * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {boolean} vertex_data_normalized do we need to denormalize vertex data?
  * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
  * @param {number[]|Float32Array} planes
  * @param {number} planes_offset
  * @param {number} plane_count
  * @returns {boolean}
  */
-export function bvh32_geometry_overlap_clipping_volume(bvh: BinaryUint32BVH, vertices: number[] | ArrayLike<number>, vertex_offset: number, vertex_stride: number, indices: number[] | ArrayLike<number> | undefined, planes: number[] | Float32Array, planes_offset: number, plane_count: number): boolean;
+export function bvh32_geometry_overlap_clipping_volume(bvh: BinaryUint32BVH, vertices: number[] | ArrayLike<number>, vertex_offset: number, vertex_stride: number, vertex_data_normalized: boolean, indices: number[] | ArrayLike<number> | undefined, planes: number[] | Float32Array, planes_offset: number, plane_count: number): boolean;
 //# sourceMappingURL=bvh32_geometry_overlap_clipping_volume.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bvh32_geometry_overlap_clipping_volume.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;GAWG;AACH,uFATW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,WACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,UACpC,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,GACJ,OAAO,CAmEnB"}
+{"version":3,"file":"bvh32_geometry_overlap_clipping_volume.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH,uFAVW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,UACpC,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,GACJ,OAAO,CAmFnB"}

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.js

@@ -2,6 +2,9 @@ import { assert } from "../../../../../core/assert.js";
 import {
     bvh32_query_user_data_overlaps_clipping_volume
 } from "../../../../../core/bvh2/binary/2/bvh32_query_user_data_overlaps_clipping_volume.js";
+import {
+    typed_array_value_denormalize
+} from "../../../../../core/collection/array/typed/typed_array_value_denormalize.js";
 import {
     triangle_intersects_clipping_volume
 } from "../../../../../core/geom/3d/triangle/triangle_intersects_clipping_volume.js";
@@ -14,6 +17,7 @@ const scratch_array = []
  * @param {number[]|ArrayLike<number>} vertices
  * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
  * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {boolean} vertex_data_normalized do we need to denormalize vertex data?
  * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
  * @param {number[]|Float32Array} planes
  * @param {number} planes_offset
@@ -23,6 +27,7 @@ const scratch_array = []
 export function bvh32_geometry_overlap_clipping_volume(
     bvh,
     vertices, vertex_offset, vertex_stride,
+    vertex_data_normalized,
     indices,
     planes, planes_offset, plane_count
 ) {
@@ -61,17 +66,32 @@ export function bvh32_geometry_overlap_clipping_volume(
         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];
+        let ax = vertices[a_address];
+        let ay = vertices[a_address + 1];
+        let az = vertices[a_address + 2];
+
+        let bx = vertices[b_address];
+        let by = vertices[b_address + 1];
+        let bz = vertices[b_address + 2];
+
+        let cx = vertices[c_address];
+        let cy = vertices[c_address + 1];
+        let cz = vertices[c_address + 2];
 
-        const bx = vertices[b_address];
-        const by = vertices[b_address + 1];
-        const bz = vertices[b_address + 2];
+        // denormalize if necessary
+        if(vertex_data_normalized) {
+            ax = typed_array_value_denormalize(ax, vertices);
+            ay = typed_array_value_denormalize(ay, vertices);
+            az = typed_array_value_denormalize(az, vertices);
 
-        const cx = vertices[c_address];
-        const cy = vertices[c_address + 1];
-        const cz = vertices[c_address + 2];
+            bx = typed_array_value_denormalize(bx, vertices);
+            by = typed_array_value_denormalize(by, vertices);
+            bz = typed_array_value_denormalize(bz, vertices);
+
+            cx = typed_array_value_denormalize(cx, vertices);
+            cy = typed_array_value_denormalize(cy, vertices);
+            cz = typed_array_value_denormalize(cz, vertices);
+        }
 
         if (triangle_intersects_clipping_volume(
             planes, planes_offset, plane_count,

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

@@ -5,6 +5,7 @@
  * @param {number[]|ArrayLike<number>} vertices
  * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
  * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {boolean} vertex_data_normalized do we need to denormalize vertex data?
  * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
  * @param {number} originX
  * @param {number} originY
@@ -14,6 +15,6 @@
  * @param {number} directionZ
  * @returns {boolean}
  */
-export function bvh32_geometry_raycast(result: SurfacePoint3, bvh: BinaryUint32BVH, vertices: number[] | ArrayLike<number>, vertex_offset: number, vertex_stride: number, indices: number[] | ArrayLike<number> | undefined, originX: number, originY: number, originZ: number, directionX: number, directionY: number, directionZ: number): boolean;
+export function bvh32_geometry_raycast(result: SurfacePoint3, bvh: BinaryUint32BVH, vertices: number[] | ArrayLike<number>, vertex_offset: number, vertex_stride: number, vertex_data_normalized: boolean, indices: number[] | ArrayLike<number> | undefined, originX: number, originY: number, originZ: number, directionX: number, directionY: number, directionZ: number): boolean;
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 //# sourceMappingURL=bvh32_geometry_raycast.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bvh32_geometry_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,+CAdW,aAAa,kCAEb,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,WACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,WACpC,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,OAAO,CAqFnB;8BAzG6B,8CAA8C"}
+{"version":3,"file":"bvh32_geometry_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;GAgBG;AACH,+CAfW,aAAa,kCAEb,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,WACpC,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,OAAO,CAwGnB;8BA7H6B,8CAA8C"}

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.js

@@ -1,5 +1,8 @@
 import { assert } from "../../../../../core/assert.js";
 import { bvh32_query_user_data_ray } from "../../../../../core/bvh2/binary/2/bvh32_query_user_data_ray.js";
+import {
+    typed_array_value_denormalize
+} from "../../../../../core/collection/array/typed/typed_array_value_denormalize.js";
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import { computeTriangleRayIntersection } from "../../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 
@@ -13,6 +16,7 @@ const scratch_hit = new SurfacePoint3()
  * @param {number[]|ArrayLike<number>} vertices
  * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
  * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {boolean} vertex_data_normalized do we need to denormalize vertex data?
  * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
  * @param {number} originX
  * @param {number} originY
@@ -26,10 +30,14 @@ export function bvh32_geometry_raycast(
     result,
     bvh,
     vertices, vertex_offset, vertex_stride,
+    vertex_data_normalized,
     indices,
     originX, originY, originZ,
     directionX, directionY, directionZ
 ) {
+
+    assert.isBoolean(vertex_data_normalized, 'vertex_data_normalized');
+
     let hit_found = false;
 
     const hit_count = bvh32_query_user_data_ray(
@@ -69,17 +77,32 @@ export function bvh32_geometry_raycast(
         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];
+        let ax = vertices[a_address];
+        let ay = vertices[a_address + 1];
+        let az = vertices[a_address + 2];
+
+        let bx = vertices[b_address];
+        let by = vertices[b_address + 1];
+        let bz = vertices[b_address + 2];
 
-        const bx = vertices[b_address];
-        const by = vertices[b_address + 1];
-        const bz = vertices[b_address + 2];
+        let cx = vertices[c_address];
+        let cy = vertices[c_address + 1];
+        let cz = vertices[c_address + 2];
 
-        const cx = vertices[c_address];
-        const cy = vertices[c_address + 1];
-        const cz = vertices[c_address + 2];
+        // denormalize if necessary
+        if(vertex_data_normalized) {
+            ax = typed_array_value_denormalize(ax, vertices);
+            ay = typed_array_value_denormalize(ay, vertices);
+            az = typed_array_value_denormalize(az, vertices);
+
+            bx = typed_array_value_denormalize(bx, vertices);
+            by = typed_array_value_denormalize(by, vertices);
+            bz = typed_array_value_denormalize(bz, vertices);
+
+            cx = typed_array_value_denormalize(cx, vertices);
+            cy = typed_array_value_denormalize(cy, vertices);
+            cz = typed_array_value_denormalize(cz, vertices);
+        }
 
         const triangle_hit_found = computeTriangleRayIntersection(
             scratch_hit,

package/src/engine/graphics/particles/particular/engine/renderers/billboard/ParticleBillboardMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleBillboardMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/engine/graphics/particles/particular/engine/renderers/billboard/ParticleBillboardMaterial.js"],"names":[],"mappings":"AA8ZA;;;;;;;GAOG;AACH,4DAFW,OAAO,kBA2EjB;+BApeM,OAAO"}
+{"version":3,"file":"ParticleBillboardMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/engine/graphics/particles/particular/engine/renderers/billboard/ParticleBillboardMaterial.js"],"names":[],"mappings":"AA+ZA;;;;;;;GAOG;AACH,4DAFW,OAAO,kBA2EjB;+BAreM,OAAO"}

package/src/engine/graphics/particles/particular/engine/renderers/billboard/ParticleBillboardMaterial.js

@@ -113,6 +113,7 @@ vec3 directLightColor_Diffuse;
 `;
 
 function make_vertex_shader() {
+    //language=GLSL
     return `
                 uniform float cameraNear;
                 uniform float cameraFar;
@@ -191,7 +192,7 @@ function make_vertex_shader() {
                                     
                     #ifdef DEPTH_SOFT_ENABLED
                     
-                        vFadeDistance =  1.0 / radius;
+                        vFadeDistance = 1.0 / radius;
                     
                     #endif