reze-engine 0.3.10 → 0.3.12

package/dist/player.d.ts

@@ -1,64 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,220 +0,0 @@
-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/src/player.ts

@@ -1,290 +0,0 @@
-import { Quat, Vec3, bezierInterpolate } from "./math"
-import { BoneFrame, MorphFrame, VMDKeyFrame, VMDLoader } from "./vmd-loader"
-
-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 class Player {
-  // Animation data
-  private frames: VMDKeyFrame[] = []
-  private boneTracks: Map<string, Array<{ boneFrame: BoneFrame; time: number }>> = new Map()
-  private morphTracks: Map<string, Array<{ morphFrame: MorphFrame; time: number }>> = new Map()
-  private _duration: number = 0
-
-  // Playback state
-  private isPlaying: boolean = false
-  private isPaused: boolean = false
-  private _currentTime: number = 0
-
-  // Timing
-  private startTime: number = 0 // Real-time when playback started
-
-  /**
-   * Load VMD animation file
-   */
-  async loadVmd(vmdUrl: string): Promise<void> {
-    // Load animation
-    this.frames = await VMDLoader.load(vmdUrl)
-    this.processFrames()
-  }
-
-  /**
-   * Process frames into tracks
-   */
-  private processFrames(): void {
-    // Helper to group frames by name and sort by time
-    const groupFrames = <T>(
-      items: Array<{ item: T; name: string; time: number }>
-    ): Map<string, Array<{ item: T; time: number }>> => {
-      const tracks = new Map<string, Array<{ item: T; time: number }>>()
-      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: Array<{ item: BoneFrame; name: string; time: number }> = []
-    const morphItems: Array<{ item: MorphFrame; name: string; time: number }> = []
-
-    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(): void {
-    if (this.frames.length === 0) return
-
-    this.isPaused = false
-    this.startTime = performance.now() - this._currentTime * 1000
-
-    this.isPlaying = true
-  }
-
-  /**
-   * Pause playback
-   */
-  pause(): void {
-    if (!this.isPlaying || this.isPaused) return
-    this.isPaused = true
-  }
-
-  /**
-   * Stop playback and reset to beginning
-   */
-  stop(): void {
-    this.isPlaying = false
-    this.isPaused = false
-    this._currentTime = 0
-    this.startTime = 0
-  }
-
-  /**
-   * Seek to specific time
-   */
-  seek(time: number): void {
-    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: number): AnimationPose | null {
-    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: number): AnimationPose {
-    const pose: AnimationPose = {
-      boneRotations: new Map(),
-      boneTranslations: new Map(),
-      morphWeights: new Map(),
-    }
-
-    // Generic binary search for upper bound
-    const upperBound = <T extends { time: number }>(time: number, keyFrames: T[]): number => {
-      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: number, b: number, w: number) => a + (b - a) * w
-        const getWeight = (offset: number) =>
-          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(): AnimationProgress {
-    return {
-      current: this._currentTime,
-      duration: this._duration,
-      percentage: this._duration > 0 ? (this._currentTime / this._duration) * 100 : 0,
-    }
-  }
-
-  get currentTime(): number {
-    return this._currentTime
-  }
-
-  get duration(): number {
-    return this._duration
-  }
-
-  get isPlayingState(): boolean {
-    return this.isPlaying && !this.isPaused
-  }
-
-  get isPausedState(): boolean {
-    return this.isPaused
-  }
-}