chart-preview 1.1.0 → 1.3.0

package/src/ChartPreview.ts

@@ -33,19 +33,29 @@ function isImageDecoderSupported(): boolean {
   return typeof ImageDecoder !== "undefined";
 }
 
+/**
+ * Check if animations are supported on this browser.
+ * Use this to conditionally enable/disable animation features.
+ */
+export function areAnimationsSupported(): boolean {
+  return isImageDecoderSupported();
+}
+
 /**
  * Manages an animated WebP texture using the ImageDecoder API.
+ * Pre-decodes all frames during initialization for optimal performance.
  * Falls back to a static texture if ImageDecoder is not supported.
  */
 class AnimatedTexture {
   private canvas: HTMLCanvasElement;
   private ctx: CanvasRenderingContext2D;
   public texture: THREE.CanvasTexture;
-  private decoder: ImageDecoder | null = null;
   private frameIndex = 0;
   private frameCount = 0;
   private lastFrameTime = 0;
   private frameDurations: number[] = [];
+  /** Pre-decoded frames stored as ImageBitmap for fast synchronous access */
+  private frameCache: ImageBitmap[] = [];
   private isAnimated = false;
   private disposed = false;
 
@@ -61,12 +71,12 @@ class AnimatedTexture {
   /**
    * Creates an AnimatedTexture from a URL.
    * Uses ImageDecoder for animation if available, otherwise loads as static texture.
+   * Pre-decodes all frames during initialization for optimal render performance.
    */
   static async create(url: string): Promise<AnimatedTexture | THREE.Texture> {
     if (!isImageDecoderSupported()) {
       // Fall back to static texture loading
-      const textureLoader = new THREE.TextureLoader();
-      return textureLoader.loadAsync(url);
+      return loadStaticTexture(url);
     }
 
     try {
@@ -80,8 +90,7 @@ class AnimatedTexture {
       const isSupported = await ImageDecoder.isTypeSupported(contentType);
       if (!isSupported) {
         // Fall back to static texture
-        const textureLoader = new THREE.TextureLoader();
-        return textureLoader.loadAsync(url);
+        return loadStaticTexture(url);
       }
 
       const decoder = new ImageDecoder({
@@ -113,37 +122,56 @@ class AnimatedTexture {
         return animTexture.texture;
       }
 
-      // Animated image - decode first frame and set up animation
+      // Animated image - pre-decode ALL frames for optimal performance
       const firstResult = await decoder.decode({ frameIndex: 0 });
       const firstFrame = firstResult.image;
       const animTexture = new AnimatedTexture(
         firstFrame.displayWidth,
         firstFrame.displayHeight
       );
-      animTexture.ctx.drawImage(firstFrame, 0, 0);
-      animTexture.texture.needsUpdate = true;
 
-      animTexture.decoder = decoder;
-      animTexture.frameCount = frameCount;
-      animTexture.isAnimated = true;
-
-      // Pre-decode frame durations
+      // Pre-decode all frames into ImageBitmap cache
       animTexture.frameDurations = [];
+      animTexture.frameCache = [];
+
       for (let i = 0; i < frameCount; i++) {
         try {
           const frameResult = await decoder.decode({ frameIndex: i });
+          const videoFrame = frameResult.image;
+
+          // Create an ImageBitmap from the VideoFrame for fast synchronous access
+          const bitmap = await createImageBitmap(videoFrame);
+          animTexture.frameCache.push(bitmap);
+
           // Duration is in microseconds, convert to milliseconds
-          const durationMs = (frameResult.image.duration ?? 100000) / 1000;
+          const durationMs = (videoFrame.duration ?? 100000) / 1000;
           animTexture.frameDurations.push(durationMs);
-          frameResult.image.close();
+          videoFrame.close();
         } catch {
           animTexture.frameDurations.push(100); // Default 100ms
+          // If frame decode fails, reuse the last successful frame or create empty bitmap
+          if (animTexture.frameCache.length > 0) {
+            animTexture.frameCache.push(
+              animTexture.frameCache[animTexture.frameCache.length - 1]
+            );
+          }
         }
       }
 
-      firstFrame.close();
+      // Draw the first frame
+      if (animTexture.frameCache.length > 0) {
+        animTexture.ctx.drawImage(animTexture.frameCache[0], 0, 0);
+        animTexture.texture.needsUpdate = true;
+      }
+
+      animTexture.frameCount = animTexture.frameCache.length;
+      animTexture.isAnimated = animTexture.frameCount > 1;
       animTexture.lastFrameTime = performance.now();
 
+      // Close the decoder - we no longer need it since all frames are cached
+      firstFrame.close();
+      decoder.close();
+
       return animTexture;
     } catch (error) {
       // Fall back to static texture on any error
@@ -151,17 +179,17 @@ class AnimatedTexture {
         "Failed to load animated texture, falling back to static:",
         error
       );
-      const textureLoader = new THREE.TextureLoader();
-      return textureLoader.loadAsync(url);
+      return loadStaticTexture(url);
     }
   }
 
   /**
    * Updates the texture to the current animation frame based on elapsed time.
-   * Call this each frame in the render loop.
+   * This method is SYNCHRONOUS for optimal render performance - all frames
+   * are pre-decoded during initialization.
    */
-  async tick(): Promise<void> {
-    if (!this.isAnimated || !this.decoder || this.disposed) {
+  tick(): void {
+    if (!this.isAnimated || this.disposed || this.frameCache.length === 0) {
       return;
     }
 
@@ -173,16 +201,12 @@ class AnimatedTexture {
       this.frameIndex = (this.frameIndex + 1) % this.frameCount;
       this.lastFrameTime = now;
 
-      try {
-        const result = await this.decoder.decode({
-          frameIndex: this.frameIndex,
-        });
+      // Synchronous frame update from pre-decoded cache
+      const frame = this.frameCache[this.frameIndex];
+      if (frame) {
         this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
-        this.ctx.drawImage(result.image, 0, 0);
+        this.ctx.drawImage(frame, 0, 0);
         this.texture.needsUpdate = true;
-        result.image.close();
-      } catch {
-        // Frame decode failed, skip this frame
       }
     }
   }
@@ -192,14 +216,49 @@ class AnimatedTexture {
    */
   dispose(): void {
     this.disposed = true;
-    if (this.decoder) {
-      this.decoder.close();
-      this.decoder = null;
+    // Close all cached ImageBitmaps
+    for (const bitmap of this.frameCache) {
+      bitmap.close();
     }
+    this.frameCache = [];
     this.texture.dispose();
   }
 }
 
+/**
+ * Loads a static texture from a URL with proper error handling.
+ * Creates a fallback placeholder texture if loading fails.
+ */
+async function loadStaticTexture(url: string): Promise<THREE.Texture> {
+  const textureLoader = new THREE.TextureLoader();
+  try {
+    const texture = await textureLoader.loadAsync(url);
+    texture.colorSpace = THREE.SRGBColorSpace;
+    return texture;
+  } catch (error) {
+    console.warn(`Failed to load static texture from ${url}:`, error);
+    // Create a small placeholder texture so notes still render
+    return createPlaceholderTexture();
+  }
+}
+
+/**
+ * Creates a placeholder texture (magenta square) for missing textures.
+ * This ensures notes always render even if texture loading fails.
+ */
+function createPlaceholderTexture(): THREE.Texture {
+  const canvas = document.createElement("canvas");
+  canvas.width = 32;
+  canvas.height = 32;
+  const ctx = canvas.getContext("2d")!;
+  // Draw a magenta square to make missing textures obvious
+  ctx.fillStyle = "#FF00FF";
+  ctx.fillRect(0, 0, 32, 32);
+  const texture = new THREE.CanvasTexture(canvas);
+  texture.colorSpace = THREE.SRGBColorSpace;
+  return texture;
+}
+
 /** Collection of animated textures that need to be ticked each frame */
 class AnimatedTextureManager {
   private animatedTextures: AnimatedTexture[] = [];
@@ -210,8 +269,13 @@ class AnimatedTextureManager {
     }
   }
 
-  async tick(): Promise<void> {
-    await Promise.all(this.animatedTextures.map((t) => t.tick()));
+  /**
+   * Updates all animated textures. This is now SYNCHRONOUS for optimal performance.
+   */
+  tick(): void {
+    for (const texture of this.animatedTextures) {
+      texture.tick();
+    }
   }
 
   dispose(): void {
@@ -445,6 +509,19 @@ export class ChartPreview {
     return this.audioManager.chartEndTimeMs;
   }
 
+  /**
+   * Manually triggers a resize of the camera and renderer.
+   * Call this when the container size changes (e.g., entering/exiting fullscreen).
+   */
+  resize() {
+    this.camera.triggerResize();
+    this.renderer.triggerResize();
+    // Re-render a frame to immediately show the updated size
+    if (this.paused) {
+      this.animateFrame(false);
+    }
+  }
+
   /**
    * Cleans up all resources. Call this when discarding the preview.
    * The preview should not be used after calling dispose().
@@ -554,6 +631,11 @@ class ChartCamera extends THREE.PerspectiveCamera {
     this.updateProjectionMatrix();
   }
 
+  /** Manually trigger a resize update */
+  triggerResize() {
+    this.onResize();
+  }
+
   dispose() {
     window.removeEventListener("resize", this.resizeListener);
     this.clear();
@@ -578,6 +660,11 @@ class ChartRenderer extends THREE.WebGLRenderer {
     this.setSize(width, height);
   }
 
+  /** Manually trigger a resize update */
+  triggerResize() {
+    this.onResize();
+  }
+
   override dispose() {
     window.removeEventListener("resize", this.resizeListener);
     super.dispose();
@@ -1062,6 +1149,17 @@ class NotesManager {
       i++
     ) {
       const note = this.noteEvents[i];
+
+      // Get the material for this note type and flags
+      const material = this.noteMaterials.get(note.type)?.get(note.flags);
+      if (!material) {
+        // Skip notes with missing textures (shouldn't happen, but prevents crashes)
+        console.warn(
+          `Missing texture for note type ${note.type} with flags ${note.flags}`
+        );
+        continue;
+      }
+
       const noteGroup = new THREE.Group();
       const scale =
         note.type === noteTypes.kick
@@ -1070,9 +1168,7 @@ class NotesManager {
             this.instrumentType === instrumentTypes.sixFret
           ? 0.04
           : SCALE;
-      const sprite = new THREE.Sprite(
-        this.noteMaterials.get(note.type)!.get(note.flags)!
-      );
+      const sprite = new THREE.Sprite(material);
       noteGroup.add(sprite);
       sprite.center = new THREE.Vector2(
         note.type === noteTypes.kick ? 0.62 : 0.5,
@@ -1177,12 +1273,27 @@ class EventSequence<
   }
 }
 
+export interface LoadTexturesOptions {
+  /**
+   * Whether to enable animated textures.
+   * When true (default), uses ImageDecoder API for animated WebP if available.
+   * When false, always loads static textures for better performance.
+   * Use `areAnimationsSupported()` to check if animations are supported on the current browser.
+   */
+  animationsEnabled?: boolean;
+}
+
 /**
  * Loads all required textures for the chart preview.
  * @param instrumentType The type of instrument to load textures for
+ * @param options Optional configuration for texture loading
  * @returns An object containing highway, strikeline, note textures, and animated texture manager
  */
-async function loadTextures(instrumentType: InstrumentType) {
+async function loadTextures(
+  instrumentType: InstrumentType,
+  options: LoadTexturesOptions = {}
+) {
+  const { animationsEnabled = true } = options;
   const textureLoader = new THREE.TextureLoader();
   const animatedTextureManager = new AnimatedTextureManager();
 
@@ -1192,9 +1303,16 @@ async function loadTextures(instrumentType: InstrumentType) {
   /**
    * Loads a texture with animation support.
    * Uses ImageDecoder API for animated WebP when available, falls back to static.
+   * If animationsEnabled is false, always loads static textures.
    */
   const loadAnimated = async (path: string): Promise<THREE.Texture> => {
     const url = `https://static.enchor.us/preview-${path}.webp`;
+
+    // If animations are disabled, load static texture directly
+    if (!animationsEnabled) {
+      return loadStaticTexture(url);
+    }
+
     const result = await AnimatedTexture.create(url);
 
     if (result instanceof AnimatedTexture) {

package/src/ChartPreviewPlayer.ts

@@ -357,6 +357,11 @@ export class ChartPreviewPlayer extends HTMLElement {
   connectedCallback() {
     this.setAttribute("tabindex", "0");
     document.addEventListener("fullscreenchange", this.handleFullscreenChange);
+    // Safari uses webkit prefix
+    document.addEventListener(
+      "webkitfullscreenchange",
+      this.handleFullscreenChange
+    );
   }
 
   disconnectedCallback() {
@@ -365,6 +370,10 @@ export class ChartPreviewPlayer extends HTMLElement {
       "fullscreenchange",
       this.handleFullscreenChange
     );
+    document.removeEventListener(
+      "webkitfullscreenchange",
+      this.handleFullscreenChange
+    );
     this.removeEventListener("keydown", this.handleKeydown);
   }
 
@@ -467,8 +476,9 @@ export class ChartPreviewPlayer extends HTMLElement {
       }
     });
 
-    // Fullscreen button
-    this.fullscreenBtn.addEventListener("click", () => {
+    // Fullscreen button - stop propagation to prevent any parent handlers
+    this.fullscreenBtn.addEventListener("click", (e) => {
+      e.stopPropagation();
       this.toggleFullscreen();
     });
 
@@ -525,14 +535,32 @@ export class ChartPreviewPlayer extends HTMLElement {
   };
 
   private handleFullscreenChange = () => {
-    this._isFullscreen = document.fullscreenElement === this.container;
+    // Check if we're in fullscreen mode (support both standard and webkit prefix)
+    const fullscreenElement =
+      document.fullscreenElement ||
+      (document as unknown as { webkitFullscreenElement?: Element })
+        .webkitFullscreenElement;
+    this._isFullscreen =
+      fullscreenElement !== null && fullscreenElement !== undefined;
     this.container.classList.toggle("fullscreen", this._isFullscreen);
     this.fullscreenBtn.innerHTML = this._isFullscreen
       ? ICONS.fullscreenExit
       : ICONS.fullscreen;
     this.fullscreenBtn.title = this._isFullscreen
       ? "Exit fullscreen"
-      : "Toggle fullscreen";
+      : "Enter fullscreen";
+
+    // Trigger resize on the chart preview after a short delay
+    // to ensure the container dimensions have updated
+    if (this.chartPreview) {
+      // Use requestAnimationFrame to ensure DOM has updated
+      requestAnimationFrame(() => {
+        // Double RAF to ensure layout has been recalculated
+        requestAnimationFrame(() => {
+          this.chartPreview?.resize();
+        });
+      });
+    }
   };
 
   private onSeekStart() {
@@ -900,7 +928,8 @@ export class ChartPreviewPlayer extends HTMLElement {
         files,
         config.instrument,
         config.difficulty,
-        config.initialSeekPercent
+        config.initialSeekPercent,
+        { animationsEnabled: config.animationsEnabled }
       );
 
       // Load the chart
@@ -948,7 +977,8 @@ export class ChartPreviewPlayer extends HTMLElement {
         files,
         config.instrument,
         config.difficulty,
-        config.initialSeekPercent
+        config.initialSeekPercent,
+        { animationsEnabled: config.animationsEnabled }
       );
 
       // Load the chart
@@ -992,7 +1022,8 @@ export class ChartPreviewPlayer extends HTMLElement {
         config.files,
         config.instrument,
         config.difficulty,
-        config.initialSeekPercent
+        config.initialSeekPercent,
+        { animationsEnabled: config.animationsEnabled }
       );
 
       // Load the chart
@@ -1105,12 +1136,46 @@ export class ChartPreviewPlayer extends HTMLElement {
    * Toggle fullscreen mode
    */
   async toggleFullscreen(): Promise<void> {
-    if (!document.fullscreenEnabled) return;
+    // Check for fullscreen support (standard and webkit)
+    const doc = document as unknown as {
+      fullscreenEnabled?: boolean;
+      webkitFullscreenEnabled?: boolean;
+      fullscreenElement?: Element;
+      webkitFullscreenElement?: Element;
+      exitFullscreen?: () => Promise<void>;
+      webkitExitFullscreen?: () => void;
+    };
+    const container = this.container as unknown as {
+      requestFullscreen?: () => Promise<void>;
+      webkitRequestFullscreen?: () => void;
+    };
+
+    const isFullscreenEnabled =
+      doc.fullscreenEnabled || doc.webkitFullscreenEnabled;
+    if (!isFullscreenEnabled) return;
+
+    const fullscreenElement =
+      doc.fullscreenElement || doc.webkitFullscreenElement;
 
-    if (this._isFullscreen) {
-      await document.exitFullscreen();
-    } else {
-      await this.container.requestFullscreen();
+    try {
+      if (fullscreenElement) {
+        // Exit fullscreen
+        if (doc.exitFullscreen) {
+          await doc.exitFullscreen();
+        } else if (doc.webkitExitFullscreen) {
+          doc.webkitExitFullscreen();
+        }
+      } else {
+        // Enter fullscreen
+        if (container.requestFullscreen) {
+          await container.requestFullscreen();
+        } else if (container.webkitRequestFullscreen) {
+          container.webkitRequestFullscreen();
+        }
+      }
+    } catch (error) {
+      // Fullscreen request can fail due to user gesture requirements or other reasons
+      console.warn("Fullscreen toggle failed:", error);
     }
   }
 

package/src/SngLoader.ts

@@ -7,7 +7,11 @@ import {
   type Instrument,
   type ScannedChart,
 } from "scan-chart";
-import { ChartPreview, type ParsedChart } from "./ChartPreview";
+import {
+  ChartPreview,
+  type LoadTexturesOptions,
+  type ParsedChart,
+} from "./ChartPreview";
 
 /**
  * Audio file extensions supported by the chart preview.
@@ -33,6 +37,11 @@ export interface LoadFromUrlConfig {
   initialSeekPercent?: number;
   /** AbortSignal to cancel the fetch operation */
   signal?: AbortSignal;
+  /**
+   * Whether to enable animated textures. Defaults to true.
+   * Set to false for better performance or when animations aren't supported.
+   */
+  animationsEnabled?: boolean;
 }
 
 /**
@@ -47,6 +56,11 @@ export interface LoadFromSngFileConfig {
   difficulty: Difficulty;
   /** Initial seek position as a percentage (0-1). Defaults to 0. */
   initialSeekPercent?: number;
+  /**
+   * Whether to enable animated textures. Defaults to true.
+   * Set to false for better performance or when animations aren't supported.
+   */
+  animationsEnabled?: boolean;
 }
 
 /**
@@ -61,6 +75,11 @@ export interface LoadFromChartFilesConfig {
   difficulty: Difficulty;
   /** Initial seek position as a percentage (0-1). Defaults to 0. */
   initialSeekPercent?: number;
+  /**
+   * Whether to enable animated textures. Defaults to true.
+   * Set to false for better performance or when animations aren't supported.
+   */
+  animationsEnabled?: boolean;
 }
 
 /**
@@ -218,13 +237,15 @@ export function isVideoFile(fileName: string): boolean {
  * @param instrument - The instrument to display
  * @param difficulty - The difficulty level to display
  * @param initialSeekPercent - Initial seek position (0-1)
+ * @param textureOptions - Options for texture loading (e.g., animations enabled)
  * @returns Prepared chart data ready for the player
  */
 export async function prepareChartData(
   files: { fileName: string; data: Uint8Array }[],
   instrument: Instrument,
   difficulty: Difficulty,
-  initialSeekPercent = 0
+  initialSeekPercent = 0,
+  textureOptions: LoadTexturesOptions = {}
 ): Promise<PreparedChartData> {
   // Filter out video files
   const filteredFiles = files.filter((f) => !isVideoFile(f.fileName));
@@ -276,7 +297,10 @@ export async function prepareChartData(
 
   // Load textures for the instrument type
   const instrumentType = getInstrumentType(instrument);
-  const textures = await ChartPreview.loadTextures(instrumentType);
+  const textures = await ChartPreview.loadTextures(
+    instrumentType,
+    textureOptions
+  );
 
   // Calculate audio length from the last note or from metadata
   const lastNote = parsedChart.trackData

package/src/index.ts

@@ -1,8 +1,10 @@
 // Core classes
 export {
   ChartPreview,
+  areAnimationsSupported,
   type ChartPreviewConfig,
   type ChartPreviewEvents,
+  type LoadTexturesOptions,
   type ParsedChart,
 } from "./ChartPreview";