@woosh/meep-engine 3.0.0 → 3.0.1

package/src/shade/renderer/loader/usd/usd_compose_transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usd_compose_transform.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_compose_transform.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;GAYG;AACH,kFAHW,MAAM,GACJ,YAAY,CA0BxB"}
+{"version":3,"file":"usd_compose_transform.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/usd_compose_transform.js"],"names":[],"mappings":"AAgEA;;;;;;;;;;;;GAYG;AACH,kFAHW,MAAM,GACJ,YAAY,CA0BxB"}

package/src/shade/renderer/loader/usd/usd_compose_transform.js

@@ -17,8 +17,18 @@
  * @module usd_compose_transform
  */
 
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
+import { M4_IDENTITY } from "../../../../core/geom/3d/mat4/M4_IDENTITY.js";
+import { m4_allocate } from "../../../../core/geom/3d/mat4/m4_allocate.js";
+import { m4_from_rotation_translation_scale } from "../../../../core/geom/3d/mat4/m4_from_rotation_translation_scale.js";
+import { m4_make_rotation_x } from "../../../../core/geom/3d/mat4/m4_make_rotation_x.js";
+import { m4_make_rotation_y } from "../../../../core/geom/3d/mat4/m4_make_rotation_y.js";
+import { m4_make_rotation_z } from "../../../../core/geom/3d/mat4/m4_make_rotation_z.js";
+import { m4_make_scale } from "../../../../core/geom/3d/mat4/m4_make_scale.js";
+import { m4_make_translation } from "../../../../core/geom/3d/mat4/m4_make_translation.js";
+import { m4_multiply } from "../../../../core/geom/3d/mat4/m4_multiply.js";
+import { m4_transpose } from "../../../../core/geom/3d/mat4/m4_transpose.js";
 import { DEG_TO_RAD } from "../../../../core/math/DEG_TO_RAD.js";
-import { mat4, quat } from "gl-matrix";
 
 /**
  * Reusable temporary matrix to avoid per-call allocations.
@@ -26,12 +36,31 @@ import { mat4, quat } from "gl-matrix";
  */
 const _temp_mat = new Float32Array(16);
 
+/**
+ * Reusable temporary matrix holding a single axis of an euler rotation, which is multiplied into
+ * the accumulating rotation rather than replacing it.
+ * @type {Float32Array}
+ */
+const _temp_axis_mat = new Float32Array(16);
+
 /**
  * Reusable temporary quaternion.
  * @type {Float32Array}
  */
 const _temp_quat = new Float32Array(4);
 
+/**
+ * An `xformOp:orient` carries rotation alone — translation and scale are separate ops with their
+ * own place in `xformOpOrder` — so the matrix it composes from a quaternion has neither.
+ * @type {number[]}
+ */
+const NO_TRANSLATION = [0, 0, 0];
+
+/**
+ * @see NO_TRANSLATION
+ * @type {number[]}
+ */
+const UNIT_SCALE = [1, 1, 1];
 
 /**
  * Compose a USD transform from its `xformOpOrder` and associated properties.
@@ -51,10 +80,10 @@ export function usd_compose_transform(fields, specs_by_path, prim_path) {
     const xform_op_order = fields.xformOpOrder;
 
     if (!xform_op_order || xform_op_order.length === 0) {
-        return mat4.create();
+        return m4_allocate();
     }
 
-    const result = mat4.create();
+    const result = m4_allocate();
 
     for (let i = 0; i < xform_op_order.length; i++) {
         const op_name = xform_op_order[i];
@@ -126,7 +155,7 @@ function resolve_xform_op_value(op_name, fields, specs_by_path, prim_path) {
  * - `xformOp:orient` — quaternion rotation (USD format: w,x,y,z)
  * - `xformOp:transform` — full 4×4 matrix
  *
- * @param {mat4} result - Matrix to multiply into (modified in place)
+ * @param {Float32Array} result - Matrix to multiply into (modified in place)
  * @param {string} op_name - Operation name
  * @param {number[]|Float32Array|Float64Array} value - Operation value
  */
