reze-engine 0.3.12 → 0.3.14

package/dist/player.d.ts

@@ -0,0 +1,64 @@
+import { Quat, Vec3 } from "./math";
+export interface AnimationPose {
+    boneRotations: Map<string, Quat>;
+    boneTranslations: Map<string, Vec3>;
+    morphWeights: Map<string, number>;
+}
+export interface AnimationProgress {
+    current: number;
+    duration: number;
+    percentage: number;
+}
+export declare class Player {
+    private frames;
+    private boneTracks;
+    private morphTracks;
+    private _duration;
+    private isPlaying;
+    private isPaused;
+    private _currentTime;
+    private startTime;
+    /**
+     * Load VMD animation file
+     */
+    loadVmd(vmdUrl: string): Promise<void>;
+    /**
+     * Process frames into tracks
+     */
+    private processFrames;
+    /**
+     * Start or resume playback
+     * Note: For iOS, this should be called synchronously from a user interaction event
+     */
+    play(): void;
+    /**
+     * Pause playback
+     */
+    pause(): void;
+    /**
+     * Stop playback and reset to beginning
+     */
+    stop(): void;
+    /**
+     * Seek to specific time
+     */
+    seek(time: number): void;
+    /**
+     * Update playback and return current pose
+     * Returns null if not playing, but returns current pose if paused
+     */
+    update(currentRealTime: number): AnimationPose | null;
+    /**
+     * Get pose at specific time (pure function)
+     */
+    getPoseAtTime(time: number): AnimationPose;
+    /**
+     * Get current playback progress
+     */
+    getProgress(): AnimationProgress;
+    get currentTime(): number;
+    get duration(): number;
+    get isPlayingState(): boolean;
+    get isPausedState(): boolean;
+}
+//# sourceMappingURL=player.d.ts.map

package/dist/player.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"player.d.ts","sourceRoot":"","sources":["../src/player.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAqB,MAAM,QAAQ,CAAA;AAGtD,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IAChC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IACnC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,MAAM;IAEjB,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,UAAU,CAAwE;IAC1F,OAAO,CAAC,WAAW,CAA0E;IAC7F,OAAO,CAAC,SAAS,CAAY;IAG7B,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,YAAY,CAAY;IAGhC,OAAO,CAAC,SAAS,CAAY;IAE7B;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM5C;;OAEG;IACH,OAAO,CAAC,aAAa;IAsDrB;;;OAGG;IACH,IAAI,IAAI,IAAI;IASZ;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,IAAI,IAAI,IAAI;IAOZ;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IASxB;;;OAGG;IACH,MAAM,CAAC,eAAe,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAwBrD;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa;IA6F1C;;OAEG;IACH,WAAW,IAAI,iBAAiB;IAQhC,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,cAAc,IAAI,OAAO,CAE5B;IAED,IAAI,aAAa,IAAI,OAAO,CAE3B;CACF"}

package/dist/player.js

