@nice2dev/game-engine 1.1.7 → 1.1.10

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

@@ -0,0 +1,840 @@
+'use strict';
+
+/**
+ * @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) {
+        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();
+    }
+}
+// ============================================================
+// Animation State Machine
+// ============================================================
+class AnimationStateMachine {
+    constructor(descriptor, clips, parameters) {
+        this.states = new Map();
+        this.transitions = [];
+        this.currentState = null;
+        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) {
+            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 },
+        };
+    }
+    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;
+    }
+}
+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;
+    }
+}
+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
+    }
+}
+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);
+        }
+    }
+}
+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);
+        }
+    }
+}
+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;
+    }
+}
+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
+        }
+    }
+}
+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;
+    }
+}
+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;
+    }
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createAnimatorController(bones) {
+    return new AnimatorController(bones);
+}
+function createAnimationClip(descriptor) {
+    return new AnimationClipImpl(descriptor);
+}
+
+exports.AnimationStateMachine = AnimationStateMachine;
+exports.AnimatorController = AnimatorController;
+exports.createAnimationClip = createAnimationClip;
+exports.createAnimatorController = createAnimatorController;