@woosh/meep-engine 2.35.16 → 2.36.1

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

@@ -1,161 +1,423 @@
-import { BufferGeometry, Float32BufferAttribute, Vector3 } from "three";
+import { BufferGeometry, Vector3 } from "three";
+import { GeometryOutput } from "./GeometryOutput.js";
+import { CapType } from "../CapType.js";
+import { max2 } from "../../../../../../core/math/max2.js";
+
 
 /**
- * @see https://github.com/mrdoob/three.js/blob/master/src/geometries/TubeGeometry.js
- * @param {Float32Array|number[]} points
- * @param {Vector3[]} _normals
- * @param {Vector3[]} binormals
+ *
+ * @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} radialSegments
- * @param {boolean} [closed]
- * @returns {BufferGeometry}
+ * @param {number} angular_step
+ * @param {number} radial_segments
  */
-export function makeTubeGeometry(points, _normals, binormals, radius, radialSegments, closed = false) {
-    const geometry = new BufferGeometry();
-    // helper variables
+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;
 
-    const vertex = new Vector3();
-    const normal = new Vector3();
+    for (let j = 0; j <= radial_segments; j++) {
+        const angle = j * angular_step;
 
-    // buffer
+        const sin = Math.sin(angle);
+        const cos = -Math.cos(angle);
 
-    const vertices = [];
-    const normals = [];
-    const uvs = [];
-    const indices = [];
+        // normal
 
-    const point_count = points.length / 3;
-    const tubularSegments = point_count - 1;
+        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);
 
-    // create buffer data
+        const normal_length = 1 / Math.hypot(normal_x_r, normal_y_r, normal_z_r);
 
-    generateBufferData();
+        const normal_x = normal_x_r * normal_length;
+        const normal_y = normal_y_r * normal_length;
+        const normal_z = normal_z_r * normal_length;
 
-    // build geometry
+        const cv = out.cursor_vertices;
+        const cv3 = cv * 3;
 
-    geometry.setIndex(indices);
-    geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
-    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
-    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+        out_normals[cv3] = normal_x;
+        out_normals[cv3 + 1] = normal_y;
+        out_normals[cv3 + 2] = normal_z;
 
-    // functions
+        // position
 
-    function generateBufferData() {
+        const vx = Px + radius * normal_x;
+        const vy = Py + radius * normal_y;
+        const vz = Pz + radius * normal_z;
 
-        for (let i = 0; i < tubularSegments; i++) {
+        out_positions[cv3] = vx;
+        out_positions[cv3 + 1] = vy;
+        out_positions[cv3 + 2] = vz;
 
-            generateSegment(i);
+        // 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;
         }
 
-        // 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)
+    }
+}
+
+/**
+ *
+ * @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);
 
-        generateSegment((closed === false) ? tubularSegments : 0);
+    const i3 = index * 3;
 
-        // uvs are generated in a separate function.
-        // this makes it easy compute correct values for closed geometries
+    const Px = in_positions[i3];
+    const Py = in_positions[i3 + 1];
+    const Pz = in_positions[i3 + 2];
 
-        generateUVs();
+    // retrieve corresponding normal and binormal
 
-        // finally create faces
+    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;
 
-        generateIndices();
+    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
+        );
     }
 
-    function generateSegment(i) {
+    make_ring_faces(out, index_offset, cap_segment_count, radial_segments);
+}
 
-        // we use getPointAt to sample evenly distributed points from the given path
+/**
+ *
+ * @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 i3 = i * 3;
+    const Px = in_positions[i3];
+    const Py = in_positions[i3 + 1];
+    const Pz = in_positions[i3 + 2];
 
-        const Px = points[i3];
-        const Py = points[i3 + 1];
-        const Pz = points[i3 + 2];
+    // retrieve corresponding normal and binormal
 
-        // retrieve corresponding normal and binormal
+    const N = in_normals[index];
+    const B = in_binormals[index];
 
-        const N = _normals[i];
-        const B = binormals[i];
+    const tangent = new Vector3();
+    tangent.crossVectors(N, B);
+    tangent.normalize();
 
-        // generate normals and vertices for the current segment
+    const normal = direction > 0 ? N.clone().negate() : N;
+
+    const angular_step_j = (Math.PI * 2) / radial_segments;
 
-        const angular_step = (Math.PI * 2) / radialSegments;
+    const uv_u = index / (in_positions.length / 3 - 1);
 
-        for (let j = 0; j <= radialSegments; j++) {
-            const v = j * angular_step;
+    const index_offset = out.cursor_vertices;
 
-            const sin = Math.sin(v);
-            const cos = -Math.cos(v);
+    make_ring_vertices(
+        out,
+        Px, Py, Pz,
+        normal, B, uv_u,
+        radius, angular_step_j, radial_segments
+    );
 
-            // normal
+    make_ring_vertices(
+        out,
+        Px, Py, Pz,
+        normal, B, uv_u,
+        0, angular_step_j, radial_segments
+    );
 
-            normal.x = (cos * N.x + sin * B.x);
-            normal.y = (cos * N.y + sin * B.y);
-            normal.z = (cos * N.z + sin * B.z);
-            normal.normalize();
+    make_ring_faces(out, index_offset, 1, radial_segments);
+}
 
-            normals.push(normal.x, normal.y, normal.z);
+/**
+ *
+ * @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}'`);
+    }
+}
 
-            // vertex
+/**
+ *
+ * @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}'`);
+    }
+}
 
-            vertex.x = Px + radius * normal.x;
-            vertex.y = Py + radius * normal.y;
-            vertex.z = Pz + radius * normal.z;
+/**
+ * @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 {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) {
 
-            vertices.push(vertex.x, vertex.y, vertex.z);
+    const out = new GeometryOutput();
 
-        }
+    // helper variables
+
+    const point_count = in_positions.length / 3;
+    const tubular_segments = point_count - 1;
+
+
+    const geometry_size = {
+        vertex_count: (tubular_segments + 1) * (radial_segments + 1),
+        polygon_count: tubular_segments * radial_segments * 2
+    };
 
+    if (!closed) {
+        compute_cap_geometry_size(2, geometry_size, radial_segments, cap_type);
     }
 
-    function generateIndices() {
-        let i = 0, j = 0;
+    out.allocate(
+        geometry_size.vertex_count,
+        geometry_size.polygon_count
+    );
 
-        for (j = 1; j <= tubularSegments; j++) {
+    // create buffer data
+    if (!closed) {
+        // start cap
+        make_cap(out, 0, in_positions, in_normals, in_binormals, radius, radial_segments, 1, cap_type);
+    }
 
-            for (i = 1; i <= radialSegments; i++) {
+    generateBufferData();
 
-                const s_1 = radialSegments + 1;
+    if (!closed) {
+        // end cap
+        make_cap(out, point_count - 1, in_positions, in_normals, in_binormals, radius, radial_segments, -1, cap_type);
+    }
 
-                const a = s_1 * (j - 1) + (i - 1);
-                const b = s_1 * j + (i - 1);
-                const c = s_1 * j + i;
-                const d = s_1 * (j - 1) + i;
+    // functions
 
-                // faces
+    function generateBufferData() {
+        const index_offset = out.cursor_vertices;
 
-                indices.push(a, b, d);
-                indices.push(b, c, d);
+        for (let i = 0; i < tubular_segments; 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)
+
+        generateSegment((closed === false) ? tubular_segments : 0);
+
+        // finally create faces
+        make_ring_faces(out, index_offset, tubular_segments, radial_segments);
+
     }
 
-    function generateUVs() {
-        let i = 0, j = 0;
+    function generateSegment(i) {
 
-        for (i = 0; i <= tubularSegments; i++) {
+        // we use getPointAt to sample evenly distributed points from the given path
+
+        const i3 = i * 3;
 
-            const u = i / tubularSegments;
+        const Px = in_positions[i3];
+        const Py = in_positions[i3 + 1];
+        const Pz = in_positions[i3 + 2];
 
-            for (j = 0; j <= radialSegments; j++) {
+        // retrieve corresponding normal and binormal
 
-                const v = j / radialSegments;
+        const N = in_normals[i];
+        const B = in_binormals[i];
 
-                uvs.push(u, v);
+        // generate normals and vertices for the current segment
 
-            }
+        const angular_step = (Math.PI * 2) / radial_segments;
 
-        }
+        make_ring_vertices(
+            out,
+            Px, Py, Pz,
+            N, B, i / tubular_segments,
+            radius, angular_step, radial_segments
+        );
 
     }
 
 
-    return geometry;
+    return out.build();
 }