@@ -0,0 +1,220 @@
+import { Quat, Vec3, bezierInterpolate } 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
+    }
+    /**
+     * Load VMD animation file
+     */
+    async loadVmd(vmdUrl) {
+        // Load animation
+        this.frames = await VMDLoader.load(vmdUrl);
+        this.processFrames();
+    }
+    /**
+     * Process frames into tracks
+     */
+    processFrames() {
+        // Helper to group frames by name and sort by time
+        const groupFrames = (items) => {
+            const tracks = new Map();
+            for (const { item, name, time } of items) {
+                if (!tracks.has(name))
+                    tracks.set(name, []);
+                tracks.get(name).push({ item, time });
+            }
+            for (const keyFrames of tracks.values()) {
+                keyFrames.sort((a, b) => a.time - b.time);
+            }
+            return tracks;
+        };
+        // Collect all bone and morph frames
+        const boneItems = [];
+        const morphItems = [];
+        for (const keyFrame of this.frames) {
+            for (const boneFrame of keyFrame.boneFrames) {
+                boneItems.push({ item: boneFrame, name: boneFrame.boneName, time: keyFrame.time });
+            }
+            for (const morphFrame of keyFrame.morphFrames) {
+                morphItems.push({ item: morphFrame, name: morphFrame.morphName, time: keyFrame.time });
+            }
+        }
+        // Transform to expected format
+        this.boneTracks = new Map();
+        for (const [name, frames] of groupFrames(boneItems).entries()) {
+            this.boneTracks.set(name, frames.map((f) => ({ boneFrame: f.item, time: f.time })));
+        }
+        this.morphTracks = new Map();
+        for (const [name, frames] of groupFrames(morphItems).entries()) {
+            this.morphTracks.set(name, frames.map((f) => ({ morphFrame: f.item, time: f.time })));
+        }
+        // Calculate duration from all tracks
+        const allTracks = [...this.boneTracks.values(), ...this.morphTracks.values()];
+        this._duration = allTracks.reduce((max, keyFrames) => {
+            const lastTime = keyFrames[keyFrames.length - 1]?.time ?? 0;
+            return Math.max(max, lastTime);
+        }, 0);
+    }
+    /**
+     * Start or resume playback
+     * Note: For iOS, this should be called synchronously from a user interaction event
+     */
+    play() {
+        if (this.frames.length === 0)
+            return;
+        this.isPaused = false;
+        this.startTime = performance.now() - this._currentTime * 1000;
+        this.isPlaying = true;
+    }
+    /**
+     * Pause playback
+     */
+    pause() {
+        if (!this.isPlaying || this.isPaused)
+            return;
+        this.isPaused = true;
+    }
+    /**
+     * Stop playback and reset to beginning
+     */
+    stop() {
+        this.isPlaying = false;
+        this.isPaused = false;
+        this._currentTime = 0;
+        this.startTime = 0;
+    }
+    /**
+     * Seek to specific time
+     */
+    seek(time) {
+        const clampedTime = Math.max(0, Math.min(time, this._duration));
+        this._currentTime = clampedTime;
+        if (this.isPlaying && !this.isPaused) {
+            this.startTime = performance.now() - clampedTime * 1000;
+        }
+    }
+    /**
+     * 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);
+        }
+        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(),
+        };
+        // Generic binary search for upper bound
+        const upperBound = (time, keyFrames) => {
+            let left = 0, 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 bone tracks
+        for (const [boneName, keyFrames] of this.boneTracks.entries()) {
+            if (keyFrames.length === 0)
+                continue;
+            const clampedTime = Math.max(keyFrames[0].time, Math.min(keyFrames[keyFrames.length - 1].time, time));
+            const idx = upperBound(clampedTime, keyFrames) - 1;
+            if (idx < 0)
+                continue;
+            const frameA = keyFrames[idx].boneFrame;
+            const frameB = keyFrames[idx + 1]?.boneFrame;
+            if (!frameB) {
+                pose.boneRotations.set(boneName, frameA.rotation);
+                pose.boneTranslations.set(boneName, frameA.translation);
+            }
+            else {
+                const timeA = keyFrames[idx].time;
+                const timeB = keyFrames[idx + 1].time;
+                const gradient = (clampedTime - timeA) / (timeB - timeA);
+                const interp = frameB.interpolation;
+                pose.boneRotations.set(boneName, Quat.slerp(frameA.rotation, frameB.rotation, bezierInterpolate(interp[0] / 127, interp[1] / 127, interp[2] / 127, interp[3] / 127, gradient)));
+                const lerp = (a, b, w) => a + (b - a) * w;
+                const getWeight = (offset) => bezierInterpolate(interp[offset] / 127, interp[offset + 8] / 127, interp[offset + 4] / 127, interp[offset + 12] / 127, gradient);
+                pose.boneTranslations.set(boneName, new Vec3(lerp(frameA.translation.x, frameB.translation.x, getWeight(0)), lerp(frameA.translation.y, frameB.translation.y, getWeight(16)), lerp(frameA.translation.z, frameB.translation.z, getWeight(32))));
+            }
+        }
+        // Process morph tracks
+        for (const [morphName, keyFrames] of this.morphTracks.entries()) {
+            if (keyFrames.length === 0)
+                continue;
+            const clampedTime = Math.max(keyFrames[0].time, Math.min(keyFrames[keyFrames.length - 1].time, time));
+            const idx = upperBound(clampedTime, keyFrames) - 1;
+            if (idx < 0)
+                continue;
+            const frameA = keyFrames[idx].morphFrame;
+            const frameB = keyFrames[idx + 1]?.morphFrame;
+            if (!frameB) {
+                pose.morphWeights.set(morphName, frameA.weight);
+            }
+            else {
+                const timeA = keyFrames[idx].time;
+                const timeB = keyFrames[idx + 1].time;
+                const gradient = (clampedTime - timeA) / (timeB - timeA);
+                pose.morphWeights.set(morphName, frameA.weight + (frameB.weight - frameA.weight) * gradient);
+            }
+        }
+        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 currentTime() {
+        return this._currentTime;
+    }
+    get duration() {
+        return this._duration;
+    }
+    get isPlayingState() {
+        return this.isPlaying && !this.isPaused;
+    }
+    get isPausedState() {
+        return this.isPaused;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "reze-engine",
-    "version": "0.3.12",
+    "version": "0.3.14",
     "description": "A WebGPU-based MMD model renderer",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",