chart-preview 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -38,13 +38,17 @@ var NOTE_SPAN_WIDTH = 0.95;
 function isImageDecoderSupported() {
   return typeof ImageDecoder !== "undefined";
 }
+function areAnimationsSupported() {
+  return isImageDecoderSupported();
+}
 var AnimatedTexture = class {
   constructor(width, height) {
-    this.decoder = null;
     this.frameIndex = 0;
     this.frameCount = 0;
     this.lastFrameTime = 0;
     this.frameDurations = [];
+    /** Pre-decoded frames stored as ImageBitmap for fast synchronous access */
+    this.frameCache = [];
     this.isAnimated = false;
     this.disposed = false;
     this.canvas = document.createElement("canvas");
@@ -57,11 +61,11 @@ var AnimatedTexture = class {
   /**
    * 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) {
     if (!isImageDecoderSupported()) {
-      const textureLoader = new THREE.TextureLoader();
-      return textureLoader.loadAsync(url);
+      return loadStaticTexture(url);
     }
     try {
       const response = await fetch(url);
@@ -71,8 +75,7 @@ var AnimatedTexture = class {
       const contentType = response.headers.get("content-type") || "image/webp";
       const isSupported = await ImageDecoder.isTypeSupported(contentType);
       if (!isSupported) {
-        const textureLoader = new THREE.TextureLoader();
-        return textureLoader.loadAsync(url);
+        return loadStaticTexture(url);
       }
       const decoder = new ImageDecoder({
         data: response.body,
@@ -103,40 +106,51 @@ var AnimatedTexture = class {
         firstFrame.displayWidth,
         firstFrame.displayHeight
       );
-      animTexture.ctx.drawImage(firstFrame, 0, 0);
-      animTexture.texture.needsUpdate = true;
-      animTexture.decoder = decoder;
-      animTexture.frameCount = frameCount;
-      animTexture.isAnimated = true;
       animTexture.frameDurations = [];
+      animTexture.frameCache = [];
       for (let i = 0; i < frameCount; i++) {
         try {
           const frameResult = await decoder.decode({ frameIndex: i });
-          const durationMs = (frameResult.image.duration ?? 1e5) / 1e3;
+          const videoFrame = frameResult.image;
+          const bitmap = await createImageBitmap(videoFrame);
+          animTexture.frameCache.push(bitmap);
+          const durationMs = (videoFrame.duration ?? 1e5) / 1e3;
           animTexture.frameDurations.push(durationMs);
-          frameResult.image.close();
+          videoFrame.close();
         } catch {
           animTexture.frameDurations.push(100);
+          if (animTexture.frameCache.length > 0) {
+            animTexture.frameCache.push(
+              animTexture.frameCache[animTexture.frameCache.length - 1]
+            );
+          }
         }
       }
-      firstFrame.close();
+      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();
+      firstFrame.close();
+      decoder.close();
       return animTexture;
     } catch (error) {
       console.warn(
         "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() {
-    if (!this.isAnimated || !this.decoder || this.disposed) {
+  tick() {
+    if (!this.isAnimated || this.disposed || this.frameCache.length === 0) {
       return;
     }
     const now = performance.now();
@@ -145,15 +159,11 @@ var AnimatedTexture = class {
     if (elapsed >= currentFrameDuration) {
       this.frameIndex = (this.frameIndex + 1) % this.frameCount;
       this.lastFrameTime = now;
-      try {
-        const result = await this.decoder.decode({
-          frameIndex: this.frameIndex
-        });
+      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 {
       }
     }
   }
@@ -162,13 +172,35 @@ var AnimatedTexture = class {
    */
   dispose() {
     this.disposed = true;
-    if (this.decoder) {
-      this.decoder.close();
-      this.decoder = null;
+    for (const bitmap of this.frameCache) {
+      bitmap.close();
     }
+    this.frameCache = [];
     this.texture.dispose();
   }
 };
+async function loadStaticTexture(url) {
+  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);
+    return createPlaceholderTexture();
+  }
+}
+function createPlaceholderTexture() {
+  const canvas = document.createElement("canvas");
+  canvas.width = 32;
+  canvas.height = 32;
+  const ctx = canvas.getContext("2d");
+  ctx.fillStyle = "#FF00FF";
+  ctx.fillRect(0, 0, 32, 32);
+  const texture = new THREE.CanvasTexture(canvas);
+  texture.colorSpace = THREE.SRGBColorSpace;
+  return texture;
+}
 var AnimatedTextureManager = class {
   constructor() {
     this.animatedTextures = [];
@@ -178,8 +210,13 @@ var AnimatedTextureManager = class {
       this.animatedTextures.push(texture);
     }
   }
-  async tick() {
-    await Promise.all(this.animatedTextures.map((t) => t.tick()));
+  /**
+   * Updates all animated textures. This is now SYNCHRONOUS for optimal performance.
+   */
+  tick() {
+    for (const texture of this.animatedTextures) {
+      texture.tick();
+    }
   }
   dispose() {
     for (const texture of this.animatedTextures) {
@@ -782,11 +819,16 @@ var NotesManager = class {
     }
     for (let i = maxNoteEventIndex + 1; this.noteEvents[i] && this.noteEvents[i].msTime < renderEndTimeMs; i++) {
       const note = this.noteEvents[i];
+      const material = this.noteMaterials.get(note.type)?.get(note.flags);
+      if (!material) {
+        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 ? 0.045 : note.type === noteTypes.open && 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,
@@ -863,12 +905,16 @@ var EventSequence = class {
     return earliestActiveEventIndex === null ? this.lastPrecedingEventIndex + 1 : earliestActiveEventIndex;
   }
 };
-async function loadTextures(instrumentType) {
+async function loadTextures(instrumentType, options = {}) {
+  const { animationsEnabled = true } = options;
   const textureLoader = new THREE.TextureLoader();
   const animatedTextureManager = new AnimatedTextureManager();
   const load = (path) => textureLoader.loadAsync("https://static.enchor.us/" + path);
   const loadAnimated = async (path) => {
     const url = `https://static.enchor.us/preview-${path}.webp`;
+    if (!animationsEnabled) {
+      return loadStaticTexture(url);
+    }
     const result = await AnimatedTexture.create(url);
     if (result instanceof AnimatedTexture) {
       animatedTextureManager.register(result);
@@ -1314,7 +1360,7 @@ function isVideoFile(fileName) {
   const ext = fileName.toLowerCase().slice(fileName.lastIndexOf("."));
   return videoExtensions.includes(ext);
 }
-async function prepareChartData(files, instrument, difficulty, initialSeekPercent = 0) {
+async function prepareChartData(files, instrument, difficulty, initialSeekPercent = 0, textureOptions = {}) {
   const filteredFiles = files.filter((f) => !isVideoFile(f.fileName));
   const scannedChart = scanChartFolder(filteredFiles);
   if (!scannedChart.playable || !scannedChart.notesData) {
@@ -1349,7 +1395,10 @@ async function prepareChartData(files, instrument, difficulty, initialSeekPercen
   }
   const audioFiles = findAudioFiles(filteredFiles);
   const instrumentType = getInstrumentType2(instrument);
-  const textures = await ChartPreview.loadTextures(instrumentType);
+  const textures = await ChartPreview.loadTextures(
+    instrumentType,
+    textureOptions
+  );
   const lastNote = parsedChart.trackData.flatMap((t) => t.noteEventGroups.flat()).reduce((max, note) => Math.max(max, note.msTime + note.msLength), 0);
   const audioLengthMs = scannedChart.song_length || lastNote + 5e3;
   const startDelayMs = (scannedChart.delay || 0) + (scannedChart.chart_offset || 0) * 1e3;
@@ -1670,10 +1719,11 @@ var ChartPreviewPlayer = class extends HTMLElement {
       }
     };
     this.handleFullscreenChange = () => {
-      this._isFullscreen = document.fullscreenElement === this.container;
+      const fullscreenElement = document.fullscreenElement || document.webkitFullscreenElement;
+      this._isFullscreen = fullscreenElement !== null && fullscreenElement !== void 0;
       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";
+      this.fullscreenBtn.title = this._isFullscreen ? "Exit fullscreen" : "Enter fullscreen";
     };
     this.shadow = this.attachShadow({ mode: "open" });
     this.render();
@@ -1698,6 +1748,10 @@ var ChartPreviewPlayer = class extends HTMLElement {
   connectedCallback() {
     this.setAttribute("tabindex", "0");
     document.addEventListener("fullscreenchange", this.handleFullscreenChange);
+    document.addEventListener(
+      "webkitfullscreenchange",
+      this.handleFullscreenChange
+    );
   }
   disconnectedCallback() {
     this.dispose();
@@ -1705,6 +1759,10 @@ var ChartPreviewPlayer = class extends HTMLElement {
       "fullscreenchange",
       this.handleFullscreenChange
     );
+    document.removeEventListener(
+      "webkitfullscreenchange",
+      this.handleFullscreenChange
+    );
     this.removeEventListener("keydown", this.handleKeydown);
   }
   render() {
@@ -1785,7 +1843,8 @@ var ChartPreviewPlayer = class extends HTMLElement {
         this.onSeekEnd();
       }
     });
-    this.fullscreenBtn.addEventListener("click", () => {
+    this.fullscreenBtn.addEventListener("click", (e) => {
+      e.stopPropagation();
       this.toggleFullscreen();
     });
     this.addEventListener("keydown", this.handleKeydown);
@@ -2098,7 +2157,8 @@ var ChartPreviewPlayer = class extends HTMLElement {
         files,
         config.instrument,
         config.difficulty,
-        config.initialSeekPercent
+        config.initialSeekPercent,
+        { animationsEnabled: config.animationsEnabled }
       );
       await this.loadChart({
         parsedChart: preparedData.parsedChart,
@@ -2140,7 +2200,8 @@ var ChartPreviewPlayer = class extends HTMLElement {
         files,
         config.instrument,
         config.difficulty,
-        config.initialSeekPercent
+        config.initialSeekPercent,
+        { animationsEnabled: config.animationsEnabled }
       );
       await this.loadChart({
         parsedChart: preparedData.parsedChart,
@@ -2179,7 +2240,8 @@ var ChartPreviewPlayer = class extends HTMLElement {
         config.files,
         config.instrument,
         config.difficulty,
-        config.initialSeekPercent
+        config.initialSeekPercent,
+        { animationsEnabled: config.animationsEnabled }
       );
       await this.loadChart({
         parsedChart: preparedData.parsedChart,
@@ -2279,12 +2341,28 @@ var ChartPreviewPlayer = class extends HTMLElement {
    * Toggle fullscreen mode
    */
   async toggleFullscreen() {
-    if (!document.fullscreenEnabled)
+    const doc = document;
+    const container = this.container;
+    const isFullscreenEnabled = doc.fullscreenEnabled || doc.webkitFullscreenEnabled;
+    if (!isFullscreenEnabled)
       return;
-    if (this._isFullscreen) {
-      await document.exitFullscreen();
-    } else {
-      await this.container.requestFullscreen();
+    const fullscreenElement = doc.fullscreenElement || doc.webkitFullscreenElement;
+    try {
+      if (fullscreenElement) {
+        if (doc.exitFullscreen) {
+          await doc.exitFullscreen();
+        } else if (doc.webkitExitFullscreen) {
+          doc.webkitExitFullscreen();
+        }
+      } else {
+        if (container.requestFullscreen) {
+          await container.requestFullscreen();
+        } else if (container.webkitRequestFullscreen) {
+          container.webkitRequestFullscreen();
+        }
+      }
+    } catch (error) {
+      console.warn("Fullscreen toggle failed:", error);
     }
   }
   /**
@@ -2319,6 +2397,7 @@ import {
 export {
   ChartPreview,
   ChartPreviewPlayer,
+  areAnimationsSupported,
   extractSngFile,
   fetchSngFile,
   findAudioFiles,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "chart-preview",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"author": "Geo",
 	"license": "MIT",
 	"main": "dist/index.js",

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 {
@@ -1062,6 +1126,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 +1145,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 +1250,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 +1280,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) {