@woosh/meep-engine 2.38.2 → 2.39.1

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

@@ -0,0 +1,274 @@
+import { Vector3 } from "three";
+import { max2 } from "../../../../../../core/math/max2.js";
+import { m3_rm_compose_transform } from "../../../../../../view/m3_rm_compose_transform.js";
+import { m3_multiply } from "../../../../../../view/multiplyMatrices3.js";
+import { make_ring_vertices } from "./make_ring_vertices.js";
+import { make_ring_faces } from "./make_ring_faces.js";
+import { v2_distance } from "../../../../../../core/geom/Vector2.js";
+import { CapType } from "../CapType.js";
+
+/**
+ *
+ * @param {number} radial_segments
+ * @returns {number}
+ */
+function compute_cap_round_segment_count(radial_segments) {
+    return max2(3, Math.ceil(radial_segments / 4));
+}
+
+/**
+ *
+ * @param {number[]} shape
+ * @param {number} shape_length
+ * @param {number} cx
+ * @param {number} cy
+ * @returns {number}
+ */
+function compute_shape_radius(shape, shape_length, cx = 0, cy = 0) {
+    let max_distance = 0;
+    for (let i = 0; i < shape_length; i++) {
+        const i2 = i * 2;
+
+        const x = shape[i2];
+        const y = shape[i2 + 1];
+
+        // NOTE: can be optimized by delaying SQRT
+        const distance = v2_distance(x, y, cx, cy);
+
+        if (distance > max_distance) {
+            max_distance = distance;
+        }
+    }
+
+    return max_distance;
+}
+
+/**
+ *
+ * @param {number} index
+ * @param {Float32Array|number[]} in_positions
+ * @param {Vector3[]} in_normals
+ * @param {Vector3[]} in_binormals
+ * @param {Vector3[]} in_tangents
+ * @param {GeometryOutput} out
+ * @param {number[]} shape
+ * @param {number[]|Float32Array} shape_normal
+ * @param {number} shape_length
+ * @param {number[]} shape_transform
+ * @param {number} direction
+ */
+function make_cap_round(
+    out,
+    index,
+    in_positions, in_normals, in_binormals, in_tangents,
+    shape, shape_normal, shape_length, shape_transform, direction
+) {
+    // how many radial segments will be placed laterally to make up the cap
+    const cap_segment_count = compute_cap_round_segment_count(shape_length);
+
+    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 T = in_tangents[index];
+
+    const tangent = new Vector3();
+    tangent.crossVectors(N, B);
+    tangent.normalize();
+    tangent.multiplyScalar(-direction);
+
+    const normal = direction > 0 ? N : N.clone().negate();
+    const binormal = direction > 0 ? B : B.clone().negate();
+
+    const angular_step_i = (Math.PI / 2) / cap_segment_count;
+
+    const uv_u = index / (in_positions.length / 3 - 1);
+
+    let i;
+
+    const index_offset = out.cursor_vertices;
+
+    const m3 = new Float32Array(9);
+
+    const radius_raw = compute_shape_radius(shape, shape_length);
+
+    // extract scale from shape matrix
+    const scale_x = Math.hypot(shape_transform[0], shape_transform[3]);
+    const scale_y = Math.hypot(shape_transform[1], shape_transform[4]);
+
+    const radius = radius_raw * max2(scale_x, scale_y);
+
+    for (i = 0; i <= cap_segment_count; i++) {
+
+        const j = direction>0? i:cap_segment_count-i;
+
+        const angle_b = j * angular_step_i ;
+
+
+        const cos_b = Math.cos(angle_b);
+        const sin_b = Math.sin(angle_b);
+
+        // build shape transform matrix that scales original shape down
+        m3_rm_compose_transform(m3, 0, 0, sin_b, sin_b, 0, 0, 0);
+        m3_multiply(m3, shape_transform, m3);
+
+        const _d = radius;
+
+        // compute offset for ring center
+        const _px = Px + tangent.x * cos_b * _d;
+        const _py = Py + tangent.y * cos_b * _d;
+        const _pz = Pz + tangent.z * cos_b * _d;
+
+        // build ring
+        // TODO normals on produced geometry are incorrect as they need to be bent along the cap
+        make_ring_vertices(
+            out,
+            _px, _py, _pz,
+            normal, binormal, tangent,
+            uv_u, v4_no_bend,
+            shape, shape_normal, shape_length, m3
+        );
+    }
+
+    make_ring_faces(out, index_offset, cap_segment_count, shape_length);
+}
+
+const m3_zero = new Float32Array(9);
+const v4_array = new Float32Array(4);
+
+const v4_no_bend = new Float32Array([0, 1, 0, 0]);
+
+/**
+ *
+ * @param {number} index
+ * @param {Float32Array|number[]} in_positions
+ * @param {Vector3[]} in_normals
+ * @param {Vector3[]} in_binormals
+ * @param {Vector3[]} in_tangents
+ * @param {GeometryOutput} out
+ * @param {number[]} shape
+ * @param {number[]|Float32Array} shape_normals
+ * @param {number} shape_length
+ * @param {number[]} shape_transform
+ * @param {number} direction
+ */
+function make_cap_flat(
+    out,
+    index,
+    in_positions, in_normals, in_binormals, in_tangents,
+    shape, shape_normal, shape_length, shape_transform, 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 uv_u = index / (in_positions.length / 3 - 1);
+
+    const index_offset = out.cursor_vertices;
+
+    make_ring_vertices(
+        out,
+        Px, Py, Pz,
+        normal, B, in_tangents[index],
+        uv_u, v4_no_bend,
+        shape, shape_normal, shape_length, shape_transform
+    );
+
+    make_ring_vertices(
+        out,
+        Px, Py, Pz,
+        normal, B, in_tangents[index],
+        uv_u, v4_no_bend,
+        shape, shape_normal, shape_length, m3_zero
+    );
+
+    make_ring_faces(out, index_offset, 1, shape_length);
+}
+
+/**
+ *
+ * @param {number} index
+ * @param {Float32Array|number[]} in_positions
+ * @param {Vector3[]} in_normals
+ * @param {Vector3[]} in_binormals
+ * @param {GeometryOutput} out
+ * @param {Vector3[]} in_tangents
+ * @param {number[]} shape
+ * @param {number[]|Float32Array} shape_normal
+ * @param {number} shape_length
+ * @param {number[]|Float32Array} shape_transform
+ * @param {number} direction
+ * @param {CapType} type
+ */
+export function make_cap(
+    out,
+    index,
+    in_positions, in_normals, in_binormals, in_tangents,
+    shape, shape_normal, shape_length, shape_transform, direction, type
+) {
+    if (type === CapType.None) {
+        // do nothing
+    } else if (type === CapType.Round) {
+        make_cap_round(
+            out,
+            index,
+            in_positions, in_normals, in_binormals, in_tangents,
+            shape, shape_normal, shape_length, shape_transform,
+            direction
+        );
+    } else if (type === CapType.Flat) {
+        make_cap_flat(
+            out,
+            index,
+            in_positions, in_normals, in_binormals, in_tangents,
+            shape, shape_normal, shape_length, shape_transform,
+            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
+ */
+export 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}'`);
+    }
+}

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

