@woosh/meep-engine 2.169.1 → 2.169.3

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

@@ -2,13 +2,17 @@ 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 { tri3_intersects_clipping_volume } from "../../../../../core/geom/3d/triangle/tri3_intersects_clipping_volume.js";
+import { read_triangle_vertices } from "../read_triangle_vertices.js";
 
 const scratch_array = []
 
+/**
+ * `ax, ay, az, bx, by, bz, cx, cy, cz` of the triangle currently being tested
+ * @type {Float64Array}
+ */
+const triangle_scratch = new Float64Array(9);
+
 /**
  *
  * @param {BinaryUint32BVH} bvh
@@ -40,66 +44,22 @@ export function bvh32_geometry_overlap_clipping_volume(
         planes, planes_offset, plane_count
     );
 
-    let a, b, c;
-
     for (let i = 0; i < hit_count; i++) {
         const triangle_index = scratch_array[i];
 
-        const index3 = triangle_index * 3;
-
-        if (indices !== undefined) {
-            assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
-
-            a = indices[index3];
-            b = indices[index3 + 1];
-            c = indices[index3 + 2];
-        } else {
-            // implicit indices
-            a = index3;
-            b = index3 + 1;
-            c = index3 + 2;
-        }
-
-        const a_address = a * vertex_stride + vertex_offset;
-        const b_address = b * vertex_stride + vertex_offset;
-        const c_address = c * vertex_stride + vertex_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');
-
-        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];
-
-        // 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);
-        }
+        read_triangle_vertices(
+            triangle_scratch, 0,
+            vertices, vertex_offset, vertex_stride,
+            vertex_data_normalized,
+            indices,
+            triangle_index
+        );
 
         if (tri3_intersects_clipping_volume(
             planes, planes_offset, plane_count,
-            ax, ay, az,
-            bx, by, bz,
-            cx, cy, cz
+            triangle_scratch[0], triangle_scratch[1], triangle_scratch[2],
+            triangle_scratch[3], triangle_scratch[4], triangle_scratch[5],
+            triangle_scratch[6], triangle_scratch[7], triangle_scratch[8]
         )) {
             return true;
         }

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":"AAWA;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAhBW,aAAa,kCAEb,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,YACpC,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,GACJ,OAAO,CA2GnB;8BAjI6B,8CAA8C"}
+{"version":3,"file":"bvh32_geometry_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAhBW,aAAa,kCAEb,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,YACpC,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,GACJ,OAAO,CA+DnB;8BA5F6B,8CAA8C"}

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

@@ -1,14 +1,18 @@
 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 { tri3_ray_intersection } from "../../../../../core/geom/3d/triangle/tri3_ray_intersection.js";
+import { read_triangle_vertices } from "../read_triangle_vertices.js";
 
 const scratch_array = []
 const scratch_hit = new SurfacePoint3()
 
+/**
+ * `ax, ay, az, bx, by, bz, cx, cy, cz` of the triangle currently being tested
+ * @type {Float64Array}
+ */
+const triangle_scratch = new Float64Array(9);
+
 /**
  *
  * @param {SurfacePoint3} result
@@ -53,68 +57,24 @@ export function bvh32_geometry_raycast(
 
     let best_distance_sqr = max_distance * max_distance;
 
-    let a, b, c;
-
     for (let i = 0; i < hit_count; i++) {
         const triangle_index = scratch_array[i];
 
-        const index3 = triangle_index * 3;
-
-        if (indices !== undefined) {
-            assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
-
-            a = indices[index3];
-            b = indices[index3 + 1];
-            c = indices[index3 + 2];
-        } else {
-            // implicit indices
-            a = index3;
-            b = index3 + 1;
-            c = index3 + 2;
-        }
-
-        const a_address = a * vertex_stride + vertex_offset;
-        const b_address = b * vertex_stride + vertex_offset;
-        const c_address = c * vertex_stride + vertex_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');
-
-        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];
-
-        // 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);
-        }
+        read_triangle_vertices(
+            triangle_scratch, 0,
+            vertices, vertex_offset, vertex_stride,
+            vertex_data_normalized,
+            indices,
+            triangle_index
+        );
 
         const triangle_hit_found = tri3_ray_intersection(
             scratch_hit,
             origin_x, origin_y, origin_z,
             direction_x, direction_y, direction_z,
-            ax, ay, az,
-            bx, by, bz,
-            cx, cy, cz
+            triangle_scratch[0], triangle_scratch[1], triangle_scratch[2],
+            triangle_scratch[3], triangle_scratch[4], triangle_scratch[5],
+            triangle_scratch[6], triangle_scratch[7], triangle_scratch[8]
         )
 
         if (!triangle_hit_found) {

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

@@ -0,0 +1,30 @@
+/**
+ * Leaf step of a "nearest point on mesh" BVH query: find the closest point on one triangle to the
+ * reference point and, if it beats the incumbent, record it into {@link result}.
+ *
+ * This is the entire payload of the leaf case, shared by the two nearest-point traversals we have -
+ * {@link bvh32_geometry_nearest} (over the implicitly-indexed {@link BinaryUint32BVH}) and
+ * {@link query_bvh_geometry_nearest} (over the pointer-node {@link BVH}). The traversals genuinely
+ * differ because the tree layouts differ; the leaf work does not, and used to be a token-identical
+ * copy in both files.
+ *
+ * @param {SurfacePoint3} result written to only when this triangle is closer than {@link best_distance_sqr}
+ * @param {number} triangle_index recorded into `result.index` on improvement
+ * @param {number} best_distance_sqr squared distance of the incumbent nearest point
+ * @param {number} x reference point X
+ * @param {number} y reference point Y
+ * @param {number} z reference point Z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {number} squared distance to the new nearest point, or {@link best_distance_sqr}
+ * unchanged when this triangle is not an improvement
+ */
+export function nearest_point_on_triangle_record(result: SurfacePoint3, triangle_index: number, best_distance_sqr: number, x: number, y: number, z: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): number;
+//# sourceMappingURL=nearest_point_on_triangle_record.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nearest_point_on_triangle_record.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/nearest_point_on_triangle_record.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wFAjBW,MAAM,qBACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAmDlB"}

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

@@ -0,0 +1,87 @@
+import { tri3_closest_point_barycentric } from "../../../../../core/geom/3d/triangle/tri3_closest_point_barycentric.js";
+import { tri3_compute_normal } from "../../../../../core/geom/3d/triangle/tri3_compute_normal.js";
+import { v3_distance_sqr } from "../../../../../core/geom/vec3/v3_distance_sqr.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const v3_scratch_0 = [];
+
+/**
+ * Leaf step of a "nearest point on mesh" BVH query: find the closest point on one triangle to the
+ * reference point and, if it beats the incumbent, record it into {@link result}.
+ *
+ * This is the entire payload of the leaf case, shared by the two nearest-point traversals we have -
+ * {@link bvh32_geometry_nearest} (over the implicitly-indexed {@link BinaryUint32BVH}) and
+ * {@link query_bvh_geometry_nearest} (over the pointer-node {@link BVH}). The traversals genuinely
+ * differ because the tree layouts differ; the leaf work does not, and used to be a token-identical
+ * copy in both files.
+ *
+ * @param {SurfacePoint3} result written to only when this triangle is closer than {@link best_distance_sqr}
+ * @param {number} triangle_index recorded into `result.index` on improvement
+ * @param {number} best_distance_sqr squared distance of the incumbent nearest point
+ * @param {number} x reference point X
+ * @param {number} y reference point Y
+ * @param {number} z reference point Z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {number} squared distance to the new nearest point, or {@link best_distance_sqr}
+ * unchanged when this triangle is not an improvement
+ */
+export function nearest_point_on_triangle_record(
+    result,
+    triangle_index,
+    best_distance_sqr,
+    x, y, z,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+
+    tri3_closest_point_barycentric(
+        v3_scratch_0, 0,
+        x, y, z,
+        ax, ay, az,
+        bx, by, bz,
+        cx, cy, cz
+    );
+
+    const u = v3_scratch_0[0];
+    const v = v3_scratch_0[1];
+    const w = 1 - u - v;
+
+    // construct edge
+
+    const contact_x = ax * u + bx * v + cx * w;
+    const contact_y = ay * u + by * v + cy * w;
+    const contact_z = az * u + bz * v + cz * w;
+
+    const distance_to_triangle_sqr = v3_distance_sqr(
+        contact_x, contact_y, contact_z,
+        x, y, z
+    );
+
+    if (distance_to_triangle_sqr >= best_distance_sqr) {
+        return best_distance_sqr;
+    }
+
+    result.position.set(contact_x, contact_y, contact_z);
+
+    tri3_compute_normal(result.normal, 0,
+        ax, ay, az,
+        bx, by, bz,
+        cx, cy, cz
+    );
+
+    result.index = triangle_index;
+
+    return distance_to_triangle_sqr;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"query_bvh_geometry_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/query_bvh_geometry_nearest.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;GAWG;AACH,uFARW,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,KAChC,MAAM,KACN,MAAM,KACN,MAAM,gBACN,MAAM,GACL,OAAO,CA+KlB"}
+{"version":3,"file":"query_bvh_geometry_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/query_bvh_geometry_nearest.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;GAWG;AACH,uFARW,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,KAChC,MAAM,KACN,MAAM,KACN,MAAM,gBACN,MAAM,GACL,OAAO,CA0IlB"}

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

@@ -9,15 +9,8 @@ import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../core/collection/S
 import {
     aabb3_unsigned_distance_sqr_to_point
 } from "../../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
-import { tri3_closest_point_barycentric } from "../../../../../core/geom/3d/triangle/tri3_closest_point_barycentric.js";
-import { tri3_compute_normal } from "../../../../../core/geom/3d/triangle/tri3_compute_normal.js";
-import { v3_distance_sqr } from "../../../../../core/geom/vec3/v3_distance_sqr.js";
+import { nearest_point_on_triangle_record } from "./nearest_point_on_triangle_record.js";
 
-/**
- *
- * @type {number[]}
- */
-const v3_scratch_0 = [];
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
@@ -149,58 +142,21 @@ export function query_bvh_geometry_nearest(
             const b_address = b * 3;
             const c_address = c * 3;
 
-            const ax = positions[a_address];
-            const ay = positions[a_address + 1];
-            const az = positions[a_address + 2];
-
-            const bx = positions[b_address];
-            const by = positions[b_address + 1];
-            const bz = positions[b_address + 2];
-
-            const cx = positions[c_address];
-            const cy = positions[c_address + 1];
-            const cz = positions[c_address + 2];
-
-            tri3_closest_point_barycentric(
-                v3_scratch_0, 0,
+            const distance_to_triangle_sqr = nearest_point_on_triangle_record(
+                result,
+                triangle_index,
+                nearest_distance_sqr,
                 x, y, z,
-                ax, ay, az,
-                bx, by, bz,
-                cx, cy, cz
+                positions[a_address], positions[a_address + 1], positions[a_address + 2],
+                positions[b_address], positions[b_address + 1], positions[b_address + 2],
+                positions[c_address], positions[c_address + 1], positions[c_address + 2]
             );
 
-            const u = v3_scratch_0[0];
-            const v = v3_scratch_0[1];
-            const w = 1 - u - v;
-
-            // construct edge
+            if (distance_to_triangle_sqr < nearest_distance_sqr) {
+                nearest_distance_sqr = distance_to_triangle_sqr;
 
-            const contact_x = ax * u + bx * v + cx * w;
-            const contact_y = ay * u + by * v + cy * w;
-            const contact_z = az * u + bz * v + cz * w;
-
-            const distance_to_triangle_sqr = v3_distance_sqr(
-                contact_x, contact_y, contact_z,
-                x, y, z
-            );
-
-            if (distance_to_triangle_sqr >= nearest_distance_sqr) {
-                continue;
+                got_a_hit = true;
             }
-
-            nearest_distance_sqr = distance_to_triangle_sqr;
-
-            result.position.set(contact_x, contact_y, contact_z);
-
-            tri3_compute_normal(result.normal, 0,
-                ax, ay, az,
-                bx, by, bz,
-                cx, cy, cz
-            );
-
-            result.index = triangle_index;
-
-            got_a_hit = true;
         }
     } while (pointer > stack_top);
 

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

@@ -0,0 +1,29 @@
+/**
+ * Read the 3 corner positions of a triangle out of a buffered geometry vertex buffer.
+ *
+ * This encodes the entire vertex-buffer contract of buffered geometry in one place:
+ * <ul>
+ *     <li>index resolution, including implicit (non-indexed) geometry</li>
+ *     <li>interleaved buffer addressing via {@link vertex_offset} / {@link vertex_stride}</li>
+ *     <li>de-quantization of normalized (integer-backed) position data</li>
+ * </ul>
+ *
+ * It exists because that contract was previously spelled out character-for-character in every
+ * BVH leaf handler over buffered geometry - {@link bvh32_geometry_nearest},
+ * {@link bvh32_geometry_raycast} and {@link bvh32_geometry_overlap_clipping_volume} each carried
+ * their own copy, so any change to the interleaving or normalization convention had to be made
+ * in three places.
+ *
+ * Output layout, starting at {@link result_offset}: `ax, ay, az, bx, by, bz, cx, cy, cz`
+ *
+ * @param {number[]|Float64Array|Float32Array} result
+ * @param {number} result_offset
+ * @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} triangle_index
+ */
+export function read_triangle_vertices(result: number[] | Float64Array | Float32Array, result_offset: number, vertices: number[] | ArrayLike<number>, vertex_offset: number, vertex_stride: number, vertex_data_normalized: boolean, indices: number[] | ArrayLike<number> | undefined, triangle_index: number): void;
+//# sourceMappingURL=read_triangle_vertices.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"read_triangle_vertices.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/read_triangle_vertices.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,YACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,kBACpC,MAAM,QAyEhB"}

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

@@ -0,0 +1,102 @@
+import { assert } from "../../../../core/assert.js";
+import { typed_array_value_denormalize } from "../../../../core/collection/array/typed/typed_array_value_denormalize.js";
+
+/**
+ * Read the 3 corner positions of a triangle out of a buffered geometry vertex buffer.
+ *
+ * This encodes the entire vertex-buffer contract of buffered geometry in one place:
+ * <ul>
+ *     <li>index resolution, including implicit (non-indexed) geometry</li>
+ *     <li>interleaved buffer addressing via {@link vertex_offset} / {@link vertex_stride}</li>
+ *     <li>de-quantization of normalized (integer-backed) position data</li>
+ * </ul>
+ *
+ * It exists because that contract was previously spelled out character-for-character in every
+ * BVH leaf handler over buffered geometry - {@link bvh32_geometry_nearest},
+ * {@link bvh32_geometry_raycast} and {@link bvh32_geometry_overlap_clipping_volume} each carried
+ * their own copy, so any change to the interleaving or normalization convention had to be made
+ * in three places.
+ *
+ * Output layout, starting at {@link result_offset}: `ax, ay, az, bx, by, bz, cx, cy, cz`
+ *
+ * @param {number[]|Float64Array|Float32Array} result
+ * @param {number} result_offset
+ * @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} triangle_index
+ */
+export function read_triangle_vertices(
+    result, result_offset,
+    vertices, vertex_offset, vertex_stride,
+    vertex_data_normalized,
+    indices,
+    triangle_index
+) {
+
+    const index3 = triangle_index * 3;
+
+    let a, b, c;
+
+    if (indices !== undefined) {
+        assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
+
+        a = indices[index3];
+        b = indices[index3 + 1];
+        c = indices[index3 + 2];
+    } else {
+        // implicit indices
+        a = index3;
+        b = index3 + 1;
+        c = index3 + 2;
+    }
+
+    const a_address = a * vertex_stride + vertex_offset;
+    const b_address = b * vertex_stride + vertex_offset;
+    const c_address = c * vertex_stride + vertex_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');
+
+    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];
+
+    // 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);
+    }
+
+    result[result_offset] = ax;
+    result[result_offset + 1] = ay;
+    result[result_offset + 2] = az;
+
+    result[result_offset + 3] = bx;
+    result[result_offset + 4] = by;
+    result[result_offset + 5] = bz;
+
+    result[result_offset + 6] = cx;
+    result[result_offset + 7] = cy;
+    result[result_offset + 8] = cz;
+}

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImpostorShaderDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.js"],"names":[],"mappings":"AA0WA;;;;GAIG;AACH;IACI,cAoCC;CACJ;kCArZ6D,OAAO"}
+{"version":3,"file":"ImpostorShaderDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.js"],"names":[],"mappings":"AAiQA;;;;GAIG;AACH;IACI,cAoCC;CACJ;kCA5S6D,OAAO"}