@woosh/meep-engine 2.38.2 → 2.39.1

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

@@ -1,336 +1,38 @@
 import { BufferGeometry, Vector3 } from "three";
 import { GeometryOutput } from "./GeometryOutput.js";
 import { CapType } from "../CapType.js";
-import { max2 } from "../../../../../../core/math/max2.js";
+import { make_ring_vertices } from "./make_ring_vertices.js";
+import { assert } from "../../../../../../core/assert.js";
+import { make_ring_faces } from "./make_ring_faces.js";
+import { compute_cap_geometry_size, make_cap } from "./make_cap.js";
+import { v3_angle_cos_between } from "../../../../../../core/geom/v3_angle_between.js";
 
 
-/**
- *
- * @param {GeometryOutput} out
- * @param {number} Px
- * @param {number} Py
- * @param {number} Pz
- * @param {Vector3} N normal
- * @param {Vector3} B binormal
- * @param {number} u X component of UV
- * @param {number} radius
- * @param {number} angular_step
- * @param {number} radial_segments
- */
-function make_ring_vertices(
-    out,
-    Px, Py, Pz,
-    N, B,
-    u,
-    radius, angular_step, radial_segments
-) {
-    const out_positions = out.positions;
-    const out_normals = out.normals;
-    const out_uvs = out.uvs;
-
-    for (let j = 0; j <= radial_segments; j++) {
-        const angle = j * angular_step;
-
-        const sin = Math.sin(angle);
-        const cos = -Math.cos(angle);
-
-        // normal
-
-        const normal_x_r = (cos * N.x + sin * B.x);
-        const normal_y_r = (cos * N.y + sin * B.y);
-        const normal_z_r = (cos * N.z + sin * B.z);
-
-        const normal_length = 1 / Math.hypot(normal_x_r, normal_y_r, normal_z_r);
-
-        const normal_x = normal_x_r * normal_length;
-        const normal_y = normal_y_r * normal_length;
-        const normal_z = normal_z_r * normal_length;
-
-        const cv = out.cursor_vertices;
-        const cv3 = cv * 3;
-
-        out_normals[cv3] = normal_x;
-        out_normals[cv3 + 1] = normal_y;
-        out_normals[cv3 + 2] = normal_z;
-
-        // position
-
-        const vx = Px + radius * normal_x;
-        const vy = Py + radius * normal_y;
-        const vz = Pz + radius * normal_z;
-
-        out_positions[cv3] = vx;
-        out_positions[cv3 + 1] = vy;
-        out_positions[cv3 + 2] = vz;
-
-        // UV
-        const v = j / radial_segments;
-
-        const cv2 = cv * 2;
-
-        out_uvs[cv2] = u;
-        out_uvs[cv2 + 1] = v;
-
-        out.cursor_vertices++;
-
-    }
-}
-
-/**
- *
- * @param {GeometryOutput} out
- * @param {number} index_offset
- * @param {number} tubular_segments
- * @param {number} radial_segments
- */
-function make_ring_faces(out, index_offset, tubular_segments, radial_segments) {
-    const indices = out.indices;
-
-    let i = 0, j = 0;
-
-    for (j = 1; j <= tubular_segments; j++) {
-
-        for (i = 1; i <= radial_segments; i++) {
-
-            const s_1 = radial_segments + 1;
-
-            const a = index_offset + s_1 * (j - 1) + (i - 1);
-            const b = index_offset + s_1 * j + (i - 1);
-            const c = index_offset + s_1 * j + i;
-            const d = index_offset + s_1 * (j - 1) + i;
-
-            // faces
-
-            const ci = out.cursor_indices;
-
-            indices[ci] = a;
-            indices[ci + 1] = b;
-            indices[ci + 2] = d;
-
-            indices[ci + 3] = b;
-            indices[ci + 4] = c;
-            indices[ci + 5] = d;
-
-            out.cursor_indices += 6;
-        }
-
-    }
-}
-
-/**
- *
- * @param {number} radial_segments
- * @returns {number}
- */
-function compute_cap_round_segment_count(radial_segments) {
-    return max2(3, Math.ceil(radial_segments / 4));
-}
-
-/**
- *
- * @param {number} index
- * @param {Float32Array|number[]} in_positions
- * @param {Vector3[]} in_normals
- * @param {Vector3[]} in_binormals
- * @param {GeometryOutput} out
- * @param {number} radius
- * @param {number} radial_segments
- * @param {number} direction
- */
-function make_cap_round(
-    out,
-    index,
-    in_positions, in_normals, in_binormals,
-    radius, radial_segments, direction
-) {
-    // how many radial segments will be placed laterally to make up the cap
-    const cap_segment_count = compute_cap_round_segment_count(radial_segments);
-
-    const i3 = index * 3;
-
-    const Px = in_positions[i3];
-    const Py = in_positions[i3 + 1];
-    const Pz = in_positions[i3 + 2];
-
-    // retrieve corresponding normal and binormal
-
-    const N = in_normals[index];
-    const B = in_binormals[index];
-
-    const tangent = new Vector3();
-    tangent.crossVectors(N, B);
-    tangent.normalize();
-
-    const normal = direction > 0 ? N : N.clone().negate();
-
-    const angular_step_i = (Math.PI / 2) / cap_segment_count;
-    const angular_step_j = (Math.PI * 2) / radial_segments;
-
-    const uv_u = index / (in_positions.length / 3 - 1);
-    let i, j;
-
-    const index_offset = out.cursor_vertices;
-
-    for (i = 0; i <= cap_segment_count; i++) {
-        const angle_b = i * angular_step_i;
-
-        const sin_b = Math.sin(angle_b);
-        const cos_b = Math.cos(angle_b);
-
-        const cap_ring_radius = sin_b * radius;
-
-        const _d = -radius * direction;
-
-        const _px = Px + tangent.x * cos_b * _d;
-        const _py = Py + tangent.y * cos_b * _d;
-        const _pz = Pz + tangent.z * cos_b * _d;
-
-        make_ring_vertices(
-            out,
-            _px, _py, _pz,
-            normal, B, uv_u,
-            cap_ring_radius, angular_step_j, radial_segments
-        );
-    }
-
-    make_ring_faces(out, index_offset, cap_segment_count, radial_segments);
-}
-
-/**
- *
- * @param {number} index
- * @param {Float32Array|number[]} in_positions
- * @param {Vector3[]} in_normals
- * @param {Vector3[]} in_binormals
- * @param {GeometryOutput} out
- * @param {number} radius
- * @param {number} radial_segments
- * @param {number} direction
- */
-function make_cap_flat(
-    out,
-    index,
-    in_positions, in_normals, in_binormals,
-    radius, radial_segments, direction
-) {
-    // how many radial segments will be placed laterally to make up the cap
-    const i3 = index * 3;
-
-    const Px = in_positions[i3];
-    const Py = in_positions[i3 + 1];
-    const Pz = in_positions[i3 + 2];
-
-    // retrieve corresponding normal and binormal
-
-    const N = in_normals[index];
-    const B = in_binormals[index];
-
-    const tangent = new Vector3();
-    tangent.crossVectors(N, B);
-    tangent.normalize();
-
-    const normal = direction > 0 ? N.clone().negate() : N;
-
-    const angular_step_j = (Math.PI * 2) / radial_segments;
-
-    const uv_u = index / (in_positions.length / 3 - 1);
-
-    const index_offset = out.cursor_vertices;
-
-    make_ring_vertices(
-        out,
-        Px, Py, Pz,
-        normal, B, uv_u,
-        radius, angular_step_j, radial_segments
-    );
-
-    make_ring_vertices(
-        out,
-        Px, Py, Pz,
-        normal, B, uv_u,
-        0, angular_step_j, radial_segments
-    );
-
-    make_ring_faces(out, index_offset, 1, radial_segments);
-}
-
-/**
- *
- * @param {number} index
- * @param {Float32Array|number[]} in_positions
- * @param {Vector3[]} in_normals
- * @param {Vector3[]} in_binormals
- * @param {GeometryOutput} out
- * @param {number} radius
- * @param {number} radial_segments
- * @param {number} direction
- * @param {CapType} type
- */
-function make_cap(
-    out,
-    index,
-    in_positions, in_normals, in_binormals,
-    radius, radial_segments, direction, type
-) {
-    if (type === CapType.None) {
-        // do nothing
-    } else if (type === CapType.Round) {
-        make_cap_round(
-            out,
-            index,
-            in_positions, in_normals, in_binormals,
-            radius, radial_segments,
-            direction
-        );
-    } else if (type === CapType.Flat) {
-        make_cap_flat(
-            out,
-            index,
-            in_positions, in_normals, in_binormals,
-            radius, radial_segments,
-            direction
-        );
-    } else {
-        throw new Error(`Unsupported cap type '${type}'`);
-    }
-}
-
-/**
- *
- * @param {number} count how many caps
- * @param {{polygon_count:number, vertex_count:number}} out
- * @param {number} radial_segments
- * @param {CapType} type
- */
-function compute_cap_geometry_size(count, out, radial_segments, type) {
-
-    if (type === CapType.None) {
-        // do nothing
-    } else if (type === CapType.Round) {
-        const cap_segment_count = compute_cap_round_segment_count(radial_segments);
-
-        out.vertex_count += count * (cap_segment_count + 1) * (radial_segments + 1);
-        out.polygon_count += count * cap_segment_count * (radial_segments) * 2;
-    } else if (type === CapType.Flat) {
-        out.vertex_count += count * (2) * (radial_segments + 1);
-        out.polygon_count += count * (radial_segments) * 2;
-    } else {
-        throw new Error(`Unsupported cap type '${type}'`);
-    }
-}
+const v4_array = new Float32Array(4);
 
 /**
  * @see https://github.com/mrdoob/three.js/blob/master/src/geometries/TubeGeometry.js
  * @param {Float32Array|number[]} in_positions
  * @param {Vector3[]} in_normals
  * @param {Vector3[]} in_binormals
- * @param {number} radius
- * @param {number} radial_segments
+ * @param {Vector3[]} in_tangents
+ * @param {number[]} shape
+ * @param {number[]|Float32Array} shape_normal
+ * @param {number} shape_length
+ * @param {number[]|Float32Array} shape_transform
  * @param {boolean} [closed]
  * @param {CapType} [cap_type]
  * @returns {BufferGeometry}
  */
