reze-engine 0.2.19 → 0.3.1

package/dist/player.js

@@ -0,0 +1,409 @@
+import { bezierInterpolate } from "./bezier-interpolate";
+import { Quat, Vec3 } from "./math";
+import { VMDLoader } from "./vmd-loader";
+export class Player {
+    constructor() {
+        // Animation data
+        this.frames = [];
+        this.boneTracks = new Map();
+        this.morphTracks = new Map();
+        this.duration = 0;
+        // Playback state
+        this.isPlaying = false;
+        this.isPaused = false;
+        this.currentTime = 0;
+        // Timing
+        this.startTime = 0; // Real-time when playback started
+        this.pausedTime = 0; // Accumulated paused duration
+        this.pauseStartTime = 0;
+        this.audioLoaded = false;
+    }
+    /**
+     * Load VMD animation file and optionally audio
+     */
+    async loadVmd(vmdUrl, audioUrl) {
+        // Load animation
+        this.frames = await VMDLoader.load(vmdUrl);
+        this.processFrames();
+        // Load audio if provided
+        if (audioUrl) {
+            await this.loadAudio(audioUrl);
+        }
+    }
+    /**
+     * Load audio file
+     */
+    async loadAudio(url) {
+        this.audioUrl = url;
+        this.audioLoaded = false;
+        return new Promise((resolve, reject) => {
+            const audio = new Audio(url);
+            audio.preload = "auto";
+            audio.addEventListener("loadeddata", () => {
+                this.audioElement = audio;
+                this.audioLoaded = true;
+                resolve();
+            });
+            audio.addEventListener("error", (e) => {
+                console.warn("Failed to load audio:", url, e);
+                this.audioLoaded = false;
+                // Don't reject - animation should still work without audio
+                resolve();
+            });
+            audio.load();
+        });
+    }
+    /**
+     * Process frames into tracks
+     */
+    processFrames() {
+        // Process bone frames
+        const allBoneKeyFrames = [];
+        for (const keyFrame of this.frames) {
+            for (const boneFrame of keyFrame.boneFrames) {
+                allBoneKeyFrames.push({
+                    boneFrame,
+                    time: keyFrame.time,
+                });
+            }
+        }
+        const boneKeyFramesByBone = new Map();
+        for (const { boneFrame, time } of allBoneKeyFrames) {
+            if (!boneKeyFramesByBone.has(boneFrame.boneName)) {
+                boneKeyFramesByBone.set(boneFrame.boneName, []);
+            }
+            boneKeyFramesByBone.get(boneFrame.boneName).push({ boneFrame, time });
+        }
+        for (const keyFrames of boneKeyFramesByBone.values()) {
+            keyFrames.sort((a, b) => a.time - b.time);
+        }
+        // Process morph frames
+        const allMorphKeyFrames = [];
+        for (const keyFrame of this.frames) {
+            for (const morphFrame of keyFrame.morphFrames) {
+                allMorphKeyFrames.push({
+                    morphFrame,
+                    time: keyFrame.time,
+                });
+            }
+        }
+        const morphKeyFramesByMorph = new Map();
+        for (const { morphFrame, time } of allMorphKeyFrames) {
+            if (!morphKeyFramesByMorph.has(morphFrame.morphName)) {
+                morphKeyFramesByMorph.set(morphFrame.morphName, []);
+            }
+            morphKeyFramesByMorph.get(morphFrame.morphName).push({ morphFrame, time });
+        }
+        for (const keyFrames of morphKeyFramesByMorph.values()) {
+            keyFrames.sort((a, b) => a.time - b.time);
+        }
+        // Store tracks
+        this.boneTracks = boneKeyFramesByBone;
+        this.morphTracks = morphKeyFramesByMorph;
+        // Calculate animation duration from max frame time
+        let maxFrameTime = 0;
+        for (const keyFrames of this.boneTracks.values()) {
+            if (keyFrames.length > 0) {
+                const lastTime = keyFrames[keyFrames.length - 1].time;
+                if (lastTime > maxFrameTime) {
+                    maxFrameTime = lastTime;
+                }
+            }
+        }
+        for (const keyFrames of this.morphTracks.values()) {
+            if (keyFrames.length > 0) {
+                const lastTime = keyFrames[keyFrames.length - 1].time;
+                if (lastTime > maxFrameTime) {
+                    maxFrameTime = lastTime;
+                }
+            }
+        }
+        this.duration = maxFrameTime > 0 ? maxFrameTime : 0;
+    }
+    /**
+     * Start or resume playback
+     */
+    play() {
+        if (this.frames.length === 0)
+            return;
+        if (this.isPaused) {
+            // Resume from paused position - don't adjust time, just continue from where we paused
+            this.isPaused = false;
+            // Adjust start time so current time calculation continues smoothly
+            this.startTime = performance.now() - this.currentTime * 1000;
+        }
+        else {
+            // Start from beginning or current seek position
+            this.startTime = performance.now() - this.currentTime * 1000;
+            this.pausedTime = 0;
+        }
+        this.isPlaying = true;
+        // Play audio if available
+        if (this.audioElement && this.audioLoaded) {
+            this.audioElement.currentTime = this.currentTime;
+            this.audioElement.play().catch((error) => {
+                console.warn("Audio play failed:", error);
+            });
+        }
+    }
+    /**
+     * Pause playback
+     */
+    pause() {
+        if (!this.isPlaying || this.isPaused)
+            return;
+        this.isPaused = true;
+        this.pauseStartTime = performance.now();
+        // Pause audio if available
+        if (this.audioElement) {
+            this.audioElement.pause();
+        }
+    }
+    /**
+     * Stop playback and reset to beginning
+     */
+    stop() {
+        this.isPlaying = false;
+        this.isPaused = false;
+        this.currentTime = 0;
+        this.startTime = 0;
+        this.pausedTime = 0;
+        // Stop audio if available
+        if (this.audioElement) {
+            this.audioElement.pause();
+            this.audioElement.currentTime = 0;
+        }
+    }
+    /**
+     * Seek to specific time
+     */
+    seek(time) {
+        const clampedTime = Math.max(0, Math.min(time, this.duration));
+        this.currentTime = clampedTime;
+        // Adjust start time if playing
+        if (this.isPlaying && !this.isPaused) {
+            this.startTime = performance.now() - clampedTime * 1000;
+            this.pausedTime = 0;
+        }
+        // Seek audio if available
+        if (this.audioElement && this.audioLoaded) {
+            this.audioElement.currentTime = clampedTime;
+        }
+    }
+    /**
+     * Update playback and return current pose
+     * Returns null if not playing, but returns current pose if paused
+     */
+    update(currentRealTime) {
+        if (!this.isPlaying || this.frames.length === 0) {
+            return null;
+        }
+        // If paused, return current pose at paused time (no time update)
+        if (this.isPaused) {
+            return this.getPoseAtTime(this.currentTime);
+        }
+        // Calculate current animation time
+        const elapsedSeconds = (currentRealTime - this.startTime) / 1000;
+        this.currentTime = elapsedSeconds;
+        // Check if animation ended
+        if (this.currentTime >= this.duration) {
+            this.currentTime = this.duration;
+            this.pause(); // Auto-pause at end
+            return this.getPoseAtTime(this.currentTime);
+        }
+        // Sync audio if present (with tolerance)
+        if (this.audioElement && this.audioLoaded) {
+            const audioTime = this.audioElement.currentTime;
+            const syncTolerance = 0.1; // 100ms tolerance
+            if (Math.abs(audioTime - this.currentTime) > syncTolerance) {
+                this.audioElement.currentTime = this.currentTime;
+            }
+        }
+        return this.getPoseAtTime(this.currentTime);
+    }
+    /**
+     * Get pose at specific time (pure function)
+     */
+    getPoseAtTime(time) {
+        const pose = {
+            boneRotations: new Map(),
+            boneTranslations: new Map(),
+            morphWeights: new Map(),
+        };
+        // Helper to find upper bound index (binary search)
+        const upperBoundFrameIndex = (time, keyFrames) => {
+            let left = 0;
+            let right = keyFrames.length;
+            while (left < right) {
+                const mid = Math.floor((left + right) / 2);
+                if (keyFrames[mid].time <= time) {
+                    left = mid + 1;
+                }
+                else {
+                    right = mid;
+                }
+            }
+            return left;
+        };
+        // Process each bone track
+        for (const [boneName, keyFrames] of this.boneTracks.entries()) {
+            if (keyFrames.length === 0)
+                continue;
+            // Clamp frame time to track range
+            const startTime = keyFrames[0].time;
+            const endTime = keyFrames[keyFrames.length - 1].time;
+            const clampedFrameTime = Math.max(startTime, Math.min(endTime, time));
+            const upperBoundIndex = upperBoundFrameIndex(clampedFrameTime, keyFrames);
+            const upperBoundIndexMinusOne = upperBoundIndex - 1;
+            if (upperBoundIndexMinusOne < 0)
+                continue;
+            const timeB = keyFrames[upperBoundIndex]?.time;
+            const boneFrameA = keyFrames[upperBoundIndexMinusOne].boneFrame;
+            if (timeB === undefined) {
+                // Last keyframe or beyond - use the last keyframe value
+                pose.boneRotations.set(boneName, boneFrameA.rotation);
+                pose.boneTranslations.set(boneName, boneFrameA.translation);
+            }
+            else {
+                // Interpolate between two keyframes
+                const timeA = keyFrames[upperBoundIndexMinusOne].time;
+                const boneFrameB = keyFrames[upperBoundIndex].boneFrame;
+                const gradient = (clampedFrameTime - timeA) / (timeB - timeA);
+                // Interpolate rotation using Bezier
+                const interp = boneFrameB.interpolation;
+                const rotWeight = bezierInterpolate(interp[0] / 127, // x1
+                interp[1] / 127, // x2
+                interp[2] / 127, // y1
+                interp[3] / 127, // y2
+                gradient);
+                const interpolatedRotation = Quat.slerp(boneFrameA.rotation, boneFrameB.rotation, rotWeight);
+                // Interpolate translation using Bezier (separate curves for X, Y, Z)
+                const xWeight = bezierInterpolate(interp[0] / 127, // X_x1
+                interp[8] / 127, // X_x2
+                interp[4] / 127, // X_y1
+                interp[12] / 127, // X_y2
+                gradient);
+                const yWeight = bezierInterpolate(interp[16] / 127, // Y_x1
+                interp[24] / 127, // Y_x2
+                interp[20] / 127, // Y_y1
+                interp[28] / 127, // Y_y2
+                gradient);
+                const zWeight = bezierInterpolate(interp[32] / 127, // Z_x1
+                interp[40] / 127, // Z_x2
+                interp[36] / 127, // Z_y1
+                interp[44] / 127, // Z_y2
+                gradient);
+                const interpolatedTranslation = new Vec3(boneFrameA.translation.x + (boneFrameB.translation.x - boneFrameA.translation.x) * xWeight, boneFrameA.translation.y + (boneFrameB.translation.y - boneFrameA.translation.y) * yWeight, boneFrameA.translation.z + (boneFrameB.translation.z - boneFrameA.translation.z) * zWeight);
+                pose.boneRotations.set(boneName, interpolatedRotation);
+                pose.boneTranslations.set(boneName, interpolatedTranslation);
+            }
+        }
+        // Helper to find upper bound index for morph frames
+        const upperBoundMorphIndex = (time, keyFrames) => {
+            let left = 0;
+            let right = keyFrames.length;
+            while (left < right) {
+                const mid = Math.floor((left + right) / 2);
+                if (keyFrames[mid].time <= time) {
+                    left = mid + 1;
+                }
+                else {
+                    right = mid;
+                }
+            }
+            return left;
+        };
+        // Process each morph track
+        for (const [morphName, keyFrames] of this.morphTracks.entries()) {
+            if (keyFrames.length === 0)
+                continue;
+            // Clamp frame time to track range
+            const startTime = keyFrames[0].time;
+            const endTime = keyFrames[keyFrames.length - 1].time;
+            const clampedFrameTime = Math.max(startTime, Math.min(endTime, time));
+            const upperBoundIndex = upperBoundMorphIndex(clampedFrameTime, keyFrames);
+            const upperBoundIndexMinusOne = upperBoundIndex - 1;
+            if (upperBoundIndexMinusOne < 0)
+                continue;
+            const timeB = keyFrames[upperBoundIndex]?.time;
+            const morphFrameA = keyFrames[upperBoundIndexMinusOne].morphFrame;
+            if (timeB === undefined) {
+                // Last keyframe or beyond - use the last keyframe value
+                pose.morphWeights.set(morphName, morphFrameA.weight);
+            }
+            else {
+                // Linear interpolation between two keyframes
+                const timeA = keyFrames[upperBoundIndexMinusOne].time;
+                const morphFrameB = keyFrames[upperBoundIndex].morphFrame;
+                const gradient = (clampedFrameTime - timeA) / (timeB - timeA);
+                const interpolatedWeight = morphFrameA.weight + (morphFrameB.weight - morphFrameA.weight) * gradient;
+                pose.morphWeights.set(morphName, interpolatedWeight);
+            }
+        }
+        return pose;
+    }
+    /**
+     * Get current playback progress
+     */
+    getProgress() {
+        return {
+            current: this.currentTime,
+            duration: this.duration,
+            percentage: this.duration > 0 ? (this.currentTime / this.duration) * 100 : 0,
+        };
+    }
+    /**
+     * Get current time
+     */
+    getCurrentTime() {
+        return this.currentTime;
+    }
+    /**
+     * Get animation duration
+     */
+    getDuration() {
+        return this.duration;
+    }
+    /**
+     * Check if playing
+     */
+    isPlayingState() {
+        return this.isPlaying && !this.isPaused;
+    }
+    /**
+     * Check if paused
+     */
+    isPausedState() {
+        return this.isPaused;
+    }
+    /**
+     * Check if has audio
+     */
+    hasAudio() {
+        return this.audioElement !== undefined && this.audioLoaded;
+    }
+    /**
+     * Set audio volume (0.0 to 1.0)
+     */
+    setVolume(volume) {
+        if (this.audioElement) {
+            this.audioElement.volume = Math.max(0, Math.min(1, volume));
+        }
+    }
+    /**
+     * Mute audio
+     */
+    mute() {
+        if (this.audioElement) {
+            this.audioElement.muted = true;
+        }
+    }
+    /**
+     * Unmute audio
+     */
+    unmute() {
+        if (this.audioElement) {
+            this.audioElement.muted = false;
+        }
+    }
+}