@@ -135,28 +164,26 @@ function apply_xform_op(result, op_name, value) {
     // Strip the "xformOp:" prefix and any namespace suffix (e.g. ":pivot")
     const op = op_name.replace(/^xformOp:/, "");
 
-    mat4.identity(_temp_mat);
-
     if (op === "translate") {
 
         // NOTE: float64 → float32 precision loss for large coordinates
-        mat4.translate(_temp_mat, _temp_mat, [value[0], value[1], value[2]]);
+        m4_make_translation(_temp_mat, value);
 
     } else if (op === "scale") {
 
-        mat4.scale(_temp_mat, _temp_mat, [value[0], value[1], value[2]]);
+        m4_make_scale(_temp_mat, value);
 
     } else if (op === "rotateX") {
 
-        mat4.rotateX(_temp_mat, _temp_mat, value * DEG_TO_RAD);
+        m4_make_rotation_x(_temp_mat, value * DEG_TO_RAD);
 
     } else if (op === "rotateY") {
 
-        mat4.rotateY(_temp_mat, _temp_mat, value * DEG_TO_RAD);
+        m4_make_rotation_y(_temp_mat, value * DEG_TO_RAD);
 
     } else if (op === "rotateZ") {
 
-        mat4.rotateZ(_temp_mat, _temp_mat, value * DEG_TO_RAD);
+        m4_make_rotation_z(_temp_mat, value * DEG_TO_RAD);
 
     } else if (op === "rotateXYZ" || op === "rotateXZY" || op === "rotateYXZ" ||
         op === "rotateYZX" || op === "rotateZXY" || op === "rotateZYX") {
@@ -166,30 +193,34 @@ function apply_xform_op(result, op_name, value) {
     } else if (op === "orient") {
 
         // USD quaternion order: (w, x, y, z)
-        // gl-matrix quaternion order: (x, y, z, w)
+        // engine quaternion order: (x, y, z, w)
         // @see https://openusd.org/release/api/class_gf_quatf.html — GfQuatf real-part-first layout
-        quat.set(_temp_quat, value[1], value[2], value[3], value[0]);
-        mat4.fromQuat(_temp_mat, _temp_quat);
+        _temp_quat[0] = value[1];
+        _temp_quat[1] = value[2];
+        _temp_quat[2] = value[3];
+        _temp_quat[3] = value[0];
+
+        m4_from_rotation_translation_scale(_temp_mat, _temp_quat, NO_TRANSLATION, UNIT_SCALE);
 
     } else if (op === "transform") {
 
         // Full 4×4 matrix — USD stores row-major, engine uses column-major
         // NOTE: float64 → float32 precision loss for all 16 matrix elements
-        mat4.transpose(_temp_mat, value);
+        m4_transpose(_temp_mat, value);
 
     } else {
         console.warn(`[USD] Unknown xformOp: "${op_name}", skipping`);
         return;
     }
 
-    mat4.multiply(result, result, _temp_mat);
+    m4_multiply(result, result, _temp_mat);
 }
 
 
 /**
  * Apply euler rotation in the specified axis order.
  *
- * @param {mat4} out - Output matrix
+ * @param {Float32Array} out - Output matrix
  * @param {string} order - e.g. "rotateXYZ"
  * @param {number[]} angles - [x, y, z] in degrees
  */
@@ -203,21 +234,25 @@ function apply_euler_rotation(out, order, angles) {
     const axis_order = order.replace("rotate", "");
 
     const ops = {
-        "X": (m) => mat4.rotateX(m, m, rx),
-        "Y": (m) => mat4.rotateY(m, m, ry),
-        "Z": (m) => mat4.rotateZ(m, m, rz),
+        "X": (m) => m4_make_rotation_x(m, rx),
+        "Y": (m) => m4_make_rotation_y(m, ry),
+        "Z": (m) => m4_make_rotation_z(m, rz),
     };
 
+    array_copy(M4_IDENTITY, 0, out, 0, 16);
+
     // OpenUSD applies the named axes to the point first-to-last (rotateXYZ ⇒ X
-    // first). gl-matrix post-multiplies, so build the matrix in reverse:
-    // out = R_last · … · R_first.
+    // first). A column-major matrix applies its rightmost factor first, so build
+    // the product in reverse: out = R_last · … · R_first.
     // @see https://openusd.org/release/api/class_usd_geom_xform_op.html — TypeRotateXYZ
     for (let i = axis_order.length - 1; i >= 0; i--) {
         const axis = axis_order[i];
         const fn = ops[axis];
 
         if (fn) {
-            fn(out);
+            fn(_temp_axis_mat);
+
+            m4_multiply(out, out, _temp_axis_mat);
         }
     }
 }