@@ -0,0 +1,40 @@
+/**
+ *
+ * @param {GeometryOutput} out
+ * @param {number} index_offset
+ * @param {number} path_segments
+ * @param {number} profile_segments
+ */
+export function make_ring_faces(out, index_offset, path_segments, profile_segments) {
+    const indices = out.indices;
+
+    let i = 0, j = 0;
+
+    for (j = 1; j <= path_segments; j++) {
+
+        for (i = 1; i <= profile_segments; i++) {
+
+            const s_1 = profile_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;
+        }
+
+    }
+}

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

@@ -0,0 +1,152 @@
+//
+
+import { v3_dot } from "../../../../../../core/geom/v3_dot.js";
+
+/**
+ *
+ * @param {GeometryOutput} out
+ * @param {number} Px
+ * @param {number} Py
+ * @param {number} Pz
+ * @param {Vector3} N normal
+ * @param {Vector3} B binormal
+ * @param {Vector3} T tangent
+ * @param {number} u X component of UV
+ * @param {number[]|Float32Array} bend_angle
+ * @param {number[]|Float32Array} shape 2d shape, format [x0,y1, x1,y1, ... , xN,yN]
+ * @param {number[]|Float32Array} shape_normals
+ * @param {number} shape_length number of points in the shape
+ * @param {number[]|Float32Array} shape_transform 3x3 2d transform matrix for shape Note that matrix uses row-major order
+ */
+export function make_ring_vertices(
+    out,
+    Px, Py, Pz,
+    N, B, T,
+    u, bend_angle,
+    shape, shape_normals, shape_length,
+    shape_transform
+) {
+    const out_positions = out.positions;
+    const out_normals = out.normals;
+    const out_uvs = out.uvs;
+
+    for (let i = 0; i <= shape_length; i++) {
+        const j = i % shape_length;
+        const i2 = j * 2;
+
+        const shape_x = shape[i2];
+        const shape_y = shape[i2 + 1];
+
+        // apply transform to the shape
+        const tx = shape_transform[0] * shape_x + shape_transform[3] * shape_y + shape_transform[6];
+        const ty = shape_transform[1] * shape_x + shape_transform[4] * shape_y + shape_transform[7];
+
+        const b_sin_x = ty * N.x;
+        const b_sin_y = ty * N.y;
+        const b_sin_z = ty * N.z;
+
+        const n_cos_x = tx * B.x;
+        const n_cos_y = tx * B.y;
+        const n_cos_z = tx * B.z;
+
+        // compute radial normal
+        const radial_normal_x_raw = (n_cos_x - b_sin_x);
+        const radial_normal_y_raw = (n_cos_y - b_sin_y);
+        const radial_normal_z_raw = (n_cos_z - b_sin_z);
+
+
+        const radial_normal_magnitude = Math.hypot(radial_normal_x_raw, radial_normal_y_raw, radial_normal_z_raw);
+
+        let normal_x;
+        let normal_y;
+        let normal_z;
+
+        if (radial_normal_magnitude !== 0) {
+
+            const normalization_factor = 1 / radial_normal_magnitude;
+
+            // re-normalize and compensate by bending angle
+            normal_x = radial_normal_x_raw * normalization_factor;
+            normal_y = radial_normal_y_raw * normalization_factor;
+            normal_z = radial_normal_z_raw * normalization_factor;
+
+        } else {
+            // normal would be 0 and produce NaNs, apply arbitrary offset
+            normal_x = T.x;
+            normal_y = T.y;
+            normal_z = T.z;
+        }
+
+        const shape_normal_x = shape_normals[i2];
+        const shape_normal_y = shape_normals[i2 + 1];
+
+        const t_nx = shape_transform[0] * shape_normal_x + shape_transform[3] * shape_normal_y + shape_transform[6];
+        const t_ny = shape_transform[1] * shape_normal_x + shape_transform[4] * shape_normal_y + shape_transform[7];
+
+
+        const nb_sin_x = t_ny * N.x;
+        const nb_sin_y = t_ny * N.y;
+        const nb_sin_z = t_ny * N.z;
+
+        const nn_cos_x = t_nx * B.x;
+        const nn_cos_y = t_nx * B.y;
+        const nn_cos_z = t_nx * B.z;
+
+        const n_normal_x_raw = (-nn_cos_x - nb_sin_x);
+        const n_normal_y_raw = (-nn_cos_y - nb_sin_y);
+        const n_normal_z_raw = (-nn_cos_z - nb_sin_z);
+
+        const n_normal_magnitude = Math.hypot(n_normal_x_raw, n_normal_y_raw, n_normal_z_raw);
+
+        const cv = out.cursor_vertices;
+        const cv3 = cv * 3;
+
+        if(n_normal_magnitude !== 0){
+            out_normals[cv3] = n_normal_x_raw / n_normal_magnitude;
+            out_normals[cv3 + 1] = n_normal_y_raw / n_normal_magnitude;
+            out_normals[cv3 + 2] = n_normal_z_raw / n_normal_magnitude;
+        }else {
+
+            out_normals[cv3] = T.x;
+            out_normals[cv3 + 1] = T.y;
+            out_normals[cv3 + 2] = T.z;
+        }
+
+        let bend_magnitude = 1;
+
+        // rotate bend normal by 90deg
+
+        const cross_x = bend_angle[1] * T.z - bend_angle[2] * T.y;
+        const cross_y = bend_angle[2] * T.x - bend_angle[0] * T.z;
+        const cross_z = bend_angle[0] * T.y - bend_angle[1] * T.x;
+
+        const rotated_bend_normal_length = Math.hypot(cross_x, cross_y, cross_z);
+        const bend_normal_length_inv = 1 / rotated_bend_normal_length;
+
+        // apply bend angle
+        const dot = v3_dot(
+            cross_x * bend_normal_length_inv, cross_y * bend_normal_length_inv, cross_z * bend_normal_length_inv,
+            normal_x, normal_y, normal_z
+        );
+
+        bend_magnitude += Math.abs(dot) * bend_angle[3];
+
+        // compute vertex position
+        const vx = Px + radial_normal_x_raw * bend_magnitude;
+        const vy = Py + radial_normal_y_raw * bend_magnitude;
+        const vz = Pz + radial_normal_z_raw * bend_magnitude;
+
+        out_positions[cv3] = vx;
+        out_positions[cv3 + 1] = vy;
+        out_positions[cv3 + 2] = vz;
+
+        // UV
+        const cv2 = cv * 2;
+
+        out_uvs[cv2] = u;
+        out_uvs[cv2 + 1] = i / shape_length;
+
+        out.cursor_vertices++;
+    }
+
+}

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.38.2",
+  "version": "2.39.1",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",