package/dist/pmx-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pmx-loader.d.ts","sourceRoot":"","sources":["../src/pmx-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAUN,MAAM,SAAS,CAAA;AAIhB,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,mBAAmB,CAAI;IAC/B,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,gBAAgB,CAAI;IAC5B,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,kBAAkB,CAAI;IAC9B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,mBAAmB,CAA4B;IACvD,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,WAAW,CAAY;IAC/B,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO;WAIM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAK9C,OAAO,CAAC,KAAK;IAiBb,OAAO,CAAC,WAAW;IA+CnB,OAAO,CAAC,aAAa;IA+FrB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,cAAc;IAyFtB,OAAO,CAAC,UAAU;IA2IlB,OAAO,CAAC,WAAW;IA+InB,OAAO,CAAC,iBAAiB;IAgDzB,OAAO,CAAC,gBAAgB;IAyFxB,OAAO,CAAC,WAAW;IAmGnB,OAAO,CAAC,kBAAkB;IAmC1B,OAAO,CAAC,OAAO;IAkLf,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,OAAO;IAmBf,OAAO,CAAC,QAAQ;CAIjB"}
+{"version":3,"file":"pmx-loader.d.ts","sourceRoot":"","sources":["../src/pmx-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAWN,MAAM,SAAS,CAAA;AAIhB,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,mBAAmB,CAAI;IAC/B,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,gBAAgB,CAAI;IAC5B,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,kBAAkB,CAAI;IAC9B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,mBAAmB,CAA4B;IACvD,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,WAAW,CAAY;IAC/B,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO;WAIM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAK9C,OAAO,CAAC,KAAK;IAiBb,OAAO,CAAC,WAAW;IA+CnB,OAAO,CAAC,aAAa;IA+FrB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,cAAc;IAyFtB,OAAO,CAAC,UAAU;IAsKlB,OAAO,CAAC,WAAW;IA+InB,OAAO,CAAC,iBAAiB;IAgDzB,OAAO,CAAC,gBAAgB;IAyFxB,OAAO,CAAC,WAAW;IAmGnB,OAAO,CAAC,kBAAkB;IAmC1B,OAAO,CAAC,OAAO;IAkLf,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,OAAO;IAmBf,OAAO,CAAC,QAAQ;CAIjB"}

package/dist/pmx-loader.js

@@ -336,55 +336,76 @@ export class PmxLoader {
                     this.getInt32();
                 }
                 // IK block
+                let ikTargetIndex = undefined;
+                let ikIteration = undefined;
+                let ikLimitAngle = undefined;
+                let ikLinks = undefined;
                 if ((flags & FLAG_IK) !== 0) {
-                    this.getNonVertexIndex(this.boneIndexSize); // target
-                    this.getInt32(); // iteration
-                    this.getFloat32(); // rotationConstraint
+                    ikTargetIndex = this.getNonVertexIndex(this.boneIndexSize); // target
+                    ikIteration = this.getInt32(); // iteration
+                    ikLimitAngle = this.getFloat32(); // rotationConstraint
                     const linksCount = this.getInt32();
+                    ikLinks = [];
                     for (let li = 0; li < linksCount; li++) {
-                        this.getNonVertexIndex(this.boneIndexSize); // link target
+                        const linkBoneIndex = this.getNonVertexIndex(this.boneIndexSize); // link target
                         const hasLimit = this.getUint8() === 1;
+                        let minAngle = undefined;
+                        let maxAngle = undefined;
                         if (hasLimit) {
                             // min and max angles (vec3 each)
-                            this.getFloat32();
-                            this.getFloat32();
-                            this.getFloat32();
-                            this.getFloat32();
-                            this.getFloat32();
-                            this.getFloat32();
+                            const minX = this.getFloat32();
+                            const minY = this.getFloat32();
+                            const minZ = this.getFloat32();
+                            const maxX = this.getFloat32();
+                            const maxY = this.getFloat32();
+                            const maxZ = this.getFloat32();
+                            minAngle = new Vec3(minX, minY, minZ);
+                            maxAngle = new Vec3(maxX, maxY, maxZ);
                         }
+                        ikLinks.push({
+                            boneIndex: linkBoneIndex,
+                            hasLimit,
+                            minAngle,
+                            maxAngle,
+                        });
                     }
                 }
                 // Stash minimal bone info; append data will be merged later
-                abs[i] = { name, parent: parentIndex, x, y, z, appendParent, appendRatio, appendRotate, appendMove };
+                abs[i] = {
+                    name,
+                    parent: parentIndex,
+                    x,
+                    y,
+                    z,
+                    appendParent,
+                    appendRatio,
+                    appendRotate,
+                    appendMove,
+                    ikTargetIndex,
+                    ikIteration,
+                    ikLimitAngle,
+                    ikLinks,
+                };
             }
             for (let i = 0; i < count; i++) {
                 const a = abs[i];
-                if (a.parent >= 0 && a.parent < count) {
-                    const p = abs[a.parent];
-                    bones.push({
-                        name: a.name,
-                        parentIndex: a.parent,
-                        bindTranslation: [a.x - p.x, a.y - p.y, a.z - p.z],
-                        children: [], // Will be populated later when building skeleton
-                        appendParentIndex: a.appendParent,
-                        appendRatio: a.appendRatio,
-                        appendRotate: a.appendRotate,
-                        appendMove: a.appendMove,
-                    });
-                }
-                else {
-                    bones.push({
-                        name: a.name,
-                        parentIndex: a.parent,
-                        bindTranslation: [a.x, a.y, a.z],
-                        children: [], // Will be populated later when building skeleton
-                        appendParentIndex: a.appendParent,
-                        appendRatio: a.appendRatio,
-                        appendRotate: a.appendRotate,
-                        appendMove: a.appendMove,
-                    });
-                }
+                const boneData = {
+                    name: a.name,
+                    parentIndex: a.parent,
+                    bindTranslation: a.parent >= 0 && a.parent < count
+                        ? [a.x - abs[a.parent].x, a.y - abs[a.parent].y, a.z - abs[a.parent].z]
+                        : [a.x, a.y, a.z],
+                    children: [], // Will be populated later when building skeleton
+                    appendParentIndex: a.appendParent,
+                    appendRatio: a.appendRatio,
+                    appendRotate: a.appendRotate,
+                    appendMove: a.appendMove,
+                    ikTargetIndex: a.ikTargetIndex,
+                    ikIteration: a.ikIteration,
+                    ikLimitAngle: a.ikLimitAngle,
+                    ikLinks: a.ikLinks,
+                };
+                bones.push(boneData);
             }
             this.bones = bones;
         }

