@vitessce/all 3.8.9 → 3.8.13

package/dist/{index-DNRC-wrS.js → index-DZg7IgTe.js}

@@ -1,7 +1,7 @@
-import { G as Group, M as Matrix4, T as TrianglesDrawMode, a as TriangleFanDrawMode, b as TriangleStripDrawMode, R as REVISION, L as Loader, c as LoaderUtils, F as FileLoader, d as MeshPhysicalMaterial, V as Vector2, C as Color, S as SpotLight, P as PointLight, D as DirectionalLight, e as Vector3, I as InstancedMesh, Q as Quaternion, O as Object3D, f as TextureLoader, g as ImageBitmapLoader, B as BufferAttribute, h as InterleavedBuffer, i as LinearMipmapLinearFilter, N as NearestMipmapLinearFilter, j as LinearMipmapNearestFilter, k as NearestMipmapNearestFilter, l as LinearFilter, m as NearestFilter, n as RepeatWrapping, o as MirroredRepeatWrapping, p as ClampToEdgeWrapping, q as PointsMaterial, r as Material, s as LineBasicMaterial, t as MeshStandardMaterial, u as DoubleSide, v as MeshBasicMaterial, w as PropertyBinding, x as BufferGeometry, y as SkinnedMesh, z as Mesh, A as LineSegments, E as Line$1, H as LineLoop, J as Points, K as PerspectiveCamera, U as MathUtils, W as OrthographicCamera, X as Skeleton, Y as InterpolateDiscrete, Z as InterpolateLinear, _ as AnimationClip, $ as Bone, a0 as InterleavedBufferAttribute, a1 as Texture, a2 as VectorKeyframeTrack, a3 as QuaternionKeyframeTrack, a4 as NumberKeyframeTrack, a5 as FrontSide, a6 as Interpolant, a7 as Box3, a8 as Sphere, a9 as InstancedBufferGeometry, aa as Float32BufferAttribute, ab as InstancedInterleavedBuffer, ac as WireframeGeometry, ad as ShaderMaterial, ae as UniformsUtils, af as UniformsLib, ag as Vector4, ah as Line3, ai as SphereGeometry, aj as _extends, ak as Plane, al as Triangle, am as BackSide, an as Ray$1, ao as jsxRuntimeExports, ap as Matrix3, aq as CoordinationType, ar as Data3DTexture, as as RedFormat, at as FloatType, au as getImageSize, av as Scene } from "./index-BmH3S4VU.js";
+import { G as Group, M as Matrix4, T as TrianglesDrawMode, a as TriangleFanDrawMode, b as TriangleStripDrawMode, R as REVISION, L as Loader, c as LoaderUtils, F as FileLoader, d as MeshPhysicalMaterial, V as Vector2, C as Color, S as SpotLight, P as PointLight, D as DirectionalLight, e as Vector3, I as InstancedMesh, Q as Quaternion, O as Object3D, f as TextureLoader, g as ImageBitmapLoader, B as BufferAttribute, h as InterleavedBuffer, i as LinearMipmapLinearFilter, N as NearestMipmapLinearFilter, j as LinearMipmapNearestFilter, k as NearestMipmapNearestFilter, l as LinearFilter, m as NearestFilter, n as RepeatWrapping, o as MirroredRepeatWrapping, p as ClampToEdgeWrapping, q as PointsMaterial, r as Material, s as LineBasicMaterial, t as MeshStandardMaterial, u as DoubleSide, v as MeshBasicMaterial, w as PropertyBinding, x as BufferGeometry, y as SkinnedMesh, z as Mesh, A as LineSegments, E as Line$1, H as LineLoop, J as Points, K as PerspectiveCamera, U as MathUtils, W as OrthographicCamera, X as Skeleton, Y as InterpolateDiscrete, Z as InterpolateLinear, _ as AnimationClip, $ as Bone, a0 as InterleavedBufferAttribute, a1 as Texture, a2 as VectorKeyframeTrack, a3 as QuaternionKeyframeTrack, a4 as NumberKeyframeTrack, a5 as FrontSide, a6 as Interpolant, a7 as Box3, a8 as Sphere, a9 as InstancedBufferGeometry, aa as Float32BufferAttribute, ab as InstancedInterleavedBuffer, ac as WireframeGeometry, ad as ShaderMaterial, ae as UniformsUtils, af as UniformsLib, ag as Vector4, ah as Line3, ai as SphereGeometry, aj as _extends, ak as Plane, al as Triangle, am as BackSide, an as Ray$1, ao as jsxRuntimeExports, ap as Matrix3, aq as CoordinationType, ar as Data3DTexture, as as RedFormat, at as FloatType, au as getImageSize, av as Scene } from "./index-B0JyLhTY.js";
 import * as React from "react";
 import { useRef, useEffect, useState, forwardRef } from "react";