package/view/View.js

@@ -10,7 +10,7 @@ import Signal from "../core/events/signal/Signal.js";
 import { SignalBinding } from "../core/events/signal/SignalBinding.js";
 import { assert } from "../core/assert.js";
 import Vector1 from "../core/geom/Vector1.js";
-import { compose3x3transform } from "./compose3x3transform.js";
+import { m3_cm_compose_transform } from "./m3_cm_compose_transform.js";
 
 
 const scratch_m3_0 = new Float32Array(9);
@@ -26,7 +26,7 @@ function setElementTransform(domElement, position, scale, rotation) {
 
     const m3 = scratch_m3_0;
 
-    compose3x3transform(m3, position.x, position.y, scale.x, scale.y,0,0, rotation);
+    m3_cm_compose_transform(m3, position.x, position.y, scale.x, scale.y,0,0, rotation);
 
 
     /*

package/view/{compose3x3transform.js → m3_cm_compose_transform.js}

@@ -1,4 +1,6 @@
 /**
+ * Composes column-major transform matrix
+ * Column-major matrices are used in CSS
  *
  * @param {number[]|Float32Array} result
  * @param {number} tX translation X offset
@@ -9,7 +11,13 @@
  * @param {number} cy center of rotation Y
  * @param {number} angle rotation angle
  */
-export function compose3x3transform(result, tX, tY, sX, sY, cx, cy, angle) {
+export function m3_cm_compose_transform(
+    result,
+    tX, tY,
+    sX, sY,
+    cx, cy,
+    angle
+) {
     const neg_angle = -angle;
 
     const sin = Math.sin(neg_angle);
@@ -34,7 +42,7 @@ export function compose3x3transform(result, tX, tY, sX, sY, cx, cy, angle) {
  * @param {number} tX
  * @param {number} tY
  */
-export function m3_from_translation(result, tX, tY) {
+export function m3_cm_from_translation(result, tX, tY) {
     result[0] = 1;
     result[1] = 0;
     result[2] = tX;
@@ -53,6 +61,6 @@ export function m3_from_translation(result, tX, tY) {
  * @param {mat3|number[]|Float32Array} m3
  * @returns {number}
  */
-export function m3_extract_rotation(m3) {
+export function m3_cm_extract_rotation(m3) {
     return Math.atan2(m3[3], m3[0]);
 }

package/view/m3_rm_compose_transform.js

@@ -0,0 +1,45 @@
+/**
+ * Composes row-major transform matrix, row-major format is used in OpenGL
+ *
+ * @param {number[]|Float32Array} result
+ * @param {number} tX translation X offset
+ * @param {number} tY translation Y offset
+ * @param {number} sX scale in X axis
+ * @param {number} sY scale in Y axis
+ * @param {number} cx center of rotation X
+ * @param {number} cy center of rotation Y
+ * @param {number} angle rotation angle
+ */
+export function m3_rm_compose_transform(
+    result,
+    tX, tY,
+    sX, sY,
+    cx, cy,
+    angle
+) {
+    const neg_angle = -angle;
+
+    const sin = Math.sin(neg_angle);
+    const cos = Math.cos(neg_angle);
+
+    result[0] = sX * cos;
+    result[3] = sX * sin;
+    result[6] = -sX * (cos * cx + sin * cy) + cx + tX;
+
+    result[1] = -sY * sin;
+    result[4] = sY * cos;
+    result[7] = -sY * (-sin * cx + cos * cy) + cy + tY;
+
+    result[2] = 0;
+    result[5] = 0;
+    result[8] = 1;
+}
+
+
+export function m3_rm_extract_scale(result, m3) {
+    const scale_x = Math.hypot(m3[0], m3[3]);
+    const scale_y = Math.hypot(m3[1], m3[4]);
+
+    result[0] = scale_x;
+    result[1] = scale_y;
+}

package/view/multiplyMatrices3.js

@@ -1,11 +1,11 @@
 /**
  * Performs matrix multiplication of 3x3 matrices
  * r = a * b
- * @param {number[]} a first matrix
- * @param {number[]} b second matrix
- * @param {number[]} r result matrix
+ * @param {number[]|Float32Array} a first matrix
+ * @param {number[]|Float32Array} b second matrix
+ * @param {number[]|Float32Array} r result matrix
  */
-export function multiplyMatrices3(a, b, r) {
+export function m3_multiply(a, b, r) {
     //read out values of input matrices to support the case where result is written back into one of the inputs
     const a0 = a[0];
     const a1 = a[1];