package/dist/vmd-loader.d.ts

@@ -1,12 +1,20 @@
-import { Quat } from "./math";
+import { Quat, Vec3 } from "./math";
 export interface BoneFrame {
     boneName: string;
     frame: number;
     rotation: Quat;
+    translation: Vec3;
+    interpolation: Uint8Array;
+}
+export interface MorphFrame {
+    morphName: string;
+    frame: number;
+    weight: number;
 }
 export interface VMDKeyFrame {
     time: number;
     boneFrames: BoneFrame[];
+    morphFrames: MorphFrame[];
 }
 export declare class VMDLoader {
     private view;
@@ -17,6 +25,8 @@ export declare class VMDLoader {
     static loadFromBuffer(buffer: ArrayBuffer): VMDKeyFrame[];
     private parse;
     private readBoneFrame;
+    private readMorphFrame;
+    private getUint8;
     private getUint32;
     private getFloat32;
     private getString;

package/dist/vmd-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vmd-loader.d.ts","sourceRoot":"","sources":["../src/vmd-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,IAAI,CAAA;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,SAAS,EAAE,CAAA;CACxB;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAa;IAE5B,OAAO;WAWM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAKtD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,EAAE;IAKzD,OAAO,CAAC,KAAK;IA8Db,OAAO,CAAC,aAAa;IA+CrB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,IAAI;CAMb"}
+{"version":3,"file":"vmd-loader.d.ts","sourceRoot":"","sources":["../src/vmd-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAEnC,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,IAAI,CAAA;IACd,WAAW,EAAE,IAAI,CAAA;IACjB,aAAa,EAAE,UAAU,CAAA;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,WAAW,EAAE,UAAU,EAAE,CAAA;CAC1B;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAa;IAE5B,OAAO;WAWM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAKtD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,EAAE;IAKzD,OAAO,CAAC,KAAK;IAgGb,OAAO,CAAC,aAAa;IAuDrB,OAAO,CAAC,cAAc;IAqCtB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,IAAI;CAMb"}