loomlarge 0.2.0 → 0.2.5

package/dist/index.cjs

@@ -245,7 +245,7 @@ var VISEME_KEYS = [
 ];
 var BONE_AU_TO_BINDINGS = {
   // Head turn and tilt (M51-M56) - use HEAD bone only (NECK should not rotate with head)
-  // Three.js Y rotation: positive = counter-clockwise from above = head turns LEFT (character POV)
+  // Axis is derived from COMPOSITE_ROTATIONS, not stored here
   51: [
     { node: "HEAD", channel: "ry", scale: 1, maxDegrees: 30 }
     // Head turn left
@@ -270,7 +270,7 @@ var BONE_AU_TO_BINDINGS = {
     { node: "HEAD", channel: "rz", scale: 1, maxDegrees: 15 }
     // Head tilt right
   ],
-  // Eyes horizontal (yaw) - CC4 rigs use rz for horizontal eye rotation
+  // Eyes - CC4 rigs use rz for horizontal, rx for vertical
   61: [
     { node: "EYE_L", channel: "rz", scale: 1, maxDegrees: 32 },
     // Eyes look left
@@ -283,45 +283,47 @@ var BONE_AU_TO_BINDINGS = {
   ],
   63: [
     { node: "EYE_L", channel: "rx", scale: -1, maxDegrees: 32 },
+    // Eyes Up
     { node: "EYE_R", channel: "rx", scale: -1, maxDegrees: 32 }
   ],
   64: [
     { node: "EYE_L", channel: "rx", scale: 1, maxDegrees: 32 },
+    // Eyes Down
     { node: "EYE_R", channel: "rx", scale: 1, maxDegrees: 32 }
   ],
   // Single-eye (Left) — horizontal (rz for CC4) and vertical (rx)
   65: [{ node: "EYE_L", channel: "rz", scale: -1, maxDegrees: 15 }],
   66: [{ node: "EYE_L", channel: "rz", scale: 1, maxDegrees: 15 }],
   67: [{ node: "EYE_L", channel: "rx", scale: -1, maxDegrees: 12 }],
+  // Left Eye Up
   68: [{ node: "EYE_L", channel: "rx", scale: 1, maxDegrees: 12 }],
+  // Left Eye Down
   // Single-eye (Right) — horizontal (rz for CC4) and vertical (rx)
   69: [{ node: "EYE_R", channel: "rz", scale: -1, maxDegrees: 15 }],
   70: [{ node: "EYE_R", channel: "rz", scale: 1, maxDegrees: 15 }],
   71: [{ node: "EYE_R", channel: "rx", scale: -1, maxDegrees: 12 }],
+  // Right Eye Up
   72: [{ node: "EYE_R", channel: "rx", scale: 1, maxDegrees: 12 }],
+  // Right Eye Down
   // Jaw / Mouth
   8: [
     // Lips Toward Each Other - slight jaw open helps sell the lip press
     { node: "JAW", channel: "rz", scale: 1, maxDegrees: 8 }
-    // Small downward rotation (jaw opening slightly)
   ],
   25: [
     // Lips Part — small jaw open
     { node: "JAW", channel: "rz", scale: 1, maxDegrees: 5.84 }
-    // 73% of 8
   ],
   26: [
     { node: "JAW", channel: "rz", scale: 1, maxDegrees: 28 }
-    // 73% of 20
   ],
   27: [
     // Mouth Stretch — larger jaw open
     { node: "JAW", channel: "rz", scale: 1, maxDegrees: 32 }
-    // 73% of 25
   ],
   29: [
     { node: "JAW", channel: "tz", scale: -1, maxUnits: 0.02 }
-    // Negative for forward thrust
+    // Translation
   ],
   30: [
     // Jaw Left
@@ -334,6 +336,7 @@ var BONE_AU_TO_BINDINGS = {
   // Tongue
   19: [
     { node: "TONGUE", channel: "tz", scale: -1, maxUnits: 8e-3 }
+    // Translation
   ],
   37: [
     // Tongue Up
@@ -413,7 +416,7 @@ var COMPOSITE_ROTATIONS = [
   }
 ];
 var CONTINUUM_PAIRS_MAP = {
-  // Eyes horizontal (yaw) - both eyes share same AUs
+  // Eyes horizontal - both eyes share same AUs (yaw maps to rz via COMPOSITE_ROTATIONS)
   61: { pairId: 62, isNegative: true, axis: "yaw", node: "EYE_L" },
   62: { pairId: 61, isNegative: false, axis: "yaw", node: "EYE_L" },
   // Eyes vertical (pitch)
@@ -650,6 +653,25 @@ var CC4_PRESET = {
 
 // src/engines/three/LoomLargeThree.ts
 var deg2rad = (d) => d * Math.PI / 180;
+var X_AXIS = new three.Vector3(1, 0, 0);
+var Y_AXIS = new three.Vector3(0, 1, 0);
+var Z_AXIS = new three.Vector3(0, 0, 1);
+var AU_TO_COMPOSITE_MAP = /* @__PURE__ */ new Map();
+COMPOSITE_ROTATIONS.forEach((comp) => {
+  ["pitch", "yaw", "roll"].forEach((axisName) => {
+    const axisConfig = comp[axisName];
+    if (axisConfig) {
+      axisConfig.aus.forEach((auId) => {
+        const existing = AU_TO_COMPOSITE_MAP.get(auId);
+        if (existing) {
+          existing.nodes.push(comp.node);
+        } else {
+          AU_TO_COMPOSITE_MAP.set(auId, { nodes: [comp.node], axis: axisName });
+        }
+      });
+    }
+  });
+});
 function clamp01(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
@@ -795,13 +817,31 @@ var _LoomLargeThree = class _LoomLargeThree {
         this.setMorph(k, base, meshNames);
       }
     }
+    const compositeInfo = AU_TO_COMPOSITE_MAP.get(id);
+    if (compositeInfo) {
+      for (const nodeKey of compositeInfo.nodes) {
+        const config = COMPOSITE_ROTATIONS.find((c) => c.node === nodeKey);
+        if (!config) continue;
+        const axisConfig = config[compositeInfo.axis];
+        if (!axisConfig) continue;
+        let axisValue;
+        if (axisConfig.negative !== void 0 && axisConfig.positive !== void 0) {
+          const negValue = this.auValues[axisConfig.negative] ?? 0;
+          const posValue = this.auValues[axisConfig.positive] ?? 0;
+          axisValue = posValue - negValue;
+        } else if (axisConfig.aus.length > 1) {
+          axisValue = Math.max(...axisConfig.aus.map((auId) => this.auValues[auId] ?? 0));
+        } else {
+          axisValue = v;
+        }
+        this.updateBoneRotation(nodeKey, compositeInfo.axis, axisValue);
+        this.pendingCompositeNodes.add(nodeKey);
+      }
+    }
     const bindings = this.config.auToBones[id];
     if (bindings) {
       for (const binding of bindings) {
-        if (binding.channel === "rx" || binding.channel === "ry" || binding.channel === "rz") {
-          const axis = binding.channel === "rx" ? "pitch" : binding.channel === "ry" ? "yaw" : "roll";
-          this.updateBoneRotation(binding.node, axis, v * binding.scale, binding.maxDegrees ?? 0);
-        } else if (binding.channel === "tx" || binding.channel === "ty" || binding.channel === "tz") {
+        if (binding.channel === "tx" || binding.channel === "ty" || binding.channel === "tz") {
           if (binding.maxUnits !== void 0) {
             this.updateBoneTranslation(binding.node, binding.channel, v * binding.scale, binding.maxUnits);
           }
@@ -836,11 +876,28 @@ var _LoomLargeThree = class _LoomLargeThree {
     for (const k of centerKeys) {
       handles.push(this.transitionMorph(k, base, durationMs, meshNames));
     }
+    const compositeInfo = AU_TO_COMPOSITE_MAP.get(numId);
+    if (compositeInfo) {
+      for (const nodeKey of compositeInfo.nodes) {
+        const config = COMPOSITE_ROTATIONS.find((c) => c.node === nodeKey);
+        if (!config) continue;
+        const axisConfig = config[compositeInfo.axis];
+        if (!axisConfig) continue;
+        let axisValue;
+        if (axisConfig.negative !== void 0 && axisConfig.positive !== void 0) {
+          const negValue = this.auValues[axisConfig.negative] ?? 0;
+          const posValue = this.auValues[axisConfig.positive] ?? 0;
+          axisValue = posValue - negValue;
+        } else if (axisConfig.aus.length > 1) {
+          axisValue = Math.max(...axisConfig.aus.map((auId) => this.auValues[auId] ?? 0));
+        } else {
+          axisValue = target;
+        }
+        handles.push(this.transitionBoneRotation(nodeKey, compositeInfo.axis, axisValue, durationMs));
+      }
+    }
     for (const binding of bindings) {
-      if (binding.channel === "rx" || binding.channel === "ry" || binding.channel === "rz") {
-        const axis = binding.channel === "rx" ? "pitch" : binding.channel === "ry" ? "yaw" : "roll";
-        handles.push(this.transitionBoneRotation(binding.node, axis, target * binding.scale, binding.maxDegrees ?? 0, durationMs));
-      } else if (binding.channel === "tx" || binding.channel === "ty" || binding.channel === "tz") {
+      if (binding.channel === "tx" || binding.channel === "ty" || binding.channel === "tz") {
         if (binding.maxUnits !== void 0) {
           handles.push(this.transitionBoneTranslation(binding.node, binding.channel, target * binding.scale, binding.maxUnits, durationMs));
         }
@@ -852,10 +909,53 @@ var _LoomLargeThree = class _LoomLargeThree {
     return this.auValues[id] ?? 0;
   }
   // ============================================================================
-  // MORPH CONTROL
+  // CONTINUUM CONTROL (for paired AUs like eyes left/right, head up/down)
   // ============================================================================
-  setMorph(key, v, meshNames) {
+  /**
+   * Set a continuum AU pair immediately (no animation).
+   *
+   * Sign convention:
+   * - Negative value (-1 to 0): activates negAU (e.g., head left, eyes left)
+   * - Positive value (0 to +1): activates posAU (e.g., head right, eyes right)
+   *
+   * @param negAU - AU ID for negative direction (e.g., 61 for eyes left)
+   * @param posAU - AU ID for positive direction (e.g., 62 for eyes right)
+   * @param continuumValue - Value from -1 (full negative) to +1 (full positive)
+   */
+  setContinuum(negAU, posAU, continuumValue) {
+    const value = Math.max(-1, Math.min(1, continuumValue));
+    const negVal = value < 0 ? Math.abs(value) : 0;
+    const posVal = value > 0 ? value : 0;
+    this.setAU(negAU, negVal);
+    this.setAU(posAU, posVal);
+  }
+  /**
+   * Smoothly transition a continuum AU pair (e.g., eyes left/right, head up/down).
+   * Takes a continuum value from -1 to +1 and internally manages both AU values.
+   *
+   * @param negAU - AU ID for negative direction (e.g., 61 for eyes left)
+   * @param posAU - AU ID for positive direction (e.g., 62 for eyes right)
+   * @param continuumValue - Target value from -1 (full negative) to +1 (full positive)
+   * @param durationMs - Transition duration in milliseconds
+   */
+  transitionContinuum(negAU, posAU, continuumValue, durationMs = 200) {
+    const target = Math.max(-1, Math.min(1, continuumValue));
+    const driverKey = `continuum_${negAU}_${posAU}`;
+    const currentNeg = this.auValues[negAU] ?? 0;
+    const currentPos = this.auValues[posAU] ?? 0;
+    const currentContinuum = currentPos - currentNeg;
+    return this.animation.addTransition(driverKey, currentContinuum, target, durationMs, (value) => this.setContinuum(negAU, posAU, value));
+  }
+  setMorph(key, v, meshNamesOrTargets) {
     const val = clamp01(v);
+    if (Array.isArray(meshNamesOrTargets) && meshNamesOrTargets.length > 0 && typeof meshNamesOrTargets[0] === "object" && "infl" in meshNamesOrTargets[0]) {
+      const targets2 = meshNamesOrTargets;
+      for (const target of targets2) {
+        target.infl[target.idx] = val;
+      }
+      return;
+    }
+    const meshNames = meshNamesOrTargets;
     const targetMeshes = meshNames || this.config.morphToMesh?.face || [];
     const cached = this.morphCache.get(key);
     if (cached) {
@@ -894,11 +994,54 @@ var _LoomLargeThree = class _LoomLargeThree {
       this.morphCache.set(key, targets);
     }
   }
+  /**
+   * Resolve morph key to direct targets for ultra-fast repeated access.
+   * Use this when you need to set the same morph many times (e.g., in animation loops).
+   */
+  resolveMorphTargets(key, meshNames) {
+    const cached = this.morphCache.get(key);
+    if (cached) return cached;
+    const targetMeshes = meshNames || this.config.morphToMesh?.face || [];
+    const targets = [];
+    if (targetMeshes.length) {
+      for (const name of targetMeshes) {
+        const mesh = this.meshByName.get(name);
+        if (!mesh) continue;
+        const dict = mesh.morphTargetDictionary;
+        const infl = mesh.morphTargetInfluences;
+        if (!dict || !infl) continue;
+        const idx = dict[key];
+        if (idx !== void 0) {
+          targets.push({ infl, idx });
+        }
+      }
+    } else {
+      for (const mesh of this.meshes) {
+        const dict = mesh.morphTargetDictionary;
+        const infl = mesh.morphTargetInfluences;
+        if (!dict || !infl) continue;
+        const idx = dict[key];
+        if (idx !== void 0) {
+          targets.push({ infl, idx });
+        }
+      }
+    }
+    if (targets.length > 0) {
+      this.morphCache.set(key, targets);
+    }
+    return targets;
+  }
   transitionMorph(key, to, durationMs = 120, meshNames) {
     const transitionKey = `morph_${key}`;
     const from = this.getMorphValue(key);
     const target = clamp01(to);
-    return this.animation.addTransition(transitionKey, from, target, durationMs, (value) => this.setMorph(key, value, meshNames));
+    const targets = this.resolveMorphTargets(key, meshNames);
+    return this.animation.addTransition(transitionKey, from, target, durationMs, (value) => {
+      const val = clamp01(value);
+      for (const t of targets) {
+        t.infl[t.idx] = val;
+      }
+    });
   }
   // ============================================================================
   // VISEME CONTROL
@@ -911,7 +1054,7 @@ var _LoomLargeThree = class _LoomLargeThree {
     this.setMorph(morphKey, val);
     const jawAmount = _LoomLargeThree.VISEME_JAW_AMOUNTS[visemeIndex] * val * jawScale;
     if (Math.abs(jawScale) > 1e-6 && Math.abs(jawAmount) > 1e-6) {
-      this.updateBoneRotation("JAW", "roll", jawAmount, _LoomLargeThree.JAW_MAX_DEGREES);
+      this.updateBoneRotation("JAW", "pitch", jawAmount);
     }
   }
   transitionViseme(visemeIndex, to, durationMs = 80, jawScale = 1) {
@@ -929,7 +1072,7 @@ var _LoomLargeThree = class _LoomLargeThree {
     if (Math.abs(jawScale) <= 1e-6 || Math.abs(jawAmount) <= 1e-6) {
       return morphHandle;
     }
-    const jawHandle = this.transitionBoneRotation("JAW", "roll", jawAmount, _LoomLargeThree.JAW_MAX_DEGREES, durationMs);
+    const jawHandle = this.transitionBoneRotation("JAW", "pitch", jawAmount, durationMs);
     return this.combineHandles([morphHandle, jawHandle]);
   }
   // ============================================================================
@@ -992,15 +1135,44 @@ var _LoomLargeThree = class _LoomLargeThree {
     const result = [];
     this.model.traverse((obj) => {
       if (obj.isMesh) {
+        const meshInfo = CC4_MESHES[obj.name];
         result.push({
           name: obj.name,
           visible: obj.visible,
-          morphCount: obj.morphTargetInfluences?.length || 0
+          morphCount: obj.morphTargetInfluences?.length || 0,
+          category: meshInfo?.category || "other"
         });
       }
     });
     return result;
   }
+  /** Get all morph targets grouped by mesh name */
+  getMorphTargets() {
+    const result = {};
+    for (const mesh of this.meshes) {
+      const dict = mesh.morphTargetDictionary;
+      if (dict) {
+        result[mesh.name] = Object.keys(dict).sort();
+      }
+    }
+    return result;
+  }
+  /** Get all resolved bone names and their current transforms */
+  getBones() {
+    const result = {};
+    for (const name of Object.keys(this.bones)) {
+      const entry = this.bones[name];
+      if (entry) {
+        const pos = entry.obj.position;
+        const rot = entry.obj.rotation;
+        result[name] = {
+          position: [pos.x, pos.y, pos.z],
+          rotation: [rot.x * 180 / Math.PI, rot.y * 180 / Math.PI, rot.z * 180 / Math.PI]
+        };
+      }
+    }
+    return result;
+  }
   setMeshVisible(meshName, visible) {
     if (!this.model) return;
     this.model.traverse((obj) => {
@@ -1009,6 +1181,70 @@ var _LoomLargeThree = class _LoomLargeThree {
       }
     });
   }
+  /** Get material config for a mesh */
+  getMeshMaterialConfig(meshName) {
+    if (!this.model) return null;
+    let result = null;
+    this.model.traverse((obj) => {
+      if (obj.isMesh && obj.name === meshName) {
+        const mat = obj.material;
+        if (mat) {
+          let blendingName = "Normal";
+          for (const [name, value] of Object.entries(_LoomLargeThree.BLENDING_MODES)) {
+            if (mat.blending === value) {
+              blendingName = name;
+              break;
+            }
+          }
+          result = {
+            renderOrder: obj.renderOrder,
+            transparent: mat.transparent,
+            opacity: mat.opacity,
+            depthWrite: mat.depthWrite,
+            depthTest: mat.depthTest,
+            blending: blendingName
+          };
+        }
+      }
+    });
+    return result;
+  }
+  /** Set material config for a mesh */
+  setMeshMaterialConfig(meshName, config) {
+    if (!this.model) return;
+    this.model.traverse((obj) => {
+      if (obj.isMesh && obj.name === meshName) {
+        const mat = obj.material;
+        if (config.renderOrder !== void 0) {
+          obj.renderOrder = config.renderOrder;
+        }
+        if (mat) {
+          if (config.opacity !== void 0) {
+            mat.opacity = config.opacity;
+            if (config.opacity < 1 && config.transparent === void 0) {
+              mat.transparent = true;
+            }
+          }
+          if (config.transparent !== void 0) {
+            mat.transparent = config.transparent;
+          }
+          if (config.depthWrite !== void 0) {
+            mat.depthWrite = config.depthWrite;
+          }
+          if (config.depthTest !== void 0) {
+            mat.depthTest = config.depthTest;
+          }
+          if (config.blending !== void 0) {
+            const blendValue = _LoomLargeThree.BLENDING_MODES[config.blending];
+            if (blendValue !== void 0) {
+              mat.blending = blendValue;
+            }
+          }
+          mat.needsUpdate = true;
+        }
+      }
+    });
+  }
   // ============================================================================
   // CONFIGURATION
   // ============================================================================
@@ -1063,20 +1299,20 @@ var _LoomLargeThree = class _LoomLargeThree {
     return !!(this.config.auToMorphs[id]?.length && this.config.auToBones[id]?.length);
   }
   initBoneRotations() {
-    const zeroAxis = { value: 0, maxRadians: 0 };
     this.rotations = {};
     this.pendingCompositeNodes.clear();
     const allBoneKeys = Array.from(
       new Set(Object.values(this.config.auToBones).flat().map((binding) => binding.node))
     );
     for (const node of allBoneKeys) {
-      this.rotations[node] = { pitch: { ...zeroAxis }, yaw: { ...zeroAxis }, roll: { ...zeroAxis } };
+      this.rotations[node] = { pitch: 0, yaw: 0, roll: 0 };
       this.pendingCompositeNodes.add(node);
     }
   }
-  updateBoneRotation(nodeKey, axis, value, maxDegrees) {
+  /** Update rotation state - just stores -1 to 1 value like stable version */
+  updateBoneRotation(nodeKey, axis, value) {
     if (!this.rotations[nodeKey]) return;
-    this.rotations[nodeKey][axis] = { value: Math.max(-1, Math.min(1, value)), maxRadians: deg2rad(maxDegrees) };
+    this.rotations[nodeKey][axis] = Math.max(-1, Math.min(1, value));
     this.pendingCompositeNodes.add(nodeKey);
   }
   updateBoneTranslation(nodeKey, channel, value, maxUnits) {
@@ -1088,11 +1324,11 @@ var _LoomLargeThree = class _LoomLargeThree {
     else this.translations[nodeKey].z = offset;
     this.pendingCompositeNodes.add(nodeKey);
   }
-  transitionBoneRotation(nodeKey, axis, to, maxDegrees, durationMs = 200) {
+  transitionBoneRotation(nodeKey, axis, to, durationMs = 200) {
     const transitionKey = `bone_${nodeKey}_${axis}`;
-    const from = this.rotations[nodeKey]?.[axis]?.value ?? 0;
+    const from = this.rotations[nodeKey]?.[axis] ?? 0;
     const target = Math.max(-1, Math.min(1, to));
-    return this.animation.addTransition(transitionKey, from, target, durationMs, (value) => this.updateBoneRotation(nodeKey, axis, value, maxDegrees));
+    return this.animation.addTransition(transitionKey, from, target, durationMs, (value) => this.updateBoneRotation(nodeKey, axis, value));
   }
   transitionBoneTranslation(nodeKey, channel, to, maxUnits, durationMs = 200) {
     const transitionKey = `boneT_${nodeKey}_${channel}`;
@@ -1109,6 +1345,10 @@ var _LoomLargeThree = class _LoomLargeThree {
     }
     this.pendingCompositeNodes.clear();
   }
+  /**
+   * Apply composite rotation using quaternion composition like stable version.
+   * Looks up maxDegrees and channel from BONE_AU_TO_BINDINGS.
+   */
   applyCompositeRotation(nodeKey) {
     const entry = this.bones[nodeKey];
     if (!entry || !this.model) {
@@ -1117,12 +1357,60 @@ var _LoomLargeThree = class _LoomLargeThree {
       }
       return;
     }
-    const { obj, basePos, baseEuler } = entry;
+    const { obj, basePos, baseQuat } = entry;
     const rotState = this.rotations[nodeKey];
     if (!rotState) return;
-    const yawRad = rotState.yaw.maxRadians * rotState.yaw.value;
-    const pitchRad = rotState.pitch.maxRadians * rotState.pitch.value;
-    const rollRad = rotState.roll.maxRadians * rotState.roll.value;
+    const config = COMPOSITE_ROTATIONS.find((c) => c.node === nodeKey);
+    if (!config) return;
+    const getBindingForAxis = (axisConfig, direction) => {
+      if (!axisConfig) return null;
+      if (axisConfig.negative !== void 0 && axisConfig.positive !== void 0) {
+        const auId = direction < 0 ? axisConfig.negative : axisConfig.positive;
+        return BONE_AU_TO_BINDINGS[auId]?.find((b) => b.node === nodeKey);
+      }
+      if (axisConfig.aus.length > 1) {
+        let maxAU = axisConfig.aus[0];
+        let maxValue = this.auValues[maxAU] ?? 0;
+        for (const auId of axisConfig.aus) {
+          const val = this.auValues[auId] ?? 0;
+          if (val > maxValue) {
+            maxValue = val;
+            maxAU = auId;
+          }
+        }
+        return BONE_AU_TO_BINDINGS[maxAU]?.find((b) => b.node === nodeKey);
+      }
+      return BONE_AU_TO_BINDINGS[axisConfig.aus[0]]?.find((b) => b.node === nodeKey);
+    };
+    const getAxis = (channel) => channel === "rx" ? X_AXIS : channel === "ry" ? Y_AXIS : Z_AXIS;
+    const compositeQ = new three.Quaternion().copy(baseQuat);
+    if (config.yaw && rotState.yaw !== 0) {
+      const binding = getBindingForAxis(config.yaw, rotState.yaw);
+      if (binding?.maxDegrees && binding.channel) {
+        const radians = deg2rad(binding.maxDegrees) * Math.abs(rotState.yaw) * binding.scale;
+        const axis = getAxis(binding.channel);
+        const deltaQ = new three.Quaternion().setFromAxisAngle(axis, radians);
+        compositeQ.multiply(deltaQ);
+      }
+    }
+    if (config.pitch && rotState.pitch !== 0) {
+      const binding = getBindingForAxis(config.pitch, rotState.pitch);
+      if (binding?.maxDegrees && binding.channel) {
+        const radians = deg2rad(binding.maxDegrees) * Math.abs(rotState.pitch) * binding.scale;
+        const axis = getAxis(binding.channel);
+        const deltaQ = new three.Quaternion().setFromAxisAngle(axis, radians);
+        compositeQ.multiply(deltaQ);
+      }
+    }
+    if (config.roll && rotState.roll !== 0) {
+      const binding = getBindingForAxis(config.roll, rotState.roll);
+      if (binding?.maxDegrees && binding.channel) {
+        const radians = deg2rad(binding.maxDegrees) * Math.abs(rotState.roll) * binding.scale;
+        const axis = getAxis(binding.channel);
+        const deltaQ = new three.Quaternion().setFromAxisAngle(axis, radians);
+        compositeQ.multiply(deltaQ);
+      }
+    }
     obj.position.copy(basePos);
     const t = this.translations[nodeKey];
     if (t) {
@@ -1130,7 +1418,7 @@ var _LoomLargeThree = class _LoomLargeThree {
       obj.position.y += t.y;
       obj.position.z += t.z;
     }
-    obj.rotation.set(baseEuler.x + pitchRad, baseEuler.y + yawRad, baseEuler.z + rollRad, baseEuler.order);
+    obj.quaternion.copy(compositeQ);
     obj.updateMatrixWorld(false);
     this.model.updateMatrixWorld(true);
   }
@@ -1200,6 +1488,13 @@ var _LoomLargeThree = class _LoomLargeThree {
         if (typeof settings.depthTest === "boolean") {
           obj.material.depthTest = settings.depthTest;
         }
+        if (typeof settings.blending === "string") {
+          const blendValue = _LoomLargeThree.BLENDING_MODES[settings.blending];
+          if (blendValue !== void 0) {
+            obj.material.blending = blendValue;
+          }
+        }
+        obj.material.needsUpdate = true;
       }
     });
   }
@@ -1223,6 +1518,19 @@ __publicField(_LoomLargeThree, "VISEME_JAW_AMOUNTS", [
   0.4
 ]);
 __publicField(_LoomLargeThree, "JAW_MAX_DEGREES", 28);
+/** Blending mode options for Three.js materials */
+__publicField(_LoomLargeThree, "BLENDING_MODES", {
+  "Normal": 1,
+  // THREE.NormalBlending
+  "Additive": 2,
+  // THREE.AdditiveBlending
+  "Subtractive": 3,
+  // THREE.SubtractiveBlending
+  "Multiply": 4,
+  // THREE.MultiplyBlending
+  "None": 0
+  // THREE.NoBlending
+});
 var LoomLargeThree = _LoomLargeThree;
 function collectMorphMeshes(root) {
   const meshes = [];
@@ -1236,6 +1544,20 @@ function collectMorphMeshes(root) {
   return meshes;
 }
 
+// src/mappings/types.ts
+var BLENDING_MODES = {
+  "Normal": 1,
+  // THREE.NormalBlending
+  "Additive": 2,
+  // THREE.AdditiveBlending
+  "Subtractive": 3,
+  // THREE.SubtractiveBlending
+  "Multiply": 4,
+  // THREE.MultiplyBlending
+  "None": 0
+  // THREE.NoBlending
+};
+
 // src/physics/HairPhysics.ts
 var DEFAULT_HAIR_PHYSICS_CONFIG = {
   mass: 1,
@@ -1364,6 +1686,7 @@ exports.AU_INFO = AU_INFO;
 exports.AU_MIX_DEFAULTS = AU_MIX_DEFAULTS;
 exports.AU_TO_MORPHS = AU_TO_MORPHS;
 exports.AnimationThree = AnimationThree;
+exports.BLENDING_MODES = BLENDING_MODES;
 exports.BONE_AU_TO_BINDINGS = BONE_AU_TO_BINDINGS;
 exports.CC4_BONE_NODES = CC4_BONE_NODES;
 exports.CC4_EYE_MESH_NODES = CC4_EYE_MESH_NODES;