-import { u as useThree, a as useFrame, c as create, e as extend, b as createPortal, O as OrbitControls, C as Canvas } from "./OrbitControls-Dm5R32wb.js";
+import { u as useThree, a as useFrame, c as create, e as extend, b as createPortal, O as OrbitControls, C as Canvas } from "./OrbitControls-Bq0h_Ctg.js";
 const isPromise = (promise) => typeof promise === "object" && typeof promise.then === "function";
 const globalCache = [];
 function shallowEqualArrays(arrA, arrB, equal = (a, b) => a === b) {
@@ -5027,7 +5027,7 @@ const Text = /* @__PURE__ */ React.forwardRef(({
   const {
     Text: TextMeshImpl,
     preloadFont
-  } = suspend(async () => import("./troika-three-text.esm-CPzJMQ38.js"), []);
+  } = suspend(async () => import("./troika-three-text.esm-aenn8tL8.js"), []);
   const invalidate = useThree(({
     invalidate: invalidate2
   }) => invalidate2);

package/dist/{index-BATko5ux.js → index-eU9RLuKQ.js}

@@ -1,6 +1,6 @@
-import { aw as log, ax as isEqual, ar as Data3DTexture, as as RedFormat, ay as UnsignedByteType, l as LinearFilter, az as RedIntegerFormat, aA as UnsignedIntType, m as NearestFilter, e as Vector3, V as Vector2, ag as Vector4, ae as UniformsUtils, aq as CoordinationType, aB as WebGLMultipleRenderTargets, aC as RGBAFormat, av as Scene, W as OrthographicCamera, ad as ShaderMaterial, z as Mesh, aD as PlaneGeometry, ao as jsxRuntimeExports, aE as GLSL3, am as BackSide } from "./index-BmH3S4VU.js";
-import { useRef, useState, useMemo, useEffect, useCallback } from "react";
-import { u as useThree, a as useFrame, O as OrbitControls, C as Canvas } from "./OrbitControls-Dm5R32wb.js";
+import { aw as log, ax as isEqual, ar as Data3DTexture, as as RedFormat, ay as UnsignedByteType, l as LinearFilter, az as RedIntegerFormat, aA as UnsignedIntType, m as NearestFilter, e as Vector3, V as Vector2, ag as Vector4, ae as UniformsUtils, aq as CoordinationType, aB as WebGLMultipleRenderTargets, aC as RGBAFormat, av as Scene, W as OrthographicCamera, ad as ShaderMaterial, z as Mesh, aD as PlaneGeometry, aE as useEventCallback, ao as jsxRuntimeExports, aF as GLSL3, am as BackSide } from "./index-B0JyLhTY.js";
+import { useRef, useState, useMemo, useEffect, Suspense } from "react";
+import { u as useThree, a as useFrame, O as OrbitControls, C as Canvas } from "./OrbitControls-Bq0h_Ctg.js";
 const LogLevel = {
   INFO: "info",
   WARN: "warn",
@@ -345,12 +345,55 @@ class VolumeDataManager {
     this.timeStamp = 0;
     this.k = 40;
     this.noNewRequests = false;
+    this.manuallyStopped = false;
     this.needsBailout = false;
     this.initStatus = INIT_STATUS.NOT_STARTED;
     this.initError = null;
     this._lastChannelConfig = null;
+    this.currentRequestCount = 0;
+    this.totalBricksRequested = 0;
     logWithColor$2("VolumeDataManager constructor complete");
   }
+  /**
+   * Get loading progress information
+   * @returns {Object} Loading progress with bricksLoaded, totalBricks, isLoading, and percentage
+   */
+  getLoadingProgress() {
+    const bricksLoaded = this.bricksEverLoaded.size;
+    const isLoading = !this.noNewRequests && this.currentRequestCount > 0;
+    const percentage = this.totalBricksRequested > 0 ? (this.totalBricksRequested - this.currentRequestCount) / this.totalBricksRequested * 100 : 0;
+    return {
+      bricksLoaded,
+      currentRequestCount: this.currentRequestCount,
+      totalBricksRequested: this.totalBricksRequested,
+      isLoading,
+      percentage,
+      noNewRequests: this.noNewRequests
+    };
+  }
+  /**
+   * Manually stop loading and render at highest resolution
+   */
+  stopLoading() {
+    log.debug("Manually stopping data loading");
+    this.noNewRequests = true;
+    this.manuallyStopped = true;
+    this.needsBailout = true;
+    this.currentRequestCount = 0;
+    this.totalBricksRequested = 0;
+  }
+  /**
+   * Manually restart loading
+   */
+  restartLoading() {
+    log.debug("Manually restarting data loading");
+    this.noNewRequests = false;
+    this.manuallyStopped = false;
+    this.needsBailout = false;
+    this.triggerUsage = true;
+    this.currentRequestCount = 0;
+    this.totalBricksRequested = 0;
+  }
   /**
    * Handle WebGL context loss
    */
@@ -621,16 +664,11 @@ class VolumeDataManager {
     this.bcTHREE = bcTHREE;
     logWithColor$2("initMRMCPT() COMPLETE");
   }
-  /*
-  testTexture() {
-    log.debug('testTexture pt', this.ptTHREE);
-    log.debug('testTexture bc', this.bcTHREE);
-  }
-  */
   async initTexture() {
     const requests = [
       { x: 0, y: 0, z: 1 }
     ];
+    logWithColor$2("initTexture - loading first brick");
     await this.handleBrickRequests(requests);
   }
   updateChannels(channelProps) {
@@ -816,6 +854,7 @@ class VolumeDataManager {
     if (!this.zarrStore || !this.zarrStore.arrays[resolution]) {
       throw new Error("Zarr store or resolution not initialized");
     }
+    log.debug("loadZarrChunk", { t, c, z, y, x, resolution });
     const array = this.zarrStore.arrays[resolution];
     const chunkEntry = await array.getChunk([t, c, z, y, x]);
     if (!chunkEntry) {
@@ -831,6 +870,10 @@ class VolumeDataManager {
       log.debug("processRequestData: already busy, skipping");
       return;
     }
+    if (this.noNewRequests) {
+      log.debug("processRequestData: loading stopped by user, skipping");
+      return;
+    }
     if (this.isContextLost()) {
       log.debug("processRequestData: WebGL context is lost, skipping");
       return;
@@ -1032,6 +1075,7 @@ class VolumeDataManager {
     }
     log.debug("starting to load zarr chunk", { resolution, z, y, x, zarrChannel });
     let chunk = await this.loadZarrChunk(0, zarrChannel, z, y, x, resolution);
+    log.debug("chunk", chunk);
     if (chunk instanceof Uint16Array) {
       log.debug("chunk is Uint16Array, converting to Uint8Array");
       if (this.channels.downsampleMin[channel] === void 0) {
@@ -1042,9 +1086,15 @@ class VolumeDataManager {
         log.debug("this.channels.downsampleMin[channel]", this.channels.downsampleMin[channel]);
         log.debug("this.channels.downsampleMax[channel]", this.channels.downsampleMax[channel]);
       }
+      const uint16View = new Uint16Array(chunk.buffer);
       const uint8Chunk = new Uint8Array(chunk.length);
-      for (let i = 0; i < chunk.length; i++) {
-        uint8Chunk[i] = Math.floor((chunk[i] - this.channels.downsampleMin[channel]) / (this.channels.downsampleMax[channel] - this.channels.downsampleMin[channel]) * 255);
+      const minVal = this.channels.downsampleMin[channel];
+      const maxVal = this.channels.downsampleMax[channel];
+      const range = maxVal - minVal;
+      for (let i = 0; i < uint16View.length; i++) {
+        const val = uint16View[i];
+        const clamped = Math.max(minVal, Math.min(maxVal, val));
+        uint8Chunk[i] = (clamped - minVal) * 255 / range | 0;
       }
       chunk = uint8Chunk;
     }
@@ -1097,12 +1147,14 @@ class VolumeDataManager {
   async handleBrickRequests(ptRequests) {
     if (ptRequests.length === 0)
       return;
+    this.totalBricksRequested = ptRequests.length;
+    this.currentRequestCount = ptRequests.length;
     const slots = this._allocateBCSlots(ptRequests.length);
     log.debug("Handling brick requests:", { requestCount: ptRequests.length, slotCount: slots.length });
     log.debug("handleBrickRequests: starting for loop");
     for (let i = 0; i < ptRequests.length; ++i) {
-      log.debug("uploading brick", ptRequests[i], slots[i]);
       await this._uploadBrick(ptRequests[i], slots[i]);
+      this.currentRequestCount = ptRequests.length - i - 1;
       const rlength = this.bricksEverLoaded.size;
       this.bricksEverLoaded.add(`${ptRequests[i].x},${ptRequests[i].y},${ptRequests[i].z}`);
       if (rlength === this.bricksEverLoaded.size) {
@@ -1111,9 +1163,11 @@ class VolumeDataManager {
       if (this.needsBailout) {
         log.debug("Bailing out of handleBrickRequests early due to needsBailout flag");
         this.needsBailout = false;
+        this.currentRequestCount = 0;
         break;
       }
     }
+    this.currentRequestCount = 0;
     log.debug("this.bricksEverLoaded", this.bricksEverLoaded);
   }
   /* --------------------------------------------------------- *
@@ -1211,7 +1265,7 @@ uniform usampler3D pageTableTex;
 // ========================================
 // RENDERING PARAMETERS/CONSTANTS
 // ========================================
-// Rendering style: 0=MIP, 1=MinIP, 2=standard volume rendering
+// Rendering style: 0=MIP, 1=MinIP, 2=standard volume rendering, 3=DEBUG
 uniform int u_renderstyle;
 // Global opacity multiplier for volume rendering
 uniform float opacity;
@@ -2223,7 +2277,19 @@ void main(void) {
     // TODO: figure out how to hook it up with frontend
     int [] c_res_min = int[7](getRes(0).x, getRes(1).x, getRes(2).x, getRes(3).x, getRes(4).x, getRes(5).x, getRes(6).x);
     int [] c_res_max = int[7](getRes(0).y, getRes(1).y, getRes(2).y, getRes(3).y, getRes(4).y, getRes(5).y, getRes(6).y);
-    
+    vec3 [] res_color = vec3[10](
+        vec3(1.0, 0.0, 0.0), 
+        vec3(0.0, 0.0, 1.0), 
+        vec3(0.0, 1.0, 0.0), 
+        vec3(1.0, 0.0, 1.0), 
+        vec3(0.0, 1.0, 1.0),
+        vec3(1.0, 1.0, 0.0),
+        vec3(1.0, 0.5, 0.5), 
+        vec3(0.5, 0.5, 1.0), 
+        vec3(0.5, 1.0, 0.5), 
+        vec3(0.5, 0.5, 0.5)
+    );
+
     // ========================================
     // PER-CHANNEL STATE ARRAYS
     // ========================================
@@ -2661,7 +2727,13 @@ void main(void) {
             // Accumulate this channel's contribution.
             // sum up the values onto the slice values
             total += c_val_current[c];
-            rgbCombo += c_val_current[c] * c_color[c];
+            if (u_renderstyle == 3) {
+                rgbCombo += c_val_current[c] * res_color[targetRes];
+            } else if (u_renderstyle == 4) {
+                rgbCombo += c_val_current[c] * res_color[c_res_current[c]];
+            } else {
+                rgbCombo += c_val_current[c] * c_color[c];
+            }
 
         }
 
@@ -2748,6 +2820,7 @@ const VolumeShader = {
     zClip: { value: new Vector2(0, 1e6) },
     u_window_size: { value: new Vector2(1, 1) },
     u_vol_scale: { value: new Vector3(1, 1, 1) },
+    // Set renderstyle to 3 or 4 for debugging modes
     u_renderstyle: { value: 2 },
     brickCacheTex: { type: "sampler3D", value: null },
     pageTableTex: { type: "usampler3D", value: null },
@@ -2850,10 +2923,10 @@ class VolumeRenderManager {
    * @returns {Object} Extracted rendering settings
    */
   extractRenderingSettingsFromProps(props) {
-    logWithColor$1("Extracting rendering settings from props");
     const { images = {}, imageLayerScopes = [], imageLayerCoordination = [{}], imageChannelScopesByLayer = {}, imageChannelCoordination = [{}], spatialRenderingMode } = props;
     const layerScope = imageLayerScopes[0];
     if (!layerScope) {
+      logWithColor$1("Extracting rendering settings from props - no layer scope");
       return {
         valid: false
       };
@@ -2863,11 +2936,13 @@ class VolumeRenderManager {
     const channelCoordination = imageChannelCoordination[0][layerScope];
     const data = images[layerScope]?.image?.instance?.getData();
     if (!data) {
+      logWithColor$1("Extracting rendering settings from props - no image data");
       return {
         valid: false
       };
     }
     if (!channelCoordination[channelScopes?.[0]][CoordinationType.SPATIAL_CHANNEL_WINDOW]) {
+      logWithColor$1("Extracting rendering settings from props - no channel window set");
       return {
         valid: false
       };
@@ -2909,10 +2984,12 @@ class VolumeRenderManager {
     let xSlice = layerCoordination[CoordinationType.SPATIAL_SLICE_X];
     let ySlice = layerCoordination[CoordinationType.SPATIAL_SLICE_Y];
     let zSlice = layerCoordination[CoordinationType.SPATIAL_SLICE_Z];
+    const lodFactor = layerCoordination[CoordinationType.SPATIAL_LOD_FACTOR] ?? 1;
     xSlice = xSlice !== null ? xSlice : new Vector2(-1, 1e5);
     ySlice = ySlice !== null ? ySlice : new Vector2(-1, 1e5);
     zSlice = zSlice !== null ? zSlice : new Vector2(-1, 1e5);
     const allChannels = images[layerScope].image.loaders[0].channels;
+    logWithColor$1("Extracting rendering settings from props - success");
     return {
       valid: true,
       channelsVisible,
@@ -2926,7 +3003,8 @@ class VolumeRenderManager {
       layerTransparency,
       xSlice,
       ySlice,
-      zSlice
+      zSlice,
+      lodFactor
     };
   }
   /**
@@ -2935,9 +3013,9 @@ class VolumeRenderManager {
    * @returns {boolean} True if settings were successfully updated
    */
   updateFromProps(props) {
-    logWithColor$1("Updating from props");
     const settings = this.extractRenderingSettingsFromProps(props);
     if (!settings.valid) {
+      logWithColor$1("Updating from props - invalid settings");
       return false;
     }
     this.channelsVisible = settings.channelsVisible;
@@ -2950,6 +3028,10 @@ class VolumeRenderManager {
     this.xSlice = settings.xSlice;
     this.ySlice = settings.ySlice;
     this.zSlice = settings.zSlice;
+    this.uniforms.lodFactor.value = settings.lodFactor;
+    logWithColor$1(`lodFactor ${settings.lodFactor}`);
+    this.shader.uniforms.lodFactor.value = settings.lodFactor;
+    logWithColor$1("Updating from props - success");
     return true;
   }
   /**
@@ -3354,7 +3436,7 @@ function performBlitPass(_gl, { screenSceneRef, screenCameraRef }) {
 function handleRequests(_gl, { frameRef, dataManager, mrtRef, bufRequest, bufUsage }) {
   const ctx = _gl.getContext();
   const f = frameRef.current;
-  if (dataManager.noNewRequests === true && f % 100 === 0 && f < 500) {
+  if (dataManager.noNewRequests === true && !dataManager.manuallyStopped && f % 100 === 0 && f < 500) {
     dataManager.noNewRequests = false;
   }
   if (dataManager.triggerRequest === true && dataManager.noNewRequests === false) {
@@ -3379,8 +3461,10 @@ function handleAdaptiveQuality(clock, params) {
     }
   }
   if (isInteracting) {
-    dataManager.noNewRequests = false;
-    dataManager.triggerUsage = true;
+    if (!dataManager.manuallyStopped) {
+      dataManager.noNewRequests = false;
+      dataManager.triggerUsage = true;
+    }
     return;
   }
   if (spatialRenderingModeChanging)
@@ -3438,7 +3522,8 @@ function VolumeView(props) {
     imageChannelCoordination,
     // onInitComplete,
     spatialRenderingMode,
-    spatialRenderingModeChanging
+    spatialRenderingModeChanging,
+    onVolumeLoadingUpdate
   } = props;
   const {
     gl
@@ -3457,11 +3542,11 @@ function VolumeView(props) {
     meshScale: [1, 1, 1],
     geometrySize: [1, 1, 1]
   });
-  const [is3D, setIs3D] = useState(false);
+  const is3D = spatialRenderingMode === "3D";
   const screenSceneRef = useRef(null);
   const screenCameraRef = useRef(null);
   const screenQuadRef = useRef(null);
-  const [isInteracting, setIsInteracting] = useState(false);
+  const [isInteracting, _setIsInteracting] = useState(false);
   const interactionTimeoutRef = useRef(null);
   const stillRef = useRef(false);
   const frameRef = useRef(0);
@@ -3514,6 +3599,7 @@ function VolumeView(props) {
   const firstImageLayerChannelCoordination = imageChannelCoordination?.[0]?.[firstImageLayerScope];
   useEffect(() => {
     logWithColor("useEffect INIT");
+    let hasRerun = false;
     if (!dataManager || !renderManager) {
       log.debug("dataManager or renderManager not initialized yet");
       return;
@@ -3526,24 +3612,32 @@ function VolumeView(props) {
       log.debug("no firstImageLayerChannelCoordination yet");
       return;
     }
-    (async () => {
+    const initializeDataManager = async () => {
+      if (dataManager.initStatus === INIT_STATUS.COMPLETE) {
+        log.debug("dataManager already initialized, skipping");
+        return;
+      }
       dataManager.initImages(images, imageLayerScopes);
       await dataManager.init(firstImageLayerChannelCoordination);
+      if (hasRerun) {
+        log.debug("Initialization useEffect has rerun, aborting remaining initialization");
+        return;
+      }
+      log.debug("dataManager initialized");
       renderManager.setZarrUniforms(dataManager.zarrStore, dataManager.PT);
       renderManager.setChannelMapping(dataManager.channels.colorMappings);
       log.debug("rm.uniforms", renderManager.uniforms);
-    })();
-  }, [
-    dataManager,
-    renderManager,
-    images,
-    imageLayerScopes
-  ]);
+      invalidate();
+    };
+    initializeDataManager();
+    return () => {
+      hasRerun = true;
+    };
+  }, [dataManager, renderManager, images, imageLayerScopes]);
   useEffect(() => {
-    logWithColor("useEffect spatialRenderingMode");
     const on3D = spatialRenderingMode === "3D";
-    setIs3D(on3D);
     if (on3D && dataManager && renderManager) {
+      logWithColor("useEffect spatialRenderingMode");
       const propsForRenderManager = {
         images,
         imageLayerScopes,
@@ -3576,33 +3670,15 @@ function VolumeView(props) {
         }
       }
     }
-  }, [
-    dataManager,
-    renderManager,
-    images,
-    imageLayerScopes,
-    imageLayerCoordination,
-    imageChannelScopesByLayer,
-    imageChannelCoordination,
-    spatialRenderingMode
-  ]);
-  useEffect(() => {
-    logWithColor("useEffect isInteracting");
-    if (isInteracting) {
-      const meshRefUniforms = meshRef.current?.material?.uniforms;
-      if (meshRefUniforms) {
-        meshRefUniforms.renderRes.value = dataManager.PT.lowestDataRes;
-      }
-      stillRef.current = false;
-      invalidate();
-    }
-  }, [invalidate, isInteracting]);
+  }, [dataManager, renderManager, images, imageLayerScopes, imageLayerCoordination, imageChannelScopesByLayer, imageChannelCoordination, spatialRenderingMode]);
   const RENDER_PRIORITY = 1;
   useFrame((state, delta, xrFrame) => {
-    if (!mrtRef.current || !dataManager || !renderManager)
+    if (!mrtRef.current || !dataManager || !renderManager) {
       return;
-    if (!renderState.shader)
+    }
+    if (!renderState.shader) {
       return;
+    }
     const { gl: frameGl, camera: frameCamera, scene: frameScene, clock } = state;
     if (!stillRef.current) {
       performGeometryPass(frameGl, frameCamera, frameScene, { mrtRef });
@@ -3623,15 +3699,27 @@ function VolumeView(props) {
     });
     frameRef.current += 1;
   }, RENDER_PRIORITY);
-  const onOrbitControlsStart = useCallback((e) => {
+  const setIsInteracting = useEventCallback((interacting) => {
+    logWithColor("invalidateOnInteraction callback");
+    _setIsInteracting(interacting);
+    if (interacting) {
+      const meshRefUniforms = meshRef.current?.material?.uniforms;
+      if (meshRefUniforms) {
+        meshRefUniforms.renderRes.value = dataManager.PT.lowestDataRes;
+      }
+      stillRef.current = false;
+      invalidate();
+    }
+  });
+  const onOrbitControlsStart = useEventCallback((e) => {
     setIsInteracting(true);
-  }, []);
-  const onOrbitControlsEnd = useCallback((e) => {
+  });
+  const onOrbitControlsEnd = useEventCallback((e) => {
     clearTimeout(interactionTimeoutRef.current);
     interactionTimeoutRef.current = setTimeout(() => {
       setIsInteracting(false);
     }, 300);
-  }, []);
+  });
   useEffect(() => {
     logWithColor("useEffect firstImageLayerChannelCoordination");
     setIsInteracting(true);
@@ -3642,7 +3730,37 @@ function VolumeView(props) {
     interactionTimeoutRef.current = setTimeout(() => {
       setIsInteracting(false);
     }, 300);
-  }, [firstImageLayerChannelCoordination]);
+  }, [dataManager, firstImageLayerChannelCoordination, renderManager, setIsInteracting]);
+  const stopLoading = useEventCallback(() => {
+    if (dataManager) {
+      dataManager.stopLoading();
+    }
+  });
+  const restartLoading = useEventCallback(() => {
+    if (dataManager) {
+      dataManager.restartLoading();
+    }
+  });
+  const getLoadingProgress = useEventCallback(() => {
+    if (dataManager) {
+      return dataManager.getLoadingProgress();
+    }
+    return null;
+  });
+  useEffect(() => {
+    if (!onVolumeLoadingUpdate)
+      return void 0;
+    const intervalId = setInterval(() => {
+      const loadingProgress = getLoadingProgress();
+      onVolumeLoadingUpdate({
+        loadingProgress,
+        stillRef,
+        onStopLoading: stopLoading,
+        onRestartLoading: restartLoading
+      });
+    }, 1e3);
+    return () => clearInterval(intervalId);
+  }, [onVolumeLoadingUpdate, stillRef]);
   if (!is3D || !dataManager || !renderManager)
     return null;
   if (!renderState.shader) {
@@ -3679,7 +3797,7 @@ function SpatialWrapper(props) {
     logarithmicDepthBuffer: false,
     preserveDrawingBuffer: false,
     autoClear: false
-  }, children: jsxRuntimeExports.jsx(VolumeView, { ...props }) });
+  }, children: jsxRuntimeExports.jsx(Suspense, { fallback: "Initializing Volume View...", children: jsxRuntimeExports.jsx(VolumeView, { ...props }) }) });
 }
 export {
   SpatialWrapper

package/dist/index.js

@@ -1,12 +1,12 @@
-import { bQ, bO, bM, bP, bN, bL, bR } from "./index-BmH3S4VU.js";
+import { bR, bP, bN, bQ, bO, bM, bS } from "./index-B0JyLhTY.js";
 import { useComplexCoordination, useComplexCoordinationSecondary, useCoordination, useCoordinationScopes, useCoordinationScopesBy, useGridItemSize, useMultiCoordinationScopesNonNull, useMultiCoordinationScopesSecondaryNonNull, usePageModeView } from "@vitessce/vit-s";
 export {
-  bQ as PluginAsyncFunction,
-  bO as PluginCoordinationType,
-  bM as PluginFileType,
-  bP as PluginJointFileType,
-  bN as PluginViewType,
-  bL as Vitessce,
+  bR as PluginAsyncFunction,
+  bP as PluginCoordinationType,
+  bN as PluginFileType,
+  bQ as PluginJointFileType,
+  bO as PluginViewType,
+  bM as Vitessce,
   useComplexCoordination,
   useComplexCoordinationSecondary,
   useCoordination,
@@ -16,5 +16,5 @@ export {
   useMultiCoordinationScopesNonNull,
   useMultiCoordinationScopesSecondaryNonNull,
   usePageModeView,
-  bR as z
+  bS as z
 };

package/dist/{jpeg-DnYEHHlA.js → jpeg-BOKb2qaL.js}

@@ -1,4 +1,4 @@
-import { aW as BaseDecoder } from "./index-BmH3S4VU.js";
+import { aX as BaseDecoder } from "./index-B0JyLhTY.js";
 const dctZigZag = new Int32Array([
   0,
   1,

package/dist/{lerc-xK3UlYuK.js → lerc-CBp5l3Pw.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-SxljTded.js";
-import { aF as getDefaultExportFromCjs, aW as BaseDecoder, aX as LercParameters, aY as LercAddCompression } from "./index-BmH3S4VU.js";
+import { aG as getDefaultExportFromCjs, aX as BaseDecoder, aY as LercParameters, aZ as LercAddCompression } from "./index-B0JyLhTY.js";
 var LercDecode = { exports: {} };
 var hasRequiredLercDecode;
 function requireLercDecode() {

package/dist/{lzw-Dq9ewDsx.js → lzw-CkA9e76s.js}

@@ -1,4 +1,4 @@
-import { aW as BaseDecoder } from "./index-BmH3S4VU.js";
+import { aX as BaseDecoder } from "./index-B0JyLhTY.js";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;
 const EOI_CODE = 257;

package/dist/{packbits-DUvZwRme.js → packbits-DOr_NbG_.js}

@@ -1,4 +1,4 @@
-import { aW as BaseDecoder } from "./index-BmH3S4VU.js";
+import { aX as BaseDecoder } from "./index-B0JyLhTY.js";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     const dataView = new DataView(buffer);

package/dist/{raw-CCF7Hnlb.js → raw-BEDGxpo9.js}

@@ -1,4 +1,4 @@
-import { aW as BaseDecoder } from "./index-BmH3S4VU.js";
+import { aX as BaseDecoder } from "./index-B0JyLhTY.js";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {
     return buffer;

package/dist/{troika-three-text.esm-CPzJMQ38.js → troika-three-text.esm-aenn8tL8.js}

@@ -1,4 +1,4 @@
-import { bG as MeshDistanceMaterial, bH as MeshDepthMaterial, bI as RGBADepthPacking, ae as UniformsUtils, bJ as ShaderChunk, a9 as InstancedBufferGeometry, a8 as Sphere, a7 as Box3, am as BackSide, u as DoubleSide, z as Mesh, a5 as FrontSide, v as MeshBasicMaterial, C as Color, e as Vector3, M as Matrix4, V as Vector2, ap as Matrix3, ag as Vector4, a1 as Texture, l as LinearFilter, aD as PlaneGeometry, x as BufferGeometry, aa as Float32BufferAttribute, bK as InstancedBufferAttribute } from "./index-BmH3S4VU.js";
+import { bH as MeshDistanceMaterial, bI as MeshDepthMaterial, bJ as RGBADepthPacking, ae as UniformsUtils, bK as ShaderChunk, a9 as InstancedBufferGeometry, a8 as Sphere, a7 as Box3, am as BackSide, u as DoubleSide, z as Mesh, a5 as FrontSide, v as MeshBasicMaterial, C as Color, e as Vector3, M as Matrix4, V as Vector2, ap as Matrix3, ag as Vector4, a1 as Texture, l as LinearFilter, aD as PlaneGeometry, x as BufferGeometry, aa as Float32BufferAttribute, bL as InstancedBufferAttribute } from "./index-B0JyLhTY.js";
 function workerBootstrap() {
   var modules = /* @__PURE__ */ Object.create(null);
   function registerModule(ref, callback) {

package/dist/{webimage-mUI4EmOE.js → webimage-Ad_VhFBm.js}

@@ -1,4 +1,4 @@
-import { aW as BaseDecoder } from "./index-BmH3S4VU.js";
+import { aX as BaseDecoder } from "./index-B0JyLhTY.js";
 class WebImageDecoder extends BaseDecoder {
   constructor() {
     super();

package/dist-tsc/base-plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-plugins.d.ts","sourceRoot":"","sources":["../src/base-plugins.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"base-plugins.d.ts","sourceRoot":"","sources":["../src/base-plugins.ts"],"names":[],"mappings":"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"}

package/dist-tsc/base-plugins.js

@@ -301,6 +301,7 @@ export const baseCoordinationTypes = [
     new PluginCoordinationType(CoordinationType.SPATIAL_CHANNEL_COLOR, [255, 255, 255], z.array(z.number()).length(3).nullable()),
     new PluginCoordinationType(CoordinationType.SPATIAL_SEGMENTATION_FILLED, true, z.boolean()),
     new PluginCoordinationType(CoordinationType.SPATIAL_SEGMENTATION_STROKE_WIDTH, 1.0, z.number()),
+    new PluginCoordinationType(CoordinationType.SPATIAL_LOD_FACTOR, 1.0, z.number()),
     // Reference: https://www.awaresystems.be/imaging/tiff/tifftags/photometricinterpretation.html
     new PluginCoordinationType(CoordinationType.PHOTOMETRIC_INTERPRETATION, null, z.enum(['BlackIsZero', 'RGB']).nullable()),
     new PluginCoordinationType(CoordinationType.SPATIAL_RENDERING_MODE, '2D', z.enum(['2D', '3D']).nullable()),