reze-engine 0.27.4 → 0.28.0

package/README.md

@@ -29,9 +29,9 @@ See [Physics](#physics) and [Rendering](#rendering) for the internals.
 - [Reze Design](https://reze.design) (web-native scene composer & shader-graph styling)
 - [Reze Studio](https://reze.studio) (MMD animation editor)
 - [MiKaPo](https://mikapo.vercel.app) (motion capture)
+- [Reze Rig](https://reze-rig.vercel.app) (FBX→VMD retarget)
 - [Popo](https://popo.love) (LLM-generated poses)
 - [MPL](https://mmd-mpl.vercel.app) (motion language)
-- [Mixamo-MMD](https://mixamo-mmd.vercel.app) (FBX→VMD retarget)
 
 ## Quick start
 
@@ -252,14 +252,14 @@ const { ok, wgsl, diagnostics } = compileGraph(HAIR_GRAPH, {
 
 The **built-in name hints**, checked top-to-bottom (first match wins), with the graph and pass-integration each category carries:
 
-| Category       | Graph · render-class / alpha       | Matches a name containing (case-insensitive substring)                                                                                                           |
-| -------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `stockings`    | `STOCKINGS_GRAPH` · `hashed` alpha | 靴下 · ソックス · タイツ · ニーソ · 袜 · stocking · socks · tights                                                                                               |
-| `eye`          | `EYE_GRAPH` · `eye`                | 白目 · 目影 · 二重 · 睫 · まつげ · まゆ · 眉 · 目 · 瞳 · 眼 · eye · iris · pupil · lash · brow                                                                   |
-| `face`         | `FACE_GRAPH`                       | 顔 · 颜 · 脸 · かお · face · 舌 · tongue · 牙 · 牙齿 · 歯 · teeth · tooth · 口腔 · 口内 · mouth · 嘴 · 歯茎 · gums                                              |
-| `hair`         | `HAIR_GRAPH` · `hair`              | 前髪 · 後髪 · 髪 · 髮 · 头发 · 頭髪 · もみあげ · アホ毛 · ヘア · hair · ahoge · bang                                                                             |
-| `body`         | `BODY_GRAPH`                       | 肌 · 皮肤 · skin                                                                                                                                                 |
-| `metal`        | `METAL_GRAPH`                      | 金属 · メタル · metal · earring · 耳环 · 耳環                                                                                                                    |
+| Category       | Graph · render-class / alpha       | Matches a name containing (case-insensitive substring)                                                                                                                                               |
+| -------------- | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `stockings`    | `STOCKINGS_GRAPH` · `hashed` alpha | 靴下 · ソックス · タイツ · ニーソ · 袜 · stocking · socks · tights                                                                                                                                   |
+| `eye`          | `EYE_GRAPH` · `eye`                | 白目 · 目影 · 二重 · 睫 · まつげ · まゆ · 眉 · 目 · 瞳 · 眼 · eye · iris · pupil · lash · brow                                                                                                       |
+| `face`         | `FACE_GRAPH`                       | 顔 · 颜 · 脸 · かお · face · 舌 · tongue · 牙 · 牙齿 · 歯 · teeth · tooth · 口腔 · 口内 · mouth · 嘴 · 歯茎 · gums                                                                                   |
+| `hair`         | `HAIR_GRAPH` · `hair`              | 前髪 · 後髪 · 髪 · 髮 · 头发 · 頭髪 · もみあげ · アホ毛 · ヘア · hair · ahoge · bang                                                                                                                 |
+| `body`         | `BODY_GRAPH`                       | 肌 · 皮肤 · skin                                                                                                                                                                                     |
+| `metal`        | `METAL_GRAPH`                      | 金属 · メタル · metal · earring · 耳环 · 耳環                                                                                                                                                        |
 | `cloth_smooth` | `CLOTH_SMOOTH_GRAPH`               | 服 · 衣 · 裙 · 裤 · スカート · ワンピ · リボン · 袖 · 靴 · 鞋 · 帽 · 体 · 飾 · 饰 · 尾 · 套 · 腿 · skirt · dress · ribbon · sleeve · shoes · shirt · short · boot · hat · cloth · accessor · trigger |
 
 `cloth_rough` and `default` have **no** name hints — a material reaches them only via an explicit `overrides` entry. The group `id` is the category name, so re-running `autoStyleGroups` is idempotent; its promise resolves after every graph compiles, so `getStyleGroups(model)` is ready the moment it resolves — seed your own store from it, then edit with `applyStyleGroups`.

package/dist/ik-solver.d.ts

@@ -9,7 +9,7 @@ export declare class IKSolverSystem {
     private static solveChain;
     private static limitAngle;
     private static getDistance;
-    private static readonly EULER_AXES;
+    private static readonly EULER_ORDER_NAMES;
     private static extractEulerAnglesInto;
     private static limitEulerAnglesInto;
     private static reconstructQuatFromEulerInto;

package/dist/ik-solver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ik-solver.d.ts","sourceRoot":"","sources":["../src/ik-solver.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AACzC,OAAO,EAAE,IAAI,EAAU,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAG7D,MAAM,MAAM,mBAAmB,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;AAwF/E,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAS;IACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAuB;IAExD,MAAM,CAAC,KAAK,CACV,SAAS,EAAE,QAAQ,EAAE,EACrB,KAAK,EAAE,IAAI,EAAE,EACb,cAAc,EAAE,IAAI,EAAE,EACtB,iBAAiB,EAAE,IAAI,EAAE,EACzB,aAAa,EAAE,IAAI,EAAE,EACrB,WAAW,EAAE,WAAW,EAAE,EAC1B,iBAAiB,CAAC,EAAE,mBAAmB,GACtC,IAAI;IAMP,OAAO,CAAC,MAAM,CAAC,OAAO;IAqFtB,OAAO,CAAC,MAAM,CAAC,UAAU;IA4HzB,OAAO,CAAC,MAAM,CAAC,UAAU;IAYzB,OAAO,CAAC,MAAM,CAAC,WAAW;IAW1B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAOjC;IAED,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAsCrC,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAMnC,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAyB3C,OAAO,CAAC,MAAM,CAAC,gCAAgC;IAkB/C,OAAO,CAAC,MAAM,CAAC,iBAAiB;CA2CjC"}
+{"version":3,"file":"ik-solver.d.ts","sourceRoot":"","sources":["../src/ik-solver.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAmB,MAAM,QAAQ,CAAA;AAC1D,OAAO,EAAE,IAAI,EAAU,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAG7D,MAAM,MAAM,mBAAmB,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;AAuF/E,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAS;IACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAuB;IAExD,MAAM,CAAC,KAAK,CACV,SAAS,EAAE,QAAQ,EAAE,EACrB,KAAK,EAAE,IAAI,EAAE,EACb,cAAc,EAAE,IAAI,EAAE,EACtB,iBAAiB,EAAE,IAAI,EAAE,EACzB,aAAa,EAAE,IAAI,EAAE,EACrB,WAAW,EAAE,WAAW,EAAE,EAC1B,iBAAiB,CAAC,EAAE,mBAAmB,GACtC,IAAI;IAMP,OAAO,CAAC,MAAM,CAAC,OAAO;IAqFtB,OAAO,CAAC,MAAM,CAAC,UAAU;IA4HzB,OAAO,CAAC,MAAM,CAAC,UAAU;IAYzB,OAAO,CAAC,MAAM,CAAC,WAAW;IAU1B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAA+C;IAExF,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAsCrC,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAMnC,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAK3C,OAAO,CAAC,MAAM,CAAC,gCAAgC;IAkB/C,OAAO,CAAC,MAAM,CAAC,iBAAiB;CA2CjC"}

package/dist/ik-solver.js

@@ -71,7 +71,6 @@ const _ikVec = [
 ];
 const _ikQuat = [
     new Quat(0, 0, 0, 1), new Quat(0, 0, 0, 1), new Quat(0, 0, 0, 1),
-    new Quat(0, 0, 0, 1), new Quat(0, 0, 0, 1), new Quat(0, 0, 0, 1),
 ];
 const _ikMat = [
     new Float32Array(16), new Float32Array(16), new Float32Array(16), new Float32Array(16),
@@ -151,7 +150,7 @@ export class IKSolverSystem {
         //   _ikVec[0]=chainPos, [1]=ikPos, [2]=targetPos, [3]=chainTargetVec, [4]=chainIkVec,
         //           [5]=rotAxis, [6]=finalAxis, [7]=eulerTmp, [8]=limitedEuler
         //   _ikMat[0]=parentRot, [1]=invParentRot, [2]=quatToMatTmp
-        //   _ikQuat[0]=ikRotation, [1]=combinedRot, [2]=localRotConj, [3..5]=axisAngleTmp
+        //   _ikQuat[0]=ikRotation, [1]=combinedRot, [2]=localRotConj
         const chainPos = Vec3.setFromMat4Translation(worldMatrices[chainBoneIndex].values, _ikVec[0]);
         const ikPos = Vec3.setFromMat4Translation(worldMatrices[ikBoneIndex].values, _ikVec[1]);
         const targetPos = Vec3.setFromMat4Translation(worldMatrices[targetBoneIndex].values, _ikVec[2]);
@@ -317,23 +316,7 @@ export class IKSolverSystem {
         out.z = this.limitAngle(euler.z, min.z, max.z, useAxis);
     }
     static reconstructQuatFromEulerInto(euler, order, out) {
-        const axes = this.EULER_AXES[order];
-        const a1 = axes[0], a2 = axes[1], a3 = axes[2];
-        const ang1 = order === InternalEulerRotationOrder.YXZ ? euler.y
-            : order === InternalEulerRotationOrder.ZYX ? euler.z
-                : euler.x;
-        const ang2 = order === InternalEulerRotationOrder.YXZ ? euler.x
-            : order === InternalEulerRotationOrder.ZYX ? euler.y
-                : euler.z;
-        const ang3 = order === InternalEulerRotationOrder.YXZ ? euler.z
-            : order === InternalEulerRotationOrder.ZYX ? euler.x
-                : euler.y;
-        // result = axisAngle(a1, ang1); then *= axisAngle(a2, ang2); then *= axisAngle(a3, ang3)
-        Quat.fromAxisAngleInto(a1[0], a1[1], a1[2], ang1, out);
-        Quat.fromAxisAngleInto(a2[0], a2[1], a2[2], ang2, _ikQuat[3]);
-        Quat.multiplyInto(out, _ikQuat[3], out);
-        Quat.fromAxisAngleInto(a3[0], a3[1], a3[2], ang3, _ikQuat[3]);
-        Quat.multiplyInto(out, _ikQuat[3], out);
+        Quat.fromEulerOrderInto(euler.x, euler.y, euler.z, this.EULER_ORDER_NAMES[order], out);
     }
     // Write parent's world rotation (translation stripped) into out Float32Array.
     static getParentWorldRotationMatrixInto(boneIndex, bones, worldMatrices, out) {
@@ -396,13 +379,5 @@ export class IKSolverSystem {
 }
 IKSolverSystem.EPSILON = 1.0e-8;
 IKSolverSystem.THRESHOLD = (88 * Math.PI) / 180;
-// Euler axis triples for each rotation order (indexed by order enum).
-// Reused to avoid allocations in reconstructQuatFromEulerInto.
-IKSolverSystem.EULER_AXES = [
-    // YXZ: Y, X, Z
-    [[0, 1, 0], [1, 0, 0], [0, 0, 1]],
-    // ZYX: Z, Y, X
-    [[0, 0, 1], [0, 1, 0], [1, 0, 0]],
-    // XZY: X, Z, Y
-    [[1, 0, 0], [0, 0, 1], [0, 1, 0]],
-];
+// Maps InternalEulerRotationOrder to the shared math-layer order names.
+IKSolverSystem.EULER_ORDER_NAMES = ["YXZ", "ZYX", "XZY"];

package/dist/index.d.ts

@@ -15,9 +15,9 @@ export { STOCKINGS_GRAPH } from "./graph/presets/stockings";
 export { EYE_GRAPH } from "./graph/presets/eye";
 export { FACE_GRAPH } from "./graph/presets/face";
 export { Model } from "./model";
-export { Vec3, Quat, Mat4 } from "./math";
+export { Vec3, Quat, Mat4, easeInOut, type EulerOrder } from "./math";
 export type { AnimationClip, AnimationPlayOptions, AnimationProgress, BoneKeyframe, IkKeyframe, MorphKeyframe, BoneInterpolation, ControlPoint, } from "./animation";
-export { FPS } from "./animation";
+export { FPS, bezierInterpolate, interpolateControlPoints, rawInterpolationToBoneInterpolation, } from "./animation";
 export { VMDLoader, type CameraKeyframe, type IkFrame } from "./vmd-loader";
 export { CameraAnimation, type CameraPose } from "./camera-animation";
 export { RezePhysics } from "./physics";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,GAC5B,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACvG,OAAO,EACL,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,GACf,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,WAAW,EACX,SAAS,EACT,SAAS,EACT,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAC3E,OAAO,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC7G,YAAY,EACV,UAAU,EACV,eAAe,EACf,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AACzC,YAAY,EACV,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,YAAY,GACb,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3E,OAAO,EAAE,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,0BAA0B,EAC/B,KAAK,sBAAsB,GAC5B,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACvG,OAAO,EACL,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,GACf,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,WAAW,EACX,SAAS,EACT,SAAS,EACT,YAAY,EACZ,WAAW,EACX,UAAU,GACX,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAC3E,OAAO,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC7G,YAAY,EACV,UAAU,EACV,eAAe,EACf,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,QAAQ,CAAA;AACrE,YAAY,EACV,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,YAAY,GACb,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,GAAG,EACH,iBAAiB,EACjB,wBAAwB,EACxB,mCAAmC,GACpC,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3E,OAAO,EAAE,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA"}

package/dist/index.js

@@ -13,8 +13,8 @@ export { STOCKINGS_GRAPH } from "./graph/presets/stockings";
 export { EYE_GRAPH } from "./graph/presets/eye";
 export { FACE_GRAPH } from "./graph/presets/face";
 export { Model } from "./model";
-export { Vec3, Quat, Mat4 } from "./math";
-export { FPS } from "./animation";
+export { Vec3, Quat, Mat4, easeInOut } from "./math";
+export { FPS, bezierInterpolate, interpolateControlPoints, rawInterpolationToBoneInterpolation, } from "./animation";
 export { VMDLoader } from "./vmd-loader";
 export { CameraAnimation } from "./camera-animation";
 export { RezePhysics } from "./physics";

package/dist/math.d.ts

@@ -1,4 +1,5 @@
 export declare function easeInOut(t: number): number;
+export type EulerOrder = "XYZ" | "XZY" | "YXZ" | "YZX" | "ZXY" | "ZYX";
 export declare class Vec3 {
     x: number;
     y: number;
@@ -18,6 +19,8 @@ export declare class Vec3 {
     static crossInto(a: Vec3, b: Vec3, out: Vec3): Vec3;
     static setFromMat4Translation(m: Float32Array, out: Vec3): Vec3;
     static transformMat4RotationInto(normal: Vec3, m: Float32Array, out: Vec3): Vec3;
+    static mirrorZInto(v: Vec3, out: Vec3): Vec3;
+    static mirrorZ(v: Vec3): Vec3;
     normalizeInPlace(): Vec3;
 }
 export declare class Quat {
@@ -43,6 +46,29 @@ export declare class Quat {
     setXYZW(x: number, y: number, z: number, w: number): Quat;
     setIdentity(): Quat;
     static fromEuler(rotX: number, rotY: number, rotZ: number): Quat;
+    static dot(a: Quat, b: Quat): number;
+    static angleTo(a: Quat, b: Quat): number;
+    static conjugateInto(q: Quat, out: Quat): Quat;
+    static nlerpInto(a: Quat, b: Quat, t: number, out: Quat): Quat;
+    static nlerp(a: Quat, b: Quat, t: number): Quat;
+    static rotateVecInto(q: Quat, v: Vec3, out: Vec3): Vec3;
+    static rotateVec(q: Quat, v: Vec3): Vec3;
+    static rotateVecInvInto(q: Quat, v: Vec3, out: Vec3): Vec3;
+    static rotateVecInv(q: Quat, v: Vec3): Vec3;
+    static fromUnitVectorsInto(from: Vec3, to: Vec3, out: Quat): Quat;
+    static fromUnitVectors(from: Vec3, to: Vec3): Quat;
+    static fromBasisInto(x: Vec3, y: Vec3, z: Vec3, out: Quat): Quat;
+    static fromBasis(x: Vec3, y: Vec3, z: Vec3): Quat;
+    static twistAroundAxisInto(q: Quat, a: Vec3, out: Quat): Quat;
+    static twistAroundAxis(q: Quat, a: Vec3): Quat;
+    static lookRotationInto(forward: Vec3, up: Vec3, out: Quat): Quat;
+    static lookRotation(forward: Vec3, up: Vec3): Quat;
+    static mirrorZInto(q: Quat, out: Quat): Quat;
+    static mirrorZ(q: Quat): Quat;
+    static fromEulerOrderInto(x: number, y: number, z: number, order: EulerOrder, out: Quat): Quat;
+    static fromEulerOrder(x: number, y: number, z: number, order: EulerOrder): Quat;
+    static toEulerOrderInto(q: Quat, order: EulerOrder, out: Vec3): Vec3;
+    static toEulerOrder(q: Quat, order: EulerOrder): Vec3;
 }
 export declare class Mat4 {
     values: Float32Array;

package/dist/math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"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"}

package/dist/math.js

@@ -90,6 +90,16 @@ export class Vec3 {
         out.z = m[2] * nx + m[6] * ny + m[10] * nz;
         return out;
     }
+    // out = (x, y, -z): right-handed Y-up ↔ left-handed Y-up (involutive). Safe when out === v.
+    static mirrorZInto(v, out) {
+        out.x = v.x;
+        out.y = v.y;
+        out.z = -v.z;
+        return out;
+    }
+    static mirrorZ(v) {
+        return new Vec3(v.x, v.y, -v.z);
+    }
     // In-place normalize returning length squared info via Vec3. Alias for normalize() but explicit.
     normalizeInPlace() {
         return this.normalize();
@@ -286,6 +296,318 @@ export class Quat {
         const z = cy * cx * sz - sy * sx * cz;
         return new Quat(x, y, z, w).normalize();
     }
+    // 4D dot product. Negative means a and b are on opposite hemispheres (same rotation
+    // when |dot| ≈ 1 either way — quaternion double cover).
+    static dot(a, b) {
+        return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+    }
+    // Rotation angle between a and b in radians, insensitive to double cover.
+    static angleTo(a, b) {
+        const d = Math.abs(a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w);
+        return 2 * Math.acos(Math.min(1, d));
+    }
+    // out = conjugate of q (inverse for unit quaternions), without mutating q. Safe when out === q.
+    static conjugateInto(q, out) {
+        out.x = -q.x;
+        out.y = -q.y;
+        out.z = -q.z;
+        out.w = q.w;
+        return out;
+    }
+    // out = normalized lerp from a to b, taking the shorter path (negates b when dot < 0).
+    // Cheaper than slerp; non-constant angular velocity. Safe when out === a or out === b.
+    static nlerpInto(a, b, t, out) {
+        const d = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+        const s = d < 0 ? -1 : 1;
+        const x = a.x + (b.x * s - a.x) * t;
+        const y = a.y + (b.y * s - a.y) * t;
+        const z = a.z + (b.z * s - a.z) * t;
+        const w = a.w + (b.w * s - a.w) * t;
+        const invLen = 1 / Math.hypot(x, y, z, w);
+        out.x = x * invLen;
+        out.y = y * invLen;
+        out.z = z * invLen;
+        out.w = w * invLen;
+        return out;
+    }
+    static nlerp(a, b, t) {
+        return Quat.nlerpInto(a, b, t, new Quat(0, 0, 0, 1));
+    }
+    // out = v rotated by unit quaternion q (no matrix, no allocation). Safe when out === v.
+    static rotateVecInto(q, v, out) {
+        // v' = v + 2*qw*(qv × v) + 2*(qv × (qv × v))
+        const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
+        const vx = v.x, vy = v.y, vz = v.z;
+        // t = 2 * (qv × v)
+        const tx = 2 * (qy * vz - qz * vy);
+        const ty = 2 * (qz * vx - qx * vz);
+        const tz = 2 * (qx * vy - qy * vx);
+        out.x = vx + qw * tx + qy * tz - qz * ty;
+        out.y = vy + qw * ty + qz * tx - qx * tz;
+        out.z = vz + qw * tz + qx * ty - qy * tx;
+        return out;
+    }
+    static rotateVec(q, v) {
+        return Quat.rotateVecInto(q, v, new Vec3(0, 0, 0));
+    }
+    // out = v rotated by the inverse (conjugate) of unit quaternion q. Safe when out === v.
+    static rotateVecInvInto(q, v, out) {
+        const qx = -q.x, qy = -q.y, qz = -q.z, qw = q.w;
+        const vx = v.x, vy = v.y, vz = v.z;
+        const tx = 2 * (qy * vz - qz * vy);
+        const ty = 2 * (qz * vx - qx * vz);
+        const tz = 2 * (qx * vy - qy * vx);
+        out.x = vx + qw * tx + qy * tz - qz * ty;
+        out.y = vy + qw * ty + qz * tx - qx * tz;
+        out.z = vz + qw * tz + qx * ty - qy * tx;
+        return out;
+    }
+    static rotateVecInv(q, v) {
+        return Quat.rotateVecInvInto(q, v, new Vec3(0, 0, 0));
+    }
+    // out = shortest-arc rotation taking unit vector `from` to unit vector `to`.
+    // Matches Babylon's FromUnitVectorsToRef exactly, including the near-antiparallel
+    // branch (w = 1 + dot < 0.001 → 180° about a perpendicular picked the same way).
+    static fromUnitVectorsInto(from, to, out) {
+        const r = from.x * to.x + from.y * to.y + from.z * to.z + 1;
+        if (r < 0.001) {
+            if (Math.abs(from.x) > Math.abs(from.z)) {
+                out.setXYZW(-from.y, from.x, 0, 0);
+            }
+            else {
+                out.setXYZW(0, -from.z, from.y, 0);
+            }
+        }
+        else {
+            // q = (from × to, 1 + from·to)
+            out.setXYZW(from.y * to.z - from.z * to.y, from.z * to.x - from.x * to.z, from.x * to.y - from.y * to.x, r);
+        }
+        const invLen = 1 / Math.sqrt(out.x * out.x + out.y * out.y + out.z * out.z + out.w * out.w);
+        out.setXYZW(out.x * invLen, out.y * invLen, out.z * invLen, out.w * invLen);
+        return out;
+    }
+    static fromUnitVectors(from, to) {
+        return Quat.fromUnitVectorsInto(from, to, new Quat(0, 0, 0, 1));
+    }
+    // out = rotation taking the standard basis onto the orthonormal axes x, y, z
+    // (the columns of the column-major rotation matrix): rotateVec(out, (1,0,0)) = x, etc.
+    static fromBasisInto(x, y, z, out) {
+        // Shepperd's method on the 3x3 with columns x, y, z.
+        const m00 = x.x, m01 = x.y, m02 = x.z;
+        const m10 = y.x, m11 = y.y, m12 = y.z;
+        const m20 = z.x, m21 = z.y, m22 = z.z;
+        const trace = m00 + m11 + m22;
+        if (trace > 0) {
+            const s = 0.5 / Math.sqrt(trace + 1);
+            out.setXYZW((m12 - m21) * s, (m20 - m02) * s, (m01 - m10) * s, 0.25 / s);
+        }
+        else if (m00 > m11 && m00 > m22) {
+            const s = 2 * Math.sqrt(1 + m00 - m11 - m22);
+            out.setXYZW(0.25 * s, (m10 + m01) / s, (m20 + m02) / s, (m12 - m21) / s);
+        }
+        else if (m11 > m22) {
+            const s = 2 * Math.sqrt(1 + m11 - m00 - m22);
+            out.setXYZW((m10 + m01) / s, 0.25 * s, (m21 + m12) / s, (m20 - m02) / s);
+        }
+        else {
+            const s = 2 * Math.sqrt(1 + m22 - m00 - m11);
+            out.setXYZW((m20 + m02) / s, (m21 + m12) / s, 0.25 * s, (m01 - m10) / s);
+        }
+        return out;
+    }
+    static fromBasis(x, y, z) {
+        return Quat.fromBasisInto(x, y, z, new Quat(0, 0, 0, 1));
+    }
+    // out = twist component of q around unit axis `a`, so that q = swing · twist
+    // (swing = Quat.multiply(q, conjugate(twist))). Singular when q is ~180° about an
+    // axis perpendicular to `a` — returns identity there.
+    static twistAroundAxisInto(q, a, out) {
+        const d = q.x * a.x + q.y * a.y + q.z * a.z;
+        const px = a.x * d;
+        const py = a.y * d;
+        const pz = a.z * d;
+        const len = Math.sqrt(px * px + py * py + pz * pz + q.w * q.w);
+        if (len < 1e-8) {
+            out.setIdentity();
+            return out;
+        }
+        out.setXYZW(px / len, py / len, pz / len, q.w / len);
+        return out;
+    }
+    static twistAroundAxis(q, a) {
+        return Quat.twistAroundAxisInto(q, a, new Quat(0, 0, 0, 1));
+    }
+    // out = orientation looking along `forward` (mapped to local +Z, the engine's LH forward)
+    // with local +Y toward `up`. Falls back to a reference up when forward ∥ up.
+    static lookRotationInto(forward, up, out) {
+        let zx = forward.x, zy = forward.y, zz = forward.z;
+        const zl = Math.sqrt(zx * zx + zy * zy + zz * zz);
+        if (zl === 0)
+            return out.setIdentity();
+        const zi = 1 / zl;
+        zx *= zi;
+        zy *= zi;
+        zz *= zi;
+        // x = up × z
+        let xx = up.y * zz - up.z * zy;
+        let xy = up.z * zx - up.x * zz;
+        let xz = up.x * zy - up.y * zx;
+        let xl = Math.sqrt(xx * xx + xy * xy + xz * xz);
+        if (xl < 1e-8) {
+            // forward ∥ up: substitute a reference up not parallel to forward
+            const uy = Math.abs(zy) < 0.99 ? 1 : 0;
+            const ux = 1 - uy;
+            xx = uy * zz;
+            xy = -ux * zz;
+            xz = ux * zy - uy * zx;
+            xl = Math.sqrt(xx * xx + xy * xy + xz * xz);
+        }
+        const xi = 1 / xl;
+        xx *= xi;
+        xy *= xi;
+        xz *= xi;
+        // y = z × x (unit: z ⊥ x)
+        const yx = zy * xz - zz * xy;
+        const yy = zz * xx - zx * xz;
+        const yz = zx * xy - zy * xx;
+        _lookX.setXYZ(xx, xy, xz);
+        _lookY.setXYZ(yx, yy, yz);
+        _lookZ.setXYZ(zx, zy, zz);
+        return Quat.fromBasisInto(_lookX, _lookY, _lookZ, out);
+    }
+    static lookRotation(forward, up) {
+        return Quat.lookRotationInto(forward, up, new Quat(0, 0, 0, 1));
+    }
+    // out = q with the Z axis mirrored: right-handed Y-up ↔ left-handed Y-up
+    // (conjugation by the Z-mirror; involutive). Pairs with Vec3.mirrorZInto. Safe when out === q.
+    static mirrorZInto(q, out) {
+        out.x = -q.x;
+        out.y = -q.y;
+        out.z = q.z;
+        out.w = q.w;
+        return out;
+    }
+    static mirrorZ(q) {
+        return new Quat(-q.x, -q.y, q.z, q.w);
+    }
+    // out = quaternion from euler angles (radians) applied in the given intrinsic order.
+    // fromEulerOrderInto(x, y, z, "YXZ", out) matches Quat.fromEuler (the MMD/PMX convention).
+    static fromEulerOrderInto(x, y, z, order, out) {
+        out.setIdentity();
+        for (let i = 0; i < 3; i++) {
+            const axis = order.charCodeAt(i) - 88; // "X" → 0, "Y" → 1, "Z" → 2
+            const angle = axis === 0 ? x : axis === 1 ? y : z;
+            const half = angle * 0.5;
+            const s = Math.sin(half);
+            const c = Math.cos(half);
+            const ax = out.x, ay = out.y, az = out.z, aw = out.w;
+            if (axis === 0) {
+                out.x = aw * s + ax * c;
+                out.y = ay * c + az * s;
+                out.z = az * c - ay * s;
+                out.w = aw * c - ax * s;
+            }
+            else if (axis === 1) {
+                out.x = ax * c - az * s;
+                out.y = aw * s + ay * c;
+                out.z = az * c + ax * s;
+                out.w = aw * c - ay * s;
+            }
+            else {
+                out.x = ax * c + ay * s;
+                out.y = ay * c - ax * s;
+                out.z = aw * s + az * c;
+                out.w = aw * c - az * s;
+            }
+        }
+        return out;
+    }
+    static fromEulerOrder(x, y, z, order) {
+        return Quat.fromEulerOrderInto(x, y, z, order, new Quat(0, 0, 0, 1));
+    }
+    // Extract euler angles (radians) in the given intrinsic order into out (out.x/y/z = rotation
+    // about X/Y/Z). At gimbal lock (middle angle ±90°) the split between first and third angle is
+    // ambiguous; the third is set to 0.
+    static toEulerOrderInto(q, order, out) {
+        Mat4.fromQuatInto(q.x, q.y, q.z, q.w, _eulerMat, 0);
+        const m = _eulerMat;
+        const m11 = m[0], m12 = m[4], m13 = m[8];
+        const m21 = m[1], m22 = m[5], m23 = m[9];
+        const m31 = m[2], m32 = m[6], m33 = m[10];
+        const clamp = (v) => (v < -1 ? -1 : v > 1 ? 1 : v);
+        switch (order) {
+            case "XYZ":
+                out.y = Math.asin(clamp(m13));
+                if (Math.abs(m13) < 0.9999999) {
+                    out.x = Math.atan2(-m23, m33);
+                    out.z = Math.atan2(-m12, m11);
+                }
+                else {
+                    out.x = Math.atan2(m32, m22);
+                    out.z = 0;
+                }
+                break;
+            case "YXZ":
+                out.x = Math.asin(-clamp(m23));
+                if (Math.abs(m23) < 0.9999999) {
+                    out.y = Math.atan2(m13, m33);
+                    out.z = Math.atan2(m21, m22);
+                }
+                else {
+                    out.y = Math.atan2(-m31, m11);
+                    out.z = 0;
+                }
+                break;
+            case "ZXY":
+                out.x = Math.asin(clamp(m32));
+                if (Math.abs(m32) < 0.9999999) {
+                    out.y = Math.atan2(-m31, m33);
+                    out.z = Math.atan2(-m12, m22);
+                }
+                else {
+                    out.y = 0;
+                    out.z = Math.atan2(m21, m11);
+                }
+                break;
+            case "ZYX":
+                out.y = Math.asin(-clamp(m31));
+                if (Math.abs(m31) < 0.9999999) {
+                    out.x = Math.atan2(m32, m33);
+                    out.z = Math.atan2(m21, m11);
+                }
+                else {
+                    out.x = 0;
+                    out.z = Math.atan2(-m12, m22);
+                }
+                break;
+            case "YZX":
+                out.z = Math.asin(clamp(m21));
+                if (Math.abs(m21) < 0.9999999) {
+                    out.x = Math.atan2(-m23, m22);
+                    out.y = Math.atan2(-m31, m11);
+                }
+                else {
+                    out.x = 0;
+                    out.y = Math.atan2(m13, m33);
+                }
+                break;
+            case "XZY":
+                out.z = Math.asin(-clamp(m12));
+                if (Math.abs(m12) < 0.9999999) {
+                    out.x = Math.atan2(m32, m22);
+                    out.y = Math.atan2(m13, m11);
+                }
+                else {
+                    out.x = Math.atan2(-m23, m33);
+                    out.y = 0;
+                }
+                break;
+        }
+        return out;
+    }
+    static toEulerOrder(q, order) {
+        return Quat.toEulerOrderInto(q, order, new Vec3(0, 0, 0));
+    }
 }
 export class Mat4 {
     constructor(values) {
@@ -762,6 +1084,12 @@ export class Mat4 {
         return new Mat4(out);
     }
 }
+// Module-private scratch for Quat.toEulerOrderInto / lookRotationInto (never handed out,
+// so no cross-call stomping with the public pools below).
+const _eulerMat = new Float32Array(16);
+const _lookX = new Vec3(0, 0, 0);
+const _lookY = new Vec3(0, 0, 0);
+const _lookZ = new Vec3(0, 0, 0);
 // Preallocated scratch instances for hot paths. Each subsystem should use its own
 // slot to avoid cross-call stomping. Bump the count if more call sites need scratch.
 export const scratchMat4Values = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.27.4",
+  "version": "0.28.0",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/ik-solver.ts

@@ -1,6 +1,6 @@
 // IK solver (MMD-style; see Saba MMDIkSolver.cpp)
 
-import { Mat4, Quat, Vec3 } from "./math"
+import { Mat4, Quat, Vec3, type EulerOrder } from "./math"
 import { Bone, IKLink, IKSolver, IKChainInfo } from "./model"
 
 // Callback type for updating world matrix (provided by model to handle append transformations)
@@ -80,7 +80,6 @@ const _ikVec: Vec3[] = [
 ]
 const _ikQuat: Quat[] = [
   new Quat(0, 0, 0, 1), new Quat(0, 0, 0, 1), new Quat(0, 0, 0, 1),
-  new Quat(0, 0, 0, 1), new Quat(0, 0, 0, 1), new Quat(0, 0, 0, 1),
 ]
 const _ikMat: Float32Array[] = [
   new Float32Array(16), new Float32Array(16), new Float32Array(16), new Float32Array(16),
@@ -215,7 +214,7 @@ export class IKSolverSystem {
     //   _ikVec[0]=chainPos, [1]=ikPos, [2]=targetPos, [3]=chainTargetVec, [4]=chainIkVec,
     //           [5]=rotAxis, [6]=finalAxis, [7]=eulerTmp, [8]=limitedEuler
     //   _ikMat[0]=parentRot, [1]=invParentRot, [2]=quatToMatTmp
-    //   _ikQuat[0]=ikRotation, [1]=combinedRot, [2]=localRotConj, [3..5]=axisAngleTmp
+    //   _ikQuat[0]=ikRotation, [1]=combinedRot, [2]=localRotConj
 
     const chainPos = Vec3.setFromMat4Translation(worldMatrices[chainBoneIndex].values, _ikVec[0])
     const ikPos = Vec3.setFromMat4Translation(worldMatrices[ikBoneIndex].values, _ikVec[1])
@@ -340,16 +339,8 @@ export class IKSolverSystem {
     return Math.sqrt(dx * dx + dy * dy + dz * dz)
   }
 
-  // Euler axis triples for each rotation order (indexed by order enum).
-  // Reused to avoid allocations in reconstructQuatFromEulerInto.
-  private static readonly EULER_AXES: readonly [number, number, number][][] = [
-    // YXZ: Y, X, Z
-    [[0, 1, 0], [1, 0, 0], [0, 0, 1]],
-    // ZYX: Z, Y, X
-    [[0, 0, 1], [0, 1, 0], [1, 0, 0]],
-    // XZY: X, Z, Y
-    [[1, 0, 0], [0, 0, 1], [0, 1, 0]],
-  ]
+  // Maps InternalEulerRotationOrder to the shared math-layer order names.
+  private static readonly EULER_ORDER_NAMES: readonly EulerOrder[] = ["YXZ", "ZYX", "XZY"]
 
   private static extractEulerAnglesInto(quat: Quat, order: InternalEulerRotationOrder, out: Vec3): void {
     Mat4.fromQuatInto(quat.x, quat.y, quat.z, quat.w, _ikMat[2], 0)
@@ -396,27 +387,7 @@ export class IKSolverSystem {
   }
 
   private static reconstructQuatFromEulerInto(euler: Vec3, order: InternalEulerRotationOrder, out: Quat): void {
-    const axes = this.EULER_AXES[order]
-    const a1 = axes[0], a2 = axes[1], a3 = axes[2]
-    const ang1 =
-      order === InternalEulerRotationOrder.YXZ ? euler.y
-      : order === InternalEulerRotationOrder.ZYX ? euler.z
-      : euler.x
-    const ang2 =
-      order === InternalEulerRotationOrder.YXZ ? euler.x
-      : order === InternalEulerRotationOrder.ZYX ? euler.y
-      : euler.z
-    const ang3 =
-      order === InternalEulerRotationOrder.YXZ ? euler.z
-      : order === InternalEulerRotationOrder.ZYX ? euler.x
-      : euler.y
-
-    // result = axisAngle(a1, ang1); then *= axisAngle(a2, ang2); then *= axisAngle(a3, ang3)
-    Quat.fromAxisAngleInto(a1[0], a1[1], a1[2], ang1, out)
-    Quat.fromAxisAngleInto(a2[0], a2[1], a2[2], ang2, _ikQuat[3])
-    Quat.multiplyInto(out, _ikQuat[3], out)
-    Quat.fromAxisAngleInto(a3[0], a3[1], a3[2], ang3, _ikQuat[3])
-    Quat.multiplyInto(out, _ikQuat[3], out)
+    Quat.fromEulerOrderInto(euler.x, euler.y, euler.z, this.EULER_ORDER_NAMES[order], out)
   }
 
   // Write parent's world rotation (translation stripped) into out Float32Array.

package/src/index.ts

@@ -53,7 +53,7 @@ export { STOCKINGS_GRAPH } from "./graph/presets/stockings"
 export { EYE_GRAPH } from "./graph/presets/eye"
 export { FACE_GRAPH } from "./graph/presets/face"
 export { Model } from "./model"
-export { Vec3, Quat, Mat4 } from "./math"
+export { Vec3, Quat, Mat4, easeInOut, type EulerOrder } from "./math"
 export type {
   AnimationClip,
   AnimationPlayOptions,
@@ -64,7 +64,12 @@ export type {
   BoneInterpolation,
   ControlPoint,
 } from "./animation"
-export { FPS } from "./animation"
+export {
+  FPS,
+  bezierInterpolate,
+  interpolateControlPoints,
+  rawInterpolationToBoneInterpolation,
+} from "./animation"
 export { VMDLoader, type CameraKeyframe, type IkFrame } from "./vmd-loader"
 export { CameraAnimation, type CameraPose } from "./camera-animation"
 export { RezePhysics } from "./physics"

package/src/math.ts

@@ -3,6 +3,10 @@ export function easeInOut(t: number): number {
   return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2
 }
 
+// Euler rotation order, read as intrinsic axes left to right:
+// "YXZ" = rotate about Y, then local X, then local Z (equals extrinsic ZXY — the MMD/PMX convention).
+export type EulerOrder = "XYZ" | "XZY" | "YXZ" | "YZX" | "ZXY" | "ZYX"
+
 export class Vec3 {
   x: number
   y: number
@@ -113,6 +117,18 @@ export class Vec3 {
     return out
   }
 
+  // out = (x, y, -z): right-handed Y-up ↔ left-handed Y-up (involutive). Safe when out === v.
+  static mirrorZInto(v: Vec3, out: Vec3): Vec3 {
+    out.x = v.x
+    out.y = v.y
+    out.z = -v.z
+    return out
+  }
+
+  static mirrorZ(v: Vec3): Vec3 {
+    return new Vec3(v.x, v.y, -v.z)
+  }
+
   // In-place normalize returning length squared info via Vec3. Alias for normalize() but explicit.
   normalizeInPlace(): Vec3 {
     return this.normalize()
@@ -333,6 +349,328 @@ export class Quat {
 
     return new Quat(x, y, z, w).normalize()
   }
+
+  // 4D dot product. Negative means a and b are on opposite hemispheres (same rotation
+  // when |dot| ≈ 1 either way — quaternion double cover).
+  static dot(a: Quat, b: Quat): number {
+    return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w
+  }
+
+  // Rotation angle between a and b in radians, insensitive to double cover.
+  static angleTo(a: Quat, b: Quat): number {
+    const d = Math.abs(a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w)
+    return 2 * Math.acos(Math.min(1, d))
+  }
+
+  // out = conjugate of q (inverse for unit quaternions), without mutating q. Safe when out === q.
+  static conjugateInto(q: Quat, out: Quat): Quat {
+    out.x = -q.x
+    out.y = -q.y
+    out.z = -q.z
+    out.w = q.w
+    return out
+  }
+
+  // out = normalized lerp from a to b, taking the shorter path (negates b when dot < 0).
+  // Cheaper than slerp; non-constant angular velocity. Safe when out === a or out === b.
+  static nlerpInto(a: Quat, b: Quat, t: number, out: Quat): Quat {
+    const d = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w
+    const s = d < 0 ? -1 : 1
+    const x = a.x + (b.x * s - a.x) * t
+    const y = a.y + (b.y * s - a.y) * t
+    const z = a.z + (b.z * s - a.z) * t
+    const w = a.w + (b.w * s - a.w) * t
+    const invLen = 1 / Math.hypot(x, y, z, w)
+    out.x = x * invLen
+    out.y = y * invLen
+    out.z = z * invLen
+    out.w = w * invLen
+    return out
+  }
+
+  static nlerp(a: Quat, b: Quat, t: number): Quat {
+    return Quat.nlerpInto(a, b, t, new Quat(0, 0, 0, 1))
+  }
+
+  // out = v rotated by unit quaternion q (no matrix, no allocation). Safe when out === v.
+  static rotateVecInto(q: Quat, v: Vec3, out: Vec3): Vec3 {
+    // v' = v + 2*qw*(qv × v) + 2*(qv × (qv × v))
+    const qx = q.x, qy = q.y, qz = q.z, qw = q.w
+    const vx = v.x, vy = v.y, vz = v.z
+    // t = 2 * (qv × v)
+    const tx = 2 * (qy * vz - qz * vy)
+    const ty = 2 * (qz * vx - qx * vz)
+    const tz = 2 * (qx * vy - qy * vx)
+    out.x = vx + qw * tx + qy * tz - qz * ty
+    out.y = vy + qw * ty + qz * tx - qx * tz
+    out.z = vz + qw * tz + qx * ty - qy * tx
+    return out
+  }
+
+  static rotateVec(q: Quat, v: Vec3): Vec3 {
+    return Quat.rotateVecInto(q, v, new Vec3(0, 0, 0))
+  }
+
+  // out = v rotated by the inverse (conjugate) of unit quaternion q. Safe when out === v.
+  static rotateVecInvInto(q: Quat, v: Vec3, out: Vec3): Vec3 {
+    const qx = -q.x, qy = -q.y, qz = -q.z, qw = q.w
+    const vx = v.x, vy = v.y, vz = v.z
+    const tx = 2 * (qy * vz - qz * vy)
+    const ty = 2 * (qz * vx - qx * vz)
+    const tz = 2 * (qx * vy - qy * vx)
+    out.x = vx + qw * tx + qy * tz - qz * ty
+    out.y = vy + qw * ty + qz * tx - qx * tz
+    out.z = vz + qw * tz + qx * ty - qy * tx
+    return out
+  }
+
+  static rotateVecInv(q: Quat, v: Vec3): Vec3 {
+    return Quat.rotateVecInvInto(q, v, new Vec3(0, 0, 0))
+  }
+
+  // out = shortest-arc rotation taking unit vector `from` to unit vector `to`.
+  // Matches Babylon's FromUnitVectorsToRef exactly, including the near-antiparallel
+  // branch (w = 1 + dot < 0.001 → 180° about a perpendicular picked the same way).
+  static fromUnitVectorsInto(from: Vec3, to: Vec3, out: Quat): Quat {
+    const r = from.x * to.x + from.y * to.y + from.z * to.z + 1
+    if (r < 0.001) {
+      if (Math.abs(from.x) > Math.abs(from.z)) {
+        out.setXYZW(-from.y, from.x, 0, 0)
+      } else {
+        out.setXYZW(0, -from.z, from.y, 0)
+      }
+    } else {
+      // q = (from × to, 1 + from·to)
+      out.setXYZW(
+        from.y * to.z - from.z * to.y,
+        from.z * to.x - from.x * to.z,
+        from.x * to.y - from.y * to.x,
+        r
+      )
+    }
+    const invLen = 1 / Math.sqrt(out.x * out.x + out.y * out.y + out.z * out.z + out.w * out.w)
+    out.setXYZW(out.x * invLen, out.y * invLen, out.z * invLen, out.w * invLen)
+    return out
+  }
+
+  static fromUnitVectors(from: Vec3, to: Vec3): Quat {
+    return Quat.fromUnitVectorsInto(from, to, new Quat(0, 0, 0, 1))
+  }
+
+  // out = rotation taking the standard basis onto the orthonormal axes x, y, z
+  // (the columns of the column-major rotation matrix): rotateVec(out, (1,0,0)) = x, etc.
+  static fromBasisInto(x: Vec3, y: Vec3, z: Vec3, out: Quat): Quat {
+    // Shepperd's method on the 3x3 with columns x, y, z.
+    const m00 = x.x, m01 = x.y, m02 = x.z
+    const m10 = y.x, m11 = y.y, m12 = y.z
+    const m20 = z.x, m21 = z.y, m22 = z.z
+    const trace = m00 + m11 + m22
+    if (trace > 0) {
+      const s = 0.5 / Math.sqrt(trace + 1)
+      out.setXYZW((m12 - m21) * s, (m20 - m02) * s, (m01 - m10) * s, 0.25 / s)
+    } else if (m00 > m11 && m00 > m22) {
+      const s = 2 * Math.sqrt(1 + m00 - m11 - m22)
+      out.setXYZW(0.25 * s, (m10 + m01) / s, (m20 + m02) / s, (m12 - m21) / s)
+    } else if (m11 > m22) {
+      const s = 2 * Math.sqrt(1 + m11 - m00 - m22)
+      out.setXYZW((m10 + m01) / s, 0.25 * s, (m21 + m12) / s, (m20 - m02) / s)
+    } else {
+      const s = 2 * Math.sqrt(1 + m22 - m00 - m11)
+      out.setXYZW((m20 + m02) / s, (m21 + m12) / s, 0.25 * s, (m01 - m10) / s)
+    }
+    return out
+  }
+
+  static fromBasis(x: Vec3, y: Vec3, z: Vec3): Quat {
+    return Quat.fromBasisInto(x, y, z, new Quat(0, 0, 0, 1))
+  }
+
+  // out = twist component of q around unit axis `a`, so that q = swing · twist
+  // (swing = Quat.multiply(q, conjugate(twist))). Singular when q is ~180° about an
+  // axis perpendicular to `a` — returns identity there.
+  static twistAroundAxisInto(q: Quat, a: Vec3, out: Quat): Quat {
+    const d = q.x * a.x + q.y * a.y + q.z * a.z
+    const px = a.x * d
+    const py = a.y * d
+    const pz = a.z * d
+    const len = Math.sqrt(px * px + py * py + pz * pz + q.w * q.w)
+    if (len < 1e-8) {
+      out.setIdentity()
+      return out
+    }
+    out.setXYZW(px / len, py / len, pz / len, q.w / len)
+    return out
+  }
+
+  static twistAroundAxis(q: Quat, a: Vec3): Quat {
+    return Quat.twistAroundAxisInto(q, a, new Quat(0, 0, 0, 1))
+  }
+
+  // out = orientation looking along `forward` (mapped to local +Z, the engine's LH forward)
+  // with local +Y toward `up`. Falls back to a reference up when forward ∥ up.
+  static lookRotationInto(forward: Vec3, up: Vec3, out: Quat): Quat {
+    let zx = forward.x, zy = forward.y, zz = forward.z
+    const zl = Math.sqrt(zx * zx + zy * zy + zz * zz)
+    if (zl === 0) return out.setIdentity()
+    const zi = 1 / zl
+    zx *= zi; zy *= zi; zz *= zi
+    // x = up × z
+    let xx = up.y * zz - up.z * zy
+    let xy = up.z * zx - up.x * zz
+    let xz = up.x * zy - up.y * zx
+    let xl = Math.sqrt(xx * xx + xy * xy + xz * xz)
+    if (xl < 1e-8) {
+      // forward ∥ up: substitute a reference up not parallel to forward
+      const uy = Math.abs(zy) < 0.99 ? 1 : 0
+      const ux = 1 - uy
+      xx = uy * zz
+      xy = -ux * zz
+      xz = ux * zy - uy * zx
+      xl = Math.sqrt(xx * xx + xy * xy + xz * xz)
+    }
+    const xi = 1 / xl
+    xx *= xi; xy *= xi; xz *= xi
+    // y = z × x (unit: z ⊥ x)
+    const yx = zy * xz - zz * xy
+    const yy = zz * xx - zx * xz
+    const yz = zx * xy - zy * xx
+    _lookX.setXYZ(xx, xy, xz)
+    _lookY.setXYZ(yx, yy, yz)
+    _lookZ.setXYZ(zx, zy, zz)
+    return Quat.fromBasisInto(_lookX, _lookY, _lookZ, out)
+  }
+
+  static lookRotation(forward: Vec3, up: Vec3): Quat {
+    return Quat.lookRotationInto(forward, up, new Quat(0, 0, 0, 1))
+  }
+
+  // out = q with the Z axis mirrored: right-handed Y-up ↔ left-handed Y-up
+  // (conjugation by the Z-mirror; involutive). Pairs with Vec3.mirrorZInto. Safe when out === q.
+  static mirrorZInto(q: Quat, out: Quat): Quat {
+    out.x = -q.x
+    out.y = -q.y
+    out.z = q.z
+    out.w = q.w
+    return out
+  }
+
+  static mirrorZ(q: Quat): Quat {
+    return new Quat(-q.x, -q.y, q.z, q.w)
+  }
+
+  // out = quaternion from euler angles (radians) applied in the given intrinsic order.
+  // fromEulerOrderInto(x, y, z, "YXZ", out) matches Quat.fromEuler (the MMD/PMX convention).
+  static fromEulerOrderInto(x: number, y: number, z: number, order: EulerOrder, out: Quat): Quat {
+    out.setIdentity()
+    for (let i = 0; i < 3; i++) {
+      const axis = order.charCodeAt(i) - 88 // "X" → 0, "Y" → 1, "Z" → 2
+      const angle = axis === 0 ? x : axis === 1 ? y : z
+      const half = angle * 0.5
+      const s = Math.sin(half)
+      const c = Math.cos(half)
+      const ax = out.x, ay = out.y, az = out.z, aw = out.w
+      if (axis === 0) {
+        out.x = aw * s + ax * c
+        out.y = ay * c + az * s
+        out.z = az * c - ay * s
+        out.w = aw * c - ax * s
+      } else if (axis === 1) {
+        out.x = ax * c - az * s
+        out.y = aw * s + ay * c
+        out.z = az * c + ax * s
+        out.w = aw * c - ay * s
+      } else {
+        out.x = ax * c + ay * s
+        out.y = ay * c - ax * s
+        out.z = aw * s + az * c
+        out.w = aw * c - az * s
+      }
+    }
+    return out
+  }
+
+  static fromEulerOrder(x: number, y: number, z: number, order: EulerOrder): Quat {
+    return Quat.fromEulerOrderInto(x, y, z, order, new Quat(0, 0, 0, 1))
+  }
+
+  // Extract euler angles (radians) in the given intrinsic order into out (out.x/y/z = rotation
+  // about X/Y/Z). At gimbal lock (middle angle ±90°) the split between first and third angle is
+  // ambiguous; the third is set to 0.
+  static toEulerOrderInto(q: Quat, order: EulerOrder, out: Vec3): Vec3 {
+    Mat4.fromQuatInto(q.x, q.y, q.z, q.w, _eulerMat, 0)
+    const m = _eulerMat
+    const m11 = m[0], m12 = m[4], m13 = m[8]
+    const m21 = m[1], m22 = m[5], m23 = m[9]
+    const m31 = m[2], m32 = m[6], m33 = m[10]
+    const clamp = (v: number) => (v < -1 ? -1 : v > 1 ? 1 : v)
+    switch (order) {
+      case "XYZ":
+        out.y = Math.asin(clamp(m13))
+        if (Math.abs(m13) < 0.9999999) {
+          out.x = Math.atan2(-m23, m33)
+          out.z = Math.atan2(-m12, m11)
+        } else {
+          out.x = Math.atan2(m32, m22)
+          out.z = 0
+        }
+        break
+      case "YXZ":
+        out.x = Math.asin(-clamp(m23))
+        if (Math.abs(m23) < 0.9999999) {
+          out.y = Math.atan2(m13, m33)
+          out.z = Math.atan2(m21, m22)
+        } else {
+          out.y = Math.atan2(-m31, m11)
+          out.z = 0
+        }
+        break
+      case "ZXY":
+        out.x = Math.asin(clamp(m32))
+        if (Math.abs(m32) < 0.9999999) {
+          out.y = Math.atan2(-m31, m33)
+          out.z = Math.atan2(-m12, m22)
+        } else {
+          out.y = 0
+          out.z = Math.atan2(m21, m11)
+        }
+        break
+      case "ZYX":
+        out.y = Math.asin(-clamp(m31))
+        if (Math.abs(m31) < 0.9999999) {
+          out.x = Math.atan2(m32, m33)
+          out.z = Math.atan2(m21, m11)
+        } else {
+          out.x = 0
+          out.z = Math.atan2(-m12, m22)
+        }
+        break
+      case "YZX":
+        out.z = Math.asin(clamp(m21))
+        if (Math.abs(m21) < 0.9999999) {
+          out.x = Math.atan2(-m23, m22)
+          out.y = Math.atan2(-m31, m11)
+        } else {
+          out.x = 0
+          out.y = Math.atan2(m13, m33)
+        }
+        break
+      case "XZY":
+        out.z = Math.asin(-clamp(m12))
+        if (Math.abs(m12) < 0.9999999) {
+          out.x = Math.atan2(m32, m22)
+          out.y = Math.atan2(m13, m11)
+        } else {
+          out.x = Math.atan2(-m23, m33)
+          out.y = 0
+        }
+        break
+    }
+    return out
+  }
+
+  static toEulerOrder(q: Quat, order: EulerOrder): Vec3 {
+    return Quat.toEulerOrderInto(q, order, new Vec3(0, 0, 0))
+  }
 }
 
 export class Mat4 {
@@ -837,6 +1175,13 @@ export class Mat4 {
   }
 }
 
+// Module-private scratch for Quat.toEulerOrderInto / lookRotationInto (never handed out,
+// so no cross-call stomping with the public pools below).
+const _eulerMat = new Float32Array(16)
+const _lookX = new Vec3(0, 0, 0)
+const _lookY = new Vec3(0, 0, 0)
+const _lookZ = new Vec3(0, 0, 0)
+
 // Preallocated scratch instances for hot paths. Each subsystem should use its own
 // slot to avoid cross-call stomping. Bump the count if more call sites need scratch.
 export const scratchMat4Values: Float32Array[] = [