-export function makeTubeGeometry(in_positions, in_normals, in_binormals, radius, radial_segments, closed = false, cap_type = CapType.Round) {
+export function makeTubeGeometry(
+    in_positions, in_normals, in_binormals, in_tangents,
+    shape, shape_normal, shape_length, shape_transform, closed = false, cap_type = CapType.Round
+) {
+    assert.enum(cap_type, CapType, 'cap_type');
+    assert.isBoolean(closed, 'closed');
+
+    assert.isNumber(shape_length, 'shape_length');
+    assert.isArrayLike(shape, 'shape');
 
     const out = new GeometryOutput();
 
@@ -341,12 +43,12 @@ export function makeTubeGeometry(in_positions, in_normals, in_binormals, radius,
 
 
     const geometry_size = {
-        vertex_count: (tubular_segments + 1) * (radial_segments + 1),
-        polygon_count: tubular_segments * radial_segments * 2
+        vertex_count: (tubular_segments + 1) * (shape_length + 1),
+        polygon_count: tubular_segments * shape_length * 2
     };
 
     if (!closed) {
-        compute_cap_geometry_size(2, geometry_size, radial_segments, cap_type);
+        compute_cap_geometry_size(2, geometry_size, shape_length, cap_type);
     }
 
     out.allocate(
@@ -357,39 +59,44 @@ export function makeTubeGeometry(in_positions, in_normals, in_binormals, radius,
     // create buffer data
     if (!closed) {
         // start cap
-        make_cap(out, 0, in_positions, in_normals, in_binormals, radius, radial_segments, 1, cap_type);
-    }
-
-    generateBufferData();
-
-    if (!closed) {
-        // end cap
-        make_cap(out, point_count - 1, in_positions, in_normals, in_binormals, radius, radial_segments, -1, cap_type);
+        make_cap(
+            out, 0,
+            in_positions, in_normals, in_binormals, in_tangents,
+            shape, shape_normal, shape_length, shape_transform, 1, cap_type
+        );
     }
 
-    // functions
-
-    function generateBufferData() {
-        const index_offset = out.cursor_vertices;
+    const index_offset = out.cursor_vertices;
 
-        for (let i = 0; i < tubular_segments; i++) {
+    for (let i = 0; i < tubular_segments; i++) {
 
-            generateSegment(i);
+        generateSegment(i);
 
-        }
+    }
 
-        // if the geometry is not closed, generate the last row of vertices and normals
-        // at the regular position on the given path
-        //
-        // if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)
+    // if the geometry is not closed, generate the last row of vertices and normals
+    // at the regular position on the given path
+    //
+    // if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)
 
-        generateSegment((closed === false) ? tubular_segments : 0);
+    generateSegment((closed === false) ? tubular_segments : 0);
 
-        // finally create faces
-        make_ring_faces(out, index_offset, tubular_segments, radial_segments);
+    // finally create faces
+    make_ring_faces(out, index_offset, tubular_segments, shape_length);
 
+    if (!closed) {
+        // end cap
+        make_cap(
+            out, point_count - 1,
+            in_positions, in_normals, in_binormals, in_tangents,
+            shape, shape_normal, shape_length, shape_transform, -1, cap_type
+        );
     }
 
+    /**
+     *
+     * @param {number} i
+     */
     function generateSegment(i) {
 
         // we use getPointAt to sample evenly distributed points from the given path
@@ -406,14 +113,14 @@ export function makeTubeGeometry(in_positions, in_normals, in_binormals, radius,
         const B = in_binormals[i];
 
         // generate normals and vertices for the current segment
-
-        const angular_step = (Math.PI * 2) / radial_segments;
+        compute_bend_normal(v4_array, i, tubular_segments, in_positions);
 
         make_ring_vertices(
             out,
             Px, Py, Pz,
-            N, B, i / tubular_segments,
-            radius, angular_step, radial_segments
+            N, B, in_tangents[i],
+            i / tubular_segments, v4_array,
+            shape, shape_normal, shape_length, shape_transform
         );
 
     }
@@ -421,3 +128,72 @@ export function makeTubeGeometry(in_positions, in_normals, in_binormals, radius,
 
     return out.build();
 }
+
+
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} index
+ * @param {number} index_count
+ * @param {number[]|Float32Array} positions
+ */
+function compute_bend_normal(
+    out,
+    index,
+    index_count,
+    positions
+) {
+    if (index <= 0 || index >= index_count - 1) {
+        // end points, no bending
+
+        out[0] = 0;
+        out[1] = 1;
+        out[2] = 0;
+        out[3] = 0;
+
+        return;
+    }
+
+    const index_next = index + 1;
+    const index_prev = index - 1;
+
+    const address_current = index * 3;
+    const address_next = index_next * 3;
+    const address_prev = index_prev * 3;
+
+    const i0_x = positions[address_prev];
+    const i0_y = positions[address_prev + 1];
+    const i0_z = positions[address_prev + 2];
+
+    const i1_x = positions[address_current];
+    const i1_y = positions[address_current + 1];
+    const i1_z = positions[address_current + 2];
+
+    const i2_x = positions[address_next];
+    const i2_y = positions[address_next + 1];
+    const i2_z = positions[address_next + 2];
+
+    const d0_x = i0_x - i1_x;
+    const d0_y = i0_y - i1_y;
+    const d0_z = i0_z - i1_z;
+
+    const d1_x = i1_x - i2_x;
+    const d1_y = i1_y - i2_y;
+    const d1_z = i1_z - i2_z;
+
+    // compute rotation axis
+    const cross_x = d0_y * d1_z - d0_z * d1_y;
+    const cross_y = d0_z * d1_x - d0_x * d1_z;
+    const cross_z = d0_x * d1_y - d0_y * d1_x;
+
+    const angle = v3_angle_cos_between(d0_x, d0_y, d0_z, d1_x, d1_y, d1_z);
+
+    const length_inv = 1 / Math.hypot(cross_x, cross_y, cross_z);
+
+    out[0] = cross_x * length_inv;
+    out[1] = cross_y * length_inv;
+    out[2] = cross_z * length_inv;
+
+    // bend amount
+    out[3] = (1 - Math.abs(angle)) * 0.5;
+}