@nice2dev/game-engine 1.3.15 → 1.3.16

package/dist/esm/native-engine/AnimationSystem.js

@@ -1,835 +1,765 @@
-/**
- * @file AnimationSystem.ts
- * @description Animation System for Nice2Dev Game Engine
- * PRO-1.11.4: Animation System
- *
- * Features:
- * - Skeletal animation
- * - Blend trees
- * - Animation state machine
- * - Inverse Kinematics (IK)
- * - Procedural animation
- * - Morph targets
- * - Animation events
- */
-// ============================================================
-// Animator Controller
-// ============================================================
 class AnimatorController {
-    constructor(boneDescriptors) {
-        this.clips = new Map();
-        this.layers = [];
-        this.stateMachine = null;
-        this.parameters = new Map();
-        this.ikChains = new Map();
-        this.morphTargets = null;
-        this.eventCallbacks = new Map();
-        this.skeleton = new SkeletonImpl(boneDescriptors);
-    }
-    // ─── Clips ─────────────────────────────────────────────
-    addClip(descriptor) {
-        const clip = new AnimationClipImpl(descriptor);
-        this.clips.set(descriptor.name, clip);
-        return clip;
-    }
-    getClip(name) {
-        return this.clips.get(name);
-    }
-    removeClip(name) {
-        this.clips.delete(name);
-    }
-    // ─── Layers ────────────────────────────────────────────
-    addLayer(descriptor) {
-        const layer = new AnimationLayerImpl(descriptor, this.skeleton, this.clips, this.parameters);
-        this.layers.push(layer);
-        return layer;
-    }
-    getLayer(nameOrIndex) {
-        if (typeof nameOrIndex === 'number') {
-            return this.layers[nameOrIndex];
-        }
-        return this.layers.find((l) => l.name === nameOrIndex);
-    }
-    getLayerCount() {
-        return this.layers.length;
-    }
-    // ─── State Machine ─────────────────────────────────────
-    createStateMachine(descriptor) {
-        this.stateMachine = new AnimationStateMachine(descriptor, this.clips, this.parameters);
-        // Initialize parameters
-        if (descriptor.parameters) {
-            for (const param of descriptor.parameters) {
-                this.parameters.set(param.name, param.defaultValue ?? (param.type === 'bool' || param.type === 'trigger' ? false : 0));
-            }
-        }
-        return this.stateMachine;
-    }
-    getStateMachine() {
-        return this.stateMachine;
-    }
-    // ─── Parameters ────────────────────────────────────────
-    setFloat(name, value) {
-        this.parameters.set(name, value);
-    }
-    getFloat(name) {
-        return this.parameters.get(name) ?? 0;
-    }
-    setInt(name, value) {
-        this.parameters.set(name, Math.floor(value));
-    }
-    getInt(name) {
-        return Math.floor(this.parameters.get(name)) ?? 0;
-    }
-    setBool(name, value) {
-        this.parameters.set(name, value);
-    }
-    getBool(name) {
-        return this.parameters.get(name) ?? false;
-    }
-    setTrigger(name) {
-        this.parameters.set(name, true);
-    }
-    resetTrigger(name) {
+  constructor(boneDescriptors) {
+    this.clips = /* @__PURE__ */ new Map();
+    this.layers = [];
+    this.stateMachine = null;
+    this.parameters = /* @__PURE__ */ new Map();
+    this.ikChains = /* @__PURE__ */ new Map();
+    this.morphTargets = null;
+    this.eventCallbacks = /* @__PURE__ */ new Map();
+    this.skeleton = new SkeletonImpl(boneDescriptors);
+  }
+  // ─── Clips ─────────────────────────────────────────────
+  addClip(descriptor) {
+    const clip = new AnimationClipImpl(descriptor);
+    this.clips.set(descriptor.name, clip);
+    return clip;
+  }
+  getClip(name) {
+    return this.clips.get(name);
+  }
+  removeClip(name) {
+    this.clips.delete(name);
+  }
+  // ─── Layers ────────────────────────────────────────────
+  addLayer(descriptor) {
+    const layer = new AnimationLayerImpl(descriptor, this.skeleton, this.clips, this.parameters);
+    this.layers.push(layer);
+    return layer;
+  }
+  getLayer(nameOrIndex) {
+    if (typeof nameOrIndex === "number") {
+      return this.layers[nameOrIndex];
+    }
+    return this.layers.find((l) => l.name === nameOrIndex);
+  }
+  getLayerCount() {
+    return this.layers.length;
+  }
+  // ─── State Machine ─────────────────────────────────────
+  createStateMachine(descriptor) {
+    this.stateMachine = new AnimationStateMachine(descriptor, this.clips, this.parameters);
+    if (descriptor.parameters) {
+      for (const param of descriptor.parameters) {
+        this.parameters.set(
+          param.name,
+          param.defaultValue ?? (param.type === "bool" || param.type === "trigger" ? false : 0)
+        );
+      }
+    }
+    return this.stateMachine;
+  }
+  getStateMachine() {
+    return this.stateMachine;
+  }
+  // ─── Parameters ────────────────────────────────────────
+  setFloat(name, value) {
+    this.parameters.set(name, value);
+  }
+  getFloat(name) {
+    return this.parameters.get(name) ?? 0;
+  }
+  setInt(name, value) {
+    this.parameters.set(name, Math.floor(value));
+  }
+  getInt(name) {
+    return Math.floor(this.parameters.get(name)) ?? 0;
+  }
+  setBool(name, value) {
+    this.parameters.set(name, value);
+  }
+  getBool(name) {
+    return this.parameters.get(name) ?? false;
+  }
+  setTrigger(name) {
+    this.parameters.set(name, true);
+  }
+  resetTrigger(name) {
+    this.parameters.set(name, false);
+  }
+  // ─── IK ────────────────────────────────────────────────
+  addIKChain(name, descriptor) {
+    const chain = new IKChainImpl(descriptor);
+    this.ikChains.set(name, chain);
+    return chain;
+  }
+  getIKChain(name) {
+    return this.ikChains.get(name);
+  }
+  removeIKChain(name) {
+    this.ikChains.delete(name);
+  }
+  // ─── Morph Targets ─────────────────────────────────────
+  createMorphTargetManager() {
+    this.morphTargets = new MorphTargetManagerImpl();
+    return this.morphTargets;
+  }
+  getMorphTargetManager() {
+    return this.morphTargets;
+  }
+  // ─── Events ────────────────────────────────────────────
+  onEvent(eventName, callback) {
+    if (!this.eventCallbacks.has(eventName)) {
+      this.eventCallbacks.set(eventName, []);
+    }
+    this.eventCallbacks.get(eventName).push(callback);
+  }
+  offEvent(eventName, callback) {
+    const callbacks = this.eventCallbacks.get(eventName);
+    if (callbacks) {
+      const idx = callbacks.indexOf(callback);
+      if (idx >= 0) {
+        callbacks.splice(idx, 1);
+      }
+    }
+  }
+  dispatchEvent(eventName, data) {
+    const callbacks = this.eventCallbacks.get(eventName);
+    if (callbacks) {
+      for (const cb of callbacks) {
+        cb(data);
+      }
+    }
+  }
+  // ─── Update ────────────────────────────────────────────
+  update(deltaTime) {
+    if (this.stateMachine) {
+      this.stateMachine.update(deltaTime);
+      const events = this.stateMachine.getTriggeredEvents();
+      for (const event of events) {
+        this.dispatchEvent(event.name, event.data);
+      }
+    }
+    for (const layer of this.layers) {
+      layer.evaluate(deltaTime);
+    }
+    if (this.stateMachine) {
+      this.stateMachine.sample(this.skeleton);
+    }
+    for (const _layer of this.layers) {
+    }
+    this.skeleton.computeWorldTransforms();
+    for (const chain of this.ikChains.values()) {
+      if (chain.isEnabled()) {
+        chain.solve(this.skeleton);
+      }
+    }
+    for (const [name, value] of this.parameters.entries()) {
+      if (value === true && this.isTrigger(name)) {
         this.parameters.set(name, false);
-    }
-    // ─── IK ────────────────────────────────────────────────
-    addIKChain(name, descriptor) {
-        const chain = new IKChainImpl(descriptor);
-        this.ikChains.set(name, chain);
-        return chain;
-    }
-    getIKChain(name) {
-        return this.ikChains.get(name);
-    }
-    removeIKChain(name) {
-        this.ikChains.delete(name);
-    }
-    // ─── Morph Targets ─────────────────────────────────────
-    createMorphTargetManager() {
-        this.morphTargets = new MorphTargetManagerImpl();
-        return this.morphTargets;
-    }
-    getMorphTargetManager() {
-        return this.morphTargets;
-    }
-    // ─── Events ────────────────────────────────────────────
-    onEvent(eventName, callback) {
-        if (!this.eventCallbacks.has(eventName)) {
-            this.eventCallbacks.set(eventName, []);
-        }
-        this.eventCallbacks.get(eventName).push(callback);
-    }
-    offEvent(eventName, callback) {
-        const callbacks = this.eventCallbacks.get(eventName);
-        if (callbacks) {
-            const idx = callbacks.indexOf(callback);
-            if (idx >= 0) {
-                callbacks.splice(idx, 1);
-            }
-        }
-    }
-    dispatchEvent(eventName, data) {
-        const callbacks = this.eventCallbacks.get(eventName);
-        if (callbacks) {
-            for (const cb of callbacks) {
-                cb(data);
-            }
-        }
-    }
-    // ─── Update ────────────────────────────────────────────
-    update(deltaTime) {
-        // Update state machine
-        if (this.stateMachine) {
-            this.stateMachine.update(deltaTime);
-            // Check for animation events
-            const events = this.stateMachine.getTriggeredEvents();
-            for (const event of events) {
-                this.dispatchEvent(event.name, event.data);
-            }
-        }
-        // Update layers
-        for (const layer of this.layers) {
-            layer.evaluate(deltaTime);
-        }
-        // Apply state machine to skeleton
-        if (this.stateMachine) {
-            this.stateMachine.sample(this.skeleton);
-        }
-        // Apply layers to skeleton
-        for (const _layer of this.layers) {
-            // Layer application happens in evaluate
-        }
-        // Compute world transforms
-        this.skeleton.computeWorldTransforms();
-        // Apply IK
-        for (const chain of this.ikChains.values()) {
-            if (chain.isEnabled()) {
-                chain.solve(this.skeleton);
-            }
-        }
-        // Reset triggers
-        for (const [name, value] of this.parameters.entries()) {
-            if (value === true && this.isTrigger(name)) {
-                this.parameters.set(name, false);
-            }
-        }
-    }
-    isTrigger(_name) {
-        // Check if parameter is a trigger type
-        return false; // Would check against parameter definitions
-    }
-    // ─── Output ────────────────────────────────────────────
-    getSkeleton() {
-        return this.skeleton;
-    }
-    getJointMatrices() {
-        return this.skeleton.getJointMatrices();
-    }
+      }
+    }
+  }
+  isTrigger(_name) {
+    return false;
+  }
+  // ─── Output ────────────────────────────────────────────
+  getSkeleton() {
+    return this.skeleton;
+  }
+  getJointMatrices() {
+    return this.skeleton.getJointMatrices();
+  }
 }
-// ============================================================
-// Animation State Machine
-// ============================================================
 class AnimationStateMachine {
-    constructor(descriptor, clips, parameters) {
-        this.states = new Map();
-        this.transitions = [];
-        this.currentState = null;
+  constructor(descriptor, clips, parameters) {
+    this.states = /* @__PURE__ */ new Map();
+    this.transitions = [];
+    this.currentState = null;
+    this.activeTransition = null;
+    this.previousTime = 0;
+    this.triggeredEvents = [];
+    this.parameters = parameters;
+    for (const stateDesc of descriptor.states) {
+      const clip = stateDesc.clip ? clips.get(stateDesc.clip) ?? null : null;
+      const state = new AnimationStateImpl(stateDesc, clip);
+      this.states.set(stateDesc.name, state);
+    }
+    for (const transDesc of descriptor.transitions) {
+      const from = this.states.get(transDesc.from);
+      const to = this.states.get(transDesc.to);
+      if (from && to) {
+        this.transitions.push(new AnimationTransitionImpl(from, to, transDesc));
+      }
+    }
+    if (descriptor.defaultState) {
+      this.currentState = this.states.get(descriptor.defaultState) ?? null;
+      this.currentState?.enter();
+    } else if (this.states.size > 0) {
+      this.currentState = this.states.values().next().value ?? null;
+      this.currentState?.enter();
+    }
+  }
+  getCurrentState() {
+    return this.currentState;
+  }
+  isInTransition() {
+    return this.activeTransition !== null;
+  }
+  getTransitionProgress() {
+    return this.activeTransition?.progress ?? 0;
+  }
+  update(deltaTime) {
+    this.triggeredEvents = [];
+    if (this.activeTransition) {
+      this.activeTransition.update(deltaTime);
+      if (this.activeTransition.isComplete()) {
+        this.currentState = this.activeTransition.to;
         this.activeTransition = null;
-        this.previousTime = 0;
-        this.triggeredEvents = [];
-        this.parameters = parameters;
-        // Create states
-        for (const stateDesc of descriptor.states) {
-            const clip = stateDesc.clip ? (clips.get(stateDesc.clip) ?? null) : null;
-            const state = new AnimationStateImpl(stateDesc, clip);
-            this.states.set(stateDesc.name, state);
-        }
-        // Create transitions
-        for (const transDesc of descriptor.transitions) {
-            const from = this.states.get(transDesc.from);
-            const to = this.states.get(transDesc.to);
-            if (from && to) {
-                this.transitions.push(new AnimationTransitionImpl(from, to, transDesc));
-            }
-        }
-        // Set default state
-        if (descriptor.defaultState) {
-            this.currentState = this.states.get(descriptor.defaultState) ?? null;
-            this.currentState?.enter();
-        }
-        else if (this.states.size > 0) {
-            this.currentState = this.states.values().next().value ?? null;
-            this.currentState?.enter();
-        }
-    }
-    getCurrentState() {
-        return this.currentState;
-    }
-    isInTransition() {
-        return this.activeTransition !== null;
-    }
-    getTransitionProgress() {
-        return this.activeTransition?.progress ?? 0;
-    }
-    update(deltaTime) {
-        this.triggeredEvents = [];
-        // Update active transition
-        if (this.activeTransition) {
-            this.activeTransition.update(deltaTime);
-            if (this.activeTransition.isComplete()) {
-                this.currentState = this.activeTransition.to;
-                this.activeTransition = null;
-            }
-        }
-        else {
-            // Check for transitions
-            if (this.currentState) {
-                for (const transition of this.transitions) {
-                    if (transition.from === this.currentState && transition.check(this.parameters)) {
-                        // Check exit time
-                        if (transition.hasExitTime) {
-                            if (this.currentState.normalizedTime >= transition.exitTime) {
-                                this.startTransition(transition);
-                                break;
-                            }
-                        }
-                        else {
-                            this.startTransition(transition);
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        // Update current state
-        const prevTime = this.currentState?.time ?? 0;
-        this.currentState?.update(deltaTime);
-        const currTime = this.currentState?.time ?? 0;
-        // Check for events
-        if (this.currentState?.clip) {
-            const event = this.currentState.clip.getEvent(currTime, prevTime);
-            if (event) {
-                this.triggeredEvents.push(event);
-            }
-        }
-    }
-    startTransition(transition) {
-        this.currentState?.exit();
-        transition.to.enter();
-        transition.to.time = transition.offset * transition.to.clip.duration;
-        transition.progress = 0;
-        this.activeTransition = transition;
-    }
-    sample(skeleton) {
-        if (this.activeTransition) {
-            // Blend between states
-            1 - this.activeTransition.progress;
-            const toWeight = this.activeTransition.progress;
-            // Sample from state
-            this.activeTransition.from.sample(skeleton);
-            // Would need to blend, simplified here
-            if (toWeight > 0.5) {
-                this.activeTransition.to.sample(skeleton);
+      }
+    } else {
+      if (this.currentState) {
+        for (const transition of this.transitions) {
+          if (transition.from === this.currentState && transition.check(this.parameters)) {
+            if (transition.hasExitTime) {
+              if (this.currentState.normalizedTime >= transition.exitTime) {
+                this.startTransition(transition);
+                break;
+              }
+            } else {
+              this.startTransition(transition);
+              break;
             }
-        }
-        else if (this.currentState) {
-            this.currentState.sample(skeleton);
-        }
-    }
-    getTriggeredEvents() {
-        return this.triggeredEvents;
-    }
-    forceState(stateName) {
-        const state = this.states.get(stateName);
-        if (state) {
-            this.currentState?.exit();
-            this.currentState = state;
-            this.currentState.enter();
-            this.activeTransition = null;
-        }
-    }
+          }
+        }
+      }
+    }
+    const prevTime = this.currentState?.time ?? 0;
+    this.currentState?.update(deltaTime);
+    const currTime = this.currentState?.time ?? 0;
+    if (this.currentState?.clip) {
+      const event = this.currentState.clip.getEvent(currTime, prevTime);
+      if (event) {
+        this.triggeredEvents.push(event);
+      }
+    }
+  }
+  startTransition(transition) {
+    this.currentState?.exit();
+    transition.to.enter();
+    transition.to.time = transition.offset * transition.to.clip.duration;
+    transition.progress = 0;
+    this.activeTransition = transition;
+  }
+  sample(skeleton) {
+    if (this.activeTransition) {
+      1 - this.activeTransition.progress;
+      const toWeight = this.activeTransition.progress;
+      this.activeTransition.from.sample(skeleton);
+      if (toWeight > 0.5) {
+        this.activeTransition.to.sample(skeleton);
+      }
+    } else if (this.currentState) {
+      this.currentState.sample(skeleton);
+    }
+  }
+  getTriggeredEvents() {
+    return this.triggeredEvents;
+  }
+  forceState(stateName) {
+    const state = this.states.get(stateName);
+    if (state) {
+      this.currentState?.exit();
+      this.currentState = state;
+      this.currentState.enter();
+      this.activeTransition = null;
+    }
+  }
 }
-// ============================================================
-// Internal Implementations
-// ============================================================
 class SkeletonImpl {
-    constructor(descriptors) {
-        this.boneMap = new Map();
-        this.bones = descriptors.map((desc, index) => ({
-            name: desc.name,
-            index,
-            parentIndex: desc.parentIndex,
-            children: [],
-            localPosition: { ...desc.position },
-            localRotation: { ...desc.rotation },
-            localScale: { ...desc.scale },
-            worldPosition: { ...desc.position },
-            worldRotation: { ...desc.rotation },
-            worldScale: { ...desc.scale },
-            inverseBindMatrix: new Float32Array(16),
-        }));
-        // Build bone map and children
-        for (let i = 0; i < this.bones.length; i++) {
-            const bone = this.bones[i];
-            this.boneMap.set(bone.name, i);
-            if (bone.parentIndex >= 0) {
-                this.bones[bone.parentIndex].children.push(i);
-            }
-        }
-        this.jointMatrices = new Float32Array(this.bones.length * 16);
-        this.computeWorldTransforms();
-    }
-    getBone(nameOrIndex) {
-        if (typeof nameOrIndex === 'number') {
-            return this.bones[nameOrIndex];
-        }
-        const index = this.boneMap.get(nameOrIndex);
-        return index !== undefined ? this.bones[index] : undefined;
-    }
-    getBoneIndex(name) {
-        return this.boneMap.get(name) ?? -1;
-    }
-    getBoneCount() {
-        return this.bones.length;
-    }
-    setLocalPose(boneIndex, position, rotation, scale) {
-        const bone = this.bones[boneIndex];
-        if (bone) {
-            bone.localPosition = { ...position };
-            bone.localRotation = { ...rotation };
-            bone.localScale = { ...scale };
-        }
-    }
-    getLocalPose(boneIndex) {
-        const bone = this.bones[boneIndex];
-        return {
-            position: { ...bone.localPosition },
-            rotation: { ...bone.localRotation },
-            scale: { ...bone.localScale },
+  constructor(descriptors) {
+    this.boneMap = /* @__PURE__ */ new Map();
+    this.bones = descriptors.map((desc, index) => ({
+      name: desc.name,
+      index,
+      parentIndex: desc.parentIndex,
+      children: [],
+      localPosition: { ...desc.position },
+      localRotation: { ...desc.rotation },
+      localScale: { ...desc.scale },
+      worldPosition: { ...desc.position },
+      worldRotation: { ...desc.rotation },
+      worldScale: { ...desc.scale },
+      inverseBindMatrix: new Float32Array(16)
+    }));
+    for (let i = 0; i < this.bones.length; i++) {
+      const bone = this.bones[i];
+      this.boneMap.set(bone.name, i);
+      if (bone.parentIndex >= 0) {
+        this.bones[bone.parentIndex].children.push(i);
+      }
+    }
+    this.jointMatrices = new Float32Array(this.bones.length * 16);
+    this.computeWorldTransforms();
+  }
+  getBone(nameOrIndex) {
+    if (typeof nameOrIndex === "number") {
+      return this.bones[nameOrIndex];
+    }
+    const index = this.boneMap.get(nameOrIndex);
+    return index !== void 0 ? this.bones[index] : void 0;
+  }
+  getBoneIndex(name) {
+    return this.boneMap.get(name) ?? -1;
+  }
+  getBoneCount() {
+    return this.bones.length;
+  }
+  setLocalPose(boneIndex, position, rotation, scale) {
+    const bone = this.bones[boneIndex];
+    if (bone) {
+      bone.localPosition = { ...position };
+      bone.localRotation = { ...rotation };
+      bone.localScale = { ...scale };
+    }
+  }
+  getLocalPose(boneIndex) {
+    const bone = this.bones[boneIndex];
+    return {
+      position: { ...bone.localPosition },
+      rotation: { ...bone.localRotation },
+      scale: { ...bone.localScale }
+    };
+  }
+  computeWorldTransforms() {
+    for (const bone of this.bones) {
+      if (bone.parentIndex < 0) {
+        bone.worldPosition = { ...bone.localPosition };
+        bone.worldRotation = { ...bone.localRotation };
+        bone.worldScale = { ...bone.localScale };
+      } else {
+        const parent = this.bones[bone.parentIndex];
+        bone.worldPosition = this.transformPoint(bone.localPosition, parent);
+        bone.worldRotation = this.multiplyQuaternions(parent.worldRotation, bone.localRotation);
+        bone.worldScale = {
+          x: parent.worldScale.x * bone.localScale.x,
+          y: parent.worldScale.y * bone.localScale.y,
+          z: parent.worldScale.z * bone.localScale.z
         };
-    }
-    computeWorldTransforms() {
-        for (const bone of this.bones) {
-            if (bone.parentIndex < 0) {
-                // Root bone
-                bone.worldPosition = { ...bone.localPosition };
-                bone.worldRotation = { ...bone.localRotation };
-                bone.worldScale = { ...bone.localScale };
-            }
-            else {
-                const parent = this.bones[bone.parentIndex];
-                // Transform local by parent world
-                bone.worldPosition = this.transformPoint(bone.localPosition, parent);
-                bone.worldRotation = this.multiplyQuaternions(parent.worldRotation, bone.localRotation);
-                bone.worldScale = {
-                    x: parent.worldScale.x * bone.localScale.x,
-                    y: parent.worldScale.y * bone.localScale.y,
-                    z: parent.worldScale.z * bone.localScale.z,
-                };
-            }
-            // Update joint matrix
-            this.updateJointMatrix(bone);
-        }
-    }
-    transformPoint(point, parent) {
-        // Simplified - would use proper quaternion rotation
-        return {
-            x: parent.worldPosition.x + point.x * parent.worldScale.x,
-            y: parent.worldPosition.y + point.y * parent.worldScale.y,
-            z: parent.worldPosition.z + point.z * parent.worldScale.z,
-        };
-    }
-    multiplyQuaternions(a, b) {
-        return {
-            x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
-            y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
-            z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
-            w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z,
-        };
-    }
-    updateJointMatrix(bone) {
-        const offset = bone.index * 16;
-        // Simplified - would compose TRS matrix
-        // Final = WorldMatrix * InverseBindMatrix
-        this.jointMatrices[offset] = 1;
-        this.jointMatrices[offset + 5] = 1;
-        this.jointMatrices[offset + 10] = 1;
-        this.jointMatrices[offset + 15] = 1;
-        this.jointMatrices[offset + 12] = bone.worldPosition.x;
-        this.jointMatrices[offset + 13] = bone.worldPosition.y;
-        this.jointMatrices[offset + 14] = bone.worldPosition.z;
-    }
-    getJointMatrices() {
-        return this.jointMatrices;
-    }
+      }
+      this.updateJointMatrix(bone);
+    }
+  }
+  transformPoint(point, parent) {
+    return {
+      x: parent.worldPosition.x + point.x * parent.worldScale.x,
+      y: parent.worldPosition.y + point.y * parent.worldScale.y,
+      z: parent.worldPosition.z + point.z * parent.worldScale.z
+    };
+  }
+  multiplyQuaternions(a, b) {
+    return {
+      x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+      y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+      z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+      w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
+    };
+  }
+  updateJointMatrix(bone) {
+    const offset = bone.index * 16;
+    this.jointMatrices[offset] = 1;
+    this.jointMatrices[offset + 5] = 1;
+    this.jointMatrices[offset + 10] = 1;
+    this.jointMatrices[offset + 15] = 1;
+    this.jointMatrices[offset + 12] = bone.worldPosition.x;
+    this.jointMatrices[offset + 13] = bone.worldPosition.y;
+    this.jointMatrices[offset + 14] = bone.worldPosition.z;
+  }
+  getJointMatrices() {
+    return this.jointMatrices;
+  }
 }
 class AnimationClipImpl {
-    constructor(descriptor) {
-        this.name = descriptor.name;
-        this.duration = descriptor.duration;
-        this.tracks = descriptor.tracks;
-        this.events = descriptor.events ?? [];
-    }
-    sample(time, skeleton) {
-        for (const track of this.tracks) {
-            const boneIndex = skeleton.getBoneIndex(track.targetBone);
-            if (boneIndex < 0) {
-                continue;
-            }
-            const value = this.sampleTrack(track, time);
-            const pose = skeleton.getLocalPose(boneIndex);
-            switch (track.property) {
-                case 'position':
-                    skeleton.setLocalPose(boneIndex, value, pose.rotation, pose.scale);
-                    break;
-                case 'rotation':
-                    skeleton.setLocalPose(boneIndex, pose.position, value, pose.scale);
-                    break;
-                case 'scale':
-                    skeleton.setLocalPose(boneIndex, pose.position, pose.rotation, value);
-                    break;
-            }
-        }
-    }
-    sampleTrack(track, time) {
-        const keyframes = track.keyframes;
-        if (keyframes.length === 0) {
-            return track.property === 'rotation' ? { x: 0, y: 0, z: 0, w: 1 } : { x: 0, y: 0, z: 0 };
-        }
-        if (keyframes.length === 1 || time <= keyframes[0].time) {
-            return keyframes[0].value;
-        }
-        if (time >= keyframes[keyframes.length - 1].time) {
-            return keyframes[keyframes.length - 1].value;
-        }
-        // Find surrounding keyframes
-        let i = 0;
-        while (i < keyframes.length - 1 && keyframes[i + 1].time < time) {
-            i++;
-        }
-        const k0 = keyframes[i];
-        const k1 = keyframes[i + 1];
-        const t = (time - k0.time) / (k1.time - k0.time);
-        // Interpolate
-        if (track.property === 'rotation') {
-            return this.slerpQuaternion(k0.value, k1.value, t);
-        }
-        else {
-            return this.lerpVec3(k0.value, k1.value, t);
-        }
-    }
-    lerpVec3(a, b, t) {
-        return {
-            x: a.x + (b.x - a.x) * t,
-            y: a.y + (b.y - a.y) * t,
-            z: a.z + (b.z - a.z) * t,
-        };
-    }
-    slerpQuaternion(a, b, t) {
-        // Simplified slerp
-        let dot = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
-        if (dot < 0) {
-            b = { x: -b.x, y: -b.y, z: -b.z, w: -b.w };
-            dot = -dot;
-        }
-        if (dot > 0.9995) {
-            // Linear interpolation for very close quaternions
-            return this.normalizeQuaternion({
-                x: a.x + (b.x - a.x) * t,
-                y: a.y + (b.y - a.y) * t,
-                z: a.z + (b.z - a.z) * t,
-                w: a.w + (b.w - a.w) * t,
-            });
-        }
-        const theta0 = Math.acos(dot);
-        const theta = theta0 * t;
-        const sinTheta = Math.sin(theta);
-        const sinTheta0 = Math.sin(theta0);
-        const s0 = Math.cos(theta) - (dot * sinTheta) / sinTheta0;
-        const s1 = sinTheta / sinTheta0;
-        return {
-            x: a.x * s0 + b.x * s1,
-            y: a.y * s0 + b.y * s1,
-            z: a.z * s0 + b.z * s1,
-            w: a.w * s0 + b.w * s1,
-        };
-    }
-    normalizeQuaternion(q) {
-        const len = Math.sqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
-        return { x: q.x / len, y: q.y / len, z: q.z / len, w: q.w / len };
-    }
-    getEvent(time, previousTime) {
-        for (const event of this.events) {
-            if (event.time > previousTime && event.time <= time) {
-                return event;
-            }
-        }
-        return null;
-    }
+  constructor(descriptor) {
+    this.name = descriptor.name;
+    this.duration = descriptor.duration;
+    this.tracks = descriptor.tracks;
+    this.events = descriptor.events ?? [];
+  }
+  sample(time, skeleton) {
+    for (const track of this.tracks) {
+      const boneIndex = skeleton.getBoneIndex(track.targetBone);
+      if (boneIndex < 0) {
+        continue;
+      }
+      const value = this.sampleTrack(track, time);
+      const pose = skeleton.getLocalPose(boneIndex);
+      switch (track.property) {
+        case "position":
+          skeleton.setLocalPose(boneIndex, value, pose.rotation, pose.scale);
+          break;
+        case "rotation":
+          skeleton.setLocalPose(boneIndex, pose.position, value, pose.scale);
+          break;
+        case "scale":
+          skeleton.setLocalPose(boneIndex, pose.position, pose.rotation, value);
+          break;
+      }
+    }
+  }
+  sampleTrack(track, time) {
+    const keyframes = track.keyframes;
+    if (keyframes.length === 0) {
+      return track.property === "rotation" ? { x: 0, y: 0, z: 0, w: 1 } : { x: 0, y: 0, z: 0 };
+    }
+    if (keyframes.length === 1 || time <= keyframes[0].time) {
+      return keyframes[0].value;
+    }
+    if (time >= keyframes[keyframes.length - 1].time) {
+      return keyframes[keyframes.length - 1].value;
+    }
+    let i = 0;
+    while (i < keyframes.length - 1 && keyframes[i + 1].time < time) {
+      i++;
+    }
+    const k0 = keyframes[i];
+    const k1 = keyframes[i + 1];
+    const t = (time - k0.time) / (k1.time - k0.time);
+    if (track.property === "rotation") {
+      return this.slerpQuaternion(k0.value, k1.value, t);
+    } else {
+      return this.lerpVec3(k0.value, k1.value, t);
+    }
+  }
+  lerpVec3(a, b, t) {
+    return {
+      x: a.x + (b.x - a.x) * t,
+      y: a.y + (b.y - a.y) * t,
+      z: a.z + (b.z - a.z) * t
+    };
+  }
+  slerpQuaternion(a, b, t) {
+    let dot = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+    if (dot < 0) {
+      b = { x: -b.x, y: -b.y, z: -b.z, w: -b.w };
+      dot = -dot;
+    }
+    if (dot > 0.9995) {
+      return this.normalizeQuaternion({
+        x: a.x + (b.x - a.x) * t,
+        y: a.y + (b.y - a.y) * t,
+        z: a.z + (b.z - a.z) * t,
+        w: a.w + (b.w - a.w) * t
+      });
+    }
+    const theta0 = Math.acos(dot);
+    const theta = theta0 * t;
+    const sinTheta = Math.sin(theta);
+    const sinTheta0 = Math.sin(theta0);
+    const s0 = Math.cos(theta) - dot * sinTheta / sinTheta0;
+    const s1 = sinTheta / sinTheta0;
+    return {
+      x: a.x * s0 + b.x * s1,
+      y: a.y * s0 + b.y * s1,
+      z: a.z * s0 + b.z * s1,
+      w: a.w * s0 + b.w * s1
+    };
+  }
+  normalizeQuaternion(q) {
+    const len = Math.sqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
+    return { x: q.x / len, y: q.y / len, z: q.z / len, w: q.w / len };
+  }
+  getEvent(time, previousTime) {
+    for (const event of this.events) {
+      if (event.time > previousTime && event.time <= time) {
+        return event;
+      }
+    }
+    return null;
+  }
 }
 class AnimationLayerImpl {
-    constructor(descriptor, _skeleton, _clips, _parameters) {
-        this._mask = null;
-        this._currentState = null;
-        this.name = descriptor.name;
-        this.blendMode = descriptor.blendMode ?? 'override';
-        this._weight = descriptor.weight ?? 1;
-        if (descriptor.mask) {
-            this._mask = new AvatarMaskImpl(descriptor.mask);
-        }
-    }
-    getWeight() {
-        return this._weight;
-    }
-    setWeight(weight) {
-        this._weight = Math.max(0, Math.min(1, weight));
-    }
-    getBlendMode() {
-        return this.blendMode;
-    }
-    setBlendMode(mode) {
-        this.blendMode = mode;
-    }
-    getMask() {
-        return this._mask;
-    }
-    setMask(mask) {
-        this._mask = mask;
-    }
-    getCurrentState() {
-        return this._currentState;
-    }
-    setCurrentState(state) {
-        this._currentState = state;
-    }
-    evaluate(_deltaTime) {
-        // Update and blend animations for this layer
-    }
+  constructor(descriptor, _skeleton, _clips, _parameters) {
+    this._mask = null;
+    this._currentState = null;
+    this.name = descriptor.name;
+    this.blendMode = descriptor.blendMode ?? "override";
+    this._weight = descriptor.weight ?? 1;
+    if (descriptor.mask) {
+      this._mask = new AvatarMaskImpl(descriptor.mask);
+    }
+  }
+  getWeight() {
+    return this._weight;
+  }
+  setWeight(weight) {
+    this._weight = Math.max(0, Math.min(1, weight));
+  }
+  getBlendMode() {
+    return this.blendMode;
+  }
+  setBlendMode(mode) {
+    this.blendMode = mode;
+  }
+  getMask() {
+    return this._mask;
+  }
+  setMask(mask) {
+    this._mask = mask;
+  }
+  getCurrentState() {
+    return this._currentState;
+  }
+  setCurrentState(state) {
+    this._currentState = state;
+  }
+  evaluate(_deltaTime) {
+  }
 }
 class AvatarMaskImpl {
-    constructor(bones) {
-        this.weights = new Map();
-        for (const bone of bones) {
-            this.weights.set(bone, 1);
-        }
-    }
-    getBoneWeight(boneName) {
-        return this.weights.get(boneName) ?? 0;
-    }
-    setBoneWeight(boneName, weight) {
-        this.weights.set(boneName, weight);
-    }
-    setAllWeights(weight) {
-        for (const bone of this.weights.keys()) {
-            this.weights.set(bone, weight);
-        }
-    }
+  constructor(bones) {
+    this.weights = /* @__PURE__ */ new Map();
+    for (const bone of bones) {
+      this.weights.set(bone, 1);
+    }
+  }
+  getBoneWeight(boneName) {
+    return this.weights.get(boneName) ?? 0;
+  }
+  setBoneWeight(boneName, weight) {
+    this.weights.set(boneName, weight);
+  }
+  setAllWeights(weight) {
+    for (const bone of this.weights.keys()) {
+      this.weights.set(bone, weight);
+    }
+  }
 }
 class AnimationStateImpl {
-    constructor(descriptor, clip) {
-        this.blendTree = null;
-        this.normalizedTime = 0;
-        this.time = 0;
-        this.name = descriptor.name;
-        this.type = descriptor.type;
-        this.clip = clip;
-        this.speed = descriptor.speed ?? 1;
-        this.wrapMode = descriptor.wrapMode ?? 'loop';
-    }
-    enter() {
-        this.time = 0;
-        this.normalizedTime = 0;
-    }
-    exit() {
-        // Cleanup
-    }
-    update(deltaTime) {
-        this.time += deltaTime * this.speed;
-        if (this.clip) {
-            const duration = this.clip.duration;
-            switch (this.wrapMode) {
-                case 'once':
-                    if (this.time > duration) {
-                        this.time = duration;
-                    }
-                    break;
-                case 'loop':
-                    while (this.time > duration) {
-                        this.time -= duration;
-                    }
-                    break;
-                case 'pingpong':
-                    // Would implement ping-pong
-                    break;
-                case 'clamp':
-                    this.time = Math.max(0, Math.min(this.time, duration));
-                    break;
-            }
-            this.normalizedTime = duration > 0 ? this.time / duration : 0;
-        }
-    }
-    sample(skeleton) {
-        if (this.clip) {
-            this.clip.sample(this.time, skeleton);
-        }
-        else if (this.blendTree) {
-            this.blendTree.sample(skeleton);
-        }
-    }
+  constructor(descriptor, clip) {
+    this.blendTree = null;
+    this.normalizedTime = 0;
+    this.time = 0;
+    this.name = descriptor.name;
+    this.type = descriptor.type;
+    this.clip = clip;
+    this.speed = descriptor.speed ?? 1;
+    this.wrapMode = descriptor.wrapMode ?? "loop";
+  }
+  enter() {
+    this.time = 0;
+    this.normalizedTime = 0;
+  }
+  exit() {
+  }
+  update(deltaTime) {
+    this.time += deltaTime * this.speed;
+    if (this.clip) {
+      const duration = this.clip.duration;
+      switch (this.wrapMode) {
+        case "once":
+          if (this.time > duration) {
+            this.time = duration;
+          }
+          break;
+        case "loop":
+          while (this.time > duration) {
+            this.time -= duration;
+          }
+          break;
+        case "pingpong":
+          break;
+        case "clamp":
+          this.time = Math.max(0, Math.min(this.time, duration));
+          break;
+      }
+      this.normalizedTime = duration > 0 ? this.time / duration : 0;
+    }
+  }
+  sample(skeleton) {
+    if (this.clip) {
+      this.clip.sample(this.time, skeleton);
+    } else if (this.blendTree) {
+      this.blendTree.sample(skeleton);
+    }
+  }
 }
 class AnimationTransitionImpl {
-    constructor(from, to, descriptor) {
-        this.progress = 0;
-        this.from = from;
-        this.to = to;
-        this.duration = descriptor.duration ?? 0.25;
-        this.offset = descriptor.offset ?? 0;
-        this.conditions = descriptor.conditions ?? [];
-        this.hasExitTime = descriptor.hasExitTime ?? false;
-        this.exitTime = descriptor.exitTime ?? 1;
-    }
-    check(parameters) {
-        if (this.conditions.length === 0) {
-            return true;
-        }
-        for (const condition of this.conditions) {
-            const value = parameters.get(condition.parameter);
-            if (value === undefined) {
-                continue;
-            }
-            let result = false;
-            switch (condition.mode) {
-                case 'equals':
-                    result = value === condition.value;
-                    break;
-                case 'not-equals':
-                    result = value !== condition.value;
-                    break;
-                case 'greater':
-                    result = value > condition.value;
-                    break;
-                case 'less':
-                    result = value < condition.value;
-                    break;
-                case 'if':
-                    result = value === true;
-                    break;
-                case 'if-not':
-                    result = value === false;
-                    break;
-            }
-            if (!result) {
-                return false;
-            }
-        }
-        return true;
-    }
-    update(deltaTime) {
-        if (this.duration > 0) {
-            this.progress += deltaTime / this.duration;
-            this.progress = Math.min(1, this.progress);
-        }
-        else {
-            this.progress = 1;
-        }
-    }
-    isComplete() {
-        return this.progress >= 1;
-    }
+  constructor(from, to, descriptor) {
+    this.progress = 0;
+    this.from = from;
+    this.to = to;
+    this.duration = descriptor.duration ?? 0.25;
+    this.offset = descriptor.offset ?? 0;
+    this.conditions = descriptor.conditions ?? [];
+    this.hasExitTime = descriptor.hasExitTime ?? false;
+    this.exitTime = descriptor.exitTime ?? 1;
+  }
+  check(parameters) {
+    if (this.conditions.length === 0) {
+      return true;
+    }
+    for (const condition of this.conditions) {
+      const value = parameters.get(condition.parameter);
+      if (value === void 0) {
+        continue;
+      }
+      let result = false;
+      switch (condition.mode) {
+        case "equals":
+          result = value === condition.value;
+          break;
+        case "not-equals":
+          result = value !== condition.value;
+          break;
+        case "greater":
+          result = value > condition.value;
+          break;
+        case "less":
+          result = value < condition.value;
+          break;
+        case "if":
+          result = value === true;
+          break;
+        case "if-not":
+          result = value === false;
+          break;
+      }
+      if (!result) {
+        return false;
+      }
+    }
+    return true;
+  }
+  update(deltaTime) {
+    if (this.duration > 0) {
+      this.progress += deltaTime / this.duration;
+      this.progress = Math.min(1, this.progress);
+    } else {
+      this.progress = 1;
+    }
+  }
+  isComplete() {
+    return this.progress >= 1;
+  }
 }
 class IKChainImpl {
-    constructor(descriptor) {
-        this._target = { x: 0, y: 0, z: 0 };
-        this._poleTarget = null;
-        this._enabled = true;
-        this.type = descriptor.type;
-        this.rootBone = descriptor.rootBone;
-        this.tipBone = descriptor.tipBone;
-        this._weight = descriptor.weight ?? 1;
-        this._iterations = descriptor.iterations ?? 10;
-        this._tolerance = descriptor.tolerance ?? 0.001;
-        this._poleTarget = descriptor.poleTarget ?? null;
-    }
-    getTarget() {
-        return { ...this._target };
-    }
-    setTarget(target) {
-        this._target = { ...target };
-    }
-    getPoleTarget() {
-        return this._poleTarget ? { ...this._poleTarget } : null;
-    }
-    setPoleTarget(target) {
-        this._poleTarget = target ? { ...target } : null;
-    }
-    getWeight() {
-        return this._weight;
-    }
-    setWeight(weight) {
-        this._weight = Math.max(0, Math.min(1, weight));
-    }
-    isEnabled() {
-        return this._enabled;
-    }
-    setEnabled(enabled) {
-        this._enabled = enabled;
-    }
-    solve(skeleton) {
-        if (!this._enabled || this._weight <= 0) {
-            return;
-        }
-        switch (this.type) {
-            case 'two-bone':
-                this.solveTwoBone(skeleton);
-                break;
-            case 'fabrik':
-                this.solveFABRIK(skeleton);
-                break;
-            case 'ccd':
-                this.solveCCD(skeleton);
-                break;
-        }
-    }
-    solveTwoBone(skeleton) {
-        // Two-bone analytical IK (common for arms/legs)
-        const root = skeleton.getBone(this.rootBone);
-        const tip = skeleton.getBone(this.tipBone);
-        if (!root || !tip) {
-            return;
-        }
-        // Would implement two-bone IK solver
-    }
-    solveFABRIK(_skeleton) {
-        // Forward And Backward Reaching Inverse Kinematics
-        for (let i = 0; i < this._iterations; i++) {
-            // Forward pass
-            // Backward pass
-        }
-    }
-    solveCCD(_skeleton) {
-        // Cyclic Coordinate Descent
-        for (let i = 0; i < this._iterations; i++) {
-            // Iterate through chain from tip to root
-        }
-    }
+  constructor(descriptor) {
+    this._target = { x: 0, y: 0, z: 0 };
+    this._poleTarget = null;
+    this._enabled = true;
+    this.type = descriptor.type;
+    this.rootBone = descriptor.rootBone;
+    this.tipBone = descriptor.tipBone;
+    this._weight = descriptor.weight ?? 1;
+    this._iterations = descriptor.iterations ?? 10;
+    this._tolerance = descriptor.tolerance ?? 1e-3;
+    this._poleTarget = descriptor.poleTarget ?? null;
+  }
+  getTarget() {
+    return { ...this._target };
+  }
+  setTarget(target) {
+    this._target = { ...target };
+  }
+  getPoleTarget() {
+    return this._poleTarget ? { ...this._poleTarget } : null;
+  }
+  setPoleTarget(target) {
+    this._poleTarget = target ? { ...target } : null;
+  }
+  getWeight() {
+    return this._weight;
+  }
+  setWeight(weight) {
+    this._weight = Math.max(0, Math.min(1, weight));
+  }
+  isEnabled() {
+    return this._enabled;
+  }
+  setEnabled(enabled) {
+    this._enabled = enabled;
+  }
+  solve(skeleton) {
+    if (!this._enabled || this._weight <= 0) {
+      return;
+    }
+    switch (this.type) {
+      case "two-bone":
+        this.solveTwoBone(skeleton);
+        break;
+      case "fabrik":
+        this.solveFABRIK(skeleton);
+        break;
+      case "ccd":
+        this.solveCCD(skeleton);
+        break;
+    }
+  }
+  solveTwoBone(skeleton) {
+    const root = skeleton.getBone(this.rootBone);
+    const tip = skeleton.getBone(this.tipBone);
+    if (!root || !tip) {
+      return;
+    }
+  }
+  solveFABRIK(_skeleton) {
+    for (let i = 0; i < this._iterations; i++) {
+    }
+  }
+  solveCCD(_skeleton) {
+    for (let i = 0; i < this._iterations; i++) {
+    }
+  }
 }
 class MorphTargetManagerImpl {
-    constructor() {
-        this.targets = new Map();
-    }
-    getMorphTarget(name) {
-        return this.targets.get(name);
-    }
-    getMorphTargets() {
-        return Array.from(this.targets.values());
-    }
-    addMorphTarget(descriptor) {
-        const target = new MorphTargetImpl(descriptor);
-        this.targets.set(descriptor.name, target);
-        return target;
-    }
-    removeMorphTarget(name) {
-        this.targets.delete(name);
-    }
-    getWeight(name) {
-        return this.targets.get(name)?.weight ?? 0;
-    }
-    setWeight(name, weight) {
-        const target = this.targets.get(name);
-        if (target) {
-            target.weight = Math.max(0, Math.min(1, weight));
-        }
-    }
-    getBlendedVertices(baseVertices) {
-        const result = new Float32Array(baseVertices);
-        for (const target of this.targets.values()) {
-            if (target.weight <= 0) {
-                continue;
-            }
-            for (let i = 0; i < result.length; i++) {
-                result[i] += target.vertices[i] * target.weight;
-            }
-        }
-        return result;
-    }
+  constructor() {
+    this.targets = /* @__PURE__ */ new Map();
+  }
+  getMorphTarget(name) {
+    return this.targets.get(name);
+  }
+  getMorphTargets() {
+    return Array.from(this.targets.values());
+  }
+  addMorphTarget(descriptor) {
+    const target = new MorphTargetImpl(descriptor);
+    this.targets.set(descriptor.name, target);
+    return target;
+  }
+  removeMorphTarget(name) {
+    this.targets.delete(name);
+  }
+  getWeight(name) {
+    return this.targets.get(name)?.weight ?? 0;
+  }
+  setWeight(name, weight) {
+    const target = this.targets.get(name);
+    if (target) {
+      target.weight = Math.max(0, Math.min(1, weight));
+    }
+  }
+  getBlendedVertices(baseVertices) {
+    const result = new Float32Array(baseVertices);
+    for (const target of this.targets.values()) {
+      if (target.weight <= 0) {
+        continue;
+      }
+      for (let i = 0; i < result.length; i++) {
+        result[i] += target.vertices[i] * target.weight;
+      }
+    }
+    return result;
+  }
 }
 class MorphTargetImpl {
-    constructor(descriptor) {
-        this.weight = 0;
-        this.name = descriptor.name;
-        this.vertices = descriptor.vertices;
-        this.normals = descriptor.normals ?? null;
-        this.tangents = descriptor.tangents ?? null;
-    }
+  constructor(descriptor) {
+    this.weight = 0;
+    this.name = descriptor.name;
+    this.vertices = descriptor.vertices;
+    this.normals = descriptor.normals ?? null;
+    this.tangents = descriptor.tangents ?? null;
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createAnimatorController(bones) {
-    return new AnimatorController(bones);
+  return new AnimatorController(bones);
 }
 function createAnimationClip(descriptor) {
-    return new AnimationClipImpl(descriptor);
+  return new AnimationClipImpl(descriptor);
 }
-
-export { AnimationStateMachine, AnimatorController, createAnimationClip, createAnimatorController };
+export {
+  AnimationStateMachine,
+  AnimatorController,
+  createAnimationClip,
+  createAnimatorController
+};