@woosh/meep-engine 2.34.1 → 2.34.2

package/engine/graphics/geometry/VertexDataSpec.js

@@ -41,6 +41,26 @@ export class VertexDataSpec {
         return undefined;
     }
 
+    /**
+     * @returns {number} -1 if not found
+     * @param {string} name
+     */
+    getAttributeIndexByName(name) {
+
+        const attributes = this.attributes;
+        const n = attributes.length;
+
+        for (let i = 0; i < n; i++) {
+            const attribute = attributes[i];
+
+            if (attribute.name === name) {
+                return i;
+            }
+        }
+
+        return undefined;
+    }
+
     /**
      *
      * @param {AttributeSpec} attribute

package/engine/graphics/micron/format/MicronGeometry.d.ts

@@ -1,9 +1,15 @@
 import {BufferGeometry} from "three";
 import {VertexDataSpec} from "../../geometry/VertexDataSpec";
+import {SurfacePoint3} from "../../../../core/geom/3d/SurfacePoint3";
 
 export class MicronGeometry {
     vertex_spec: VertexDataSpec
     public proxy: BufferGeometry
 
     initialize(): void
+
+    raycast(
+        origin_x: number, origin_y: number, origin_z: number,
+        direction_x: number, direction_y: number, direction_z: number
+    ): SurfacePoint3[]
 }

package/engine/graphics/micron/format/MicronGeometry.js

@@ -1,5 +1,8 @@
 import { VertexDataSpec } from "../../geometry/VertexDataSpec.js";
 import { assert } from "../../../../core/assert.js";
+import { intersectRay } from "../../../../core/bvh2/aabb3/AABB3Math.js";
+import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 
 let id_counter = 0;
 
@@ -55,6 +58,128 @@ export class MicronGeometry {
         this.__proxy = null;
     }
 
+    /**
+     *
+     * @param {number} origin_x
+     * @param {number} origin_y
+     * @param {number} origin_z
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     * @returns {SurfacePoint3[]}
+     */
+    raycast(
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z
+    ) {
+
+        /**
+         *
+         * @type {SurfacePoint3[]}
+         */
+        const hits = [];
+
+        let stack_cursor = 1;
+        const stack = [this.root];
+
+        const spec = this.vertex_spec;
+
+        const position_attribute_index = spec.getAttributeIndexByName('position');
+
+        // check that position attribute actually exists
+        assert.isNonNegativeInteger(position_attribute_index, 'position_attribute_index');
+
+        const temp_hit = new SurfacePoint3();
+
+        while (stack_cursor > 0) {
+            stack_cursor--;
+
+            const patch = stack[stack_cursor];
+
+            // using group bounding box because it's conservative, as we want to be able to hit LOD_0
+            const bb = patch.group_bounding_box;
+
+            const bb_intersection_exists = intersectRay(
+                bb[0], bb[1], bb[2], bb[3], bb[4], bb[5],
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z
+            );
+
+            if (!bb_intersection_exists) {
+                // no intersection
+                continue;
+            }
+
+            if (patch.lod === 0) {
+                // LOD 0 - source geometry
+
+                // raycast against geometry
+                const indices = patch.face_indices;
+                const index_count = indices.length;
+
+                const vertices = patch.vertex_attribute_arrays[position_attribute_index];
+
+                for (let i = 0; i < index_count;) {
+                    const a = indices[i++];
+                    const b = indices[i++];
+                    const c = indices[i++];
+
+
+                    const a_address = a * 3;
+                    const b_address = b * 3;
+                    const c_address = c * 3;
+
+
+                    const ax = vertices[a_address];
+                    const ay = vertices[a_address + 1];
+                    const az = vertices[a_address + 2];
+
+                    const bx = vertices[b_address];
+                    const by = vertices[b_address + 1];
+                    const bz = vertices[b_address + 2];
+
+                    const cx = vertices[c_address];
+                    const cy = vertices[c_address + 1];
+                    const cz = vertices[c_address + 2];
+
+                    if (computeTriangleRayIntersection(
+                        temp_hit,
+                        origin_x, origin_y, origin_z,
+                        direction_x, direction_y, direction_z,
+                        ax, ay, az,
+                        bx, by, bz,
+                        cx, cy, cz
+                    )) {
+
+                        const contact = new SurfacePoint3();
+
+                        contact.copy(temp_hit);
+
+                        hits.push(contact);
+
+                    }
+                }
+
+            } else {
+                // refine more
+                const children = patch.children;
+
+                const child_count = children.length;
+
+                for (let i = 0; i < child_count; i++) {
+                    const child = children[i];
+
+                    // push to stack
+                    stack[stack_cursor] = child;
+
+                    stack_cursor++;
+                }
+            }
+        }
+
+        return hits;
+    }
+
     get patches() {
         return this.__patches;
     }

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.34.1",
+  "version": "2.34.2",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",