Feature - CDF in invlerp if only 3D view shown of image layer

src/perspective_view/panel.ts

@@ -81,6 +81,8 @@ import { MultipleScaleBarTextures } from "#src/widget/scale_bar.js";
 import type { RPC } from "#src/worker_rpc.js";
 import { SharedObject } from "#src/worker_rpc.js";
 
+const REDRAW_DELAY_AFTER_CAMERA_MOVE = 300;
+
 export interface PerspectiveViewerState extends RenderedDataViewerState {
   wireFrame: WatchableValueInterface<boolean>;
   orthographicProjection: TrackableBoolean;
@@ -251,6 +253,7 @@ export class PerspectivePanel extends RenderedDataPanel {
   protected visibleLayerTracker: Owned<
     VisibleRenderLayerTracker<PerspectivePanel, PerspectiveViewRenderLayer>
   >;
+  private redrawAfterMoveTimeOutId: number = -1;
 
   get rpc() {
     return this.sharedObject.rpc!;
@@ -261,6 +264,9 @@ export class PerspectivePanel extends RenderedDataPanel {
   get displayDimensionRenderInfo() {
     return this.navigationState.displayDimensionRenderInfo;
   }
+  get isCameraMoving() {
+    return this.redrawAfterMoveTimeOutId !== -1;
+  }
 
   /**
    * If boolean value is true, sliceView is shown unconditionally, regardless of the value of
@@ -417,6 +423,22 @@ export class PerspectivePanel extends RenderedDataPanel {
       this,
     );
 
+    this.registerDisposer(
+      this.viewer.navigationState.changed.add(() => {
+        // Don't mark camera moving on picking requests
+        if (this.isMovingToMousePosition) {
+          return;
+        }
+        if (this.redrawAfterMoveTimeOutId !== -1) {
+          window.clearTimeout(this.redrawAfterMoveTimeOutId);
+        }
+        this.redrawAfterMoveTimeOutId = window.setTimeout(() => {
+          this.redrawAfterMoveTimeOutId = -1;
+          this.context.scheduleRedraw();
+        }, REDRAW_DELAY_AFTER_CAMERA_MOVE);
+      }),
+    );
+
     registerActionListener(
       element,
       "rotate-via-mouse-drag",
@@ -902,6 +924,8 @@ export class PerspectivePanel extends RenderedDataPanel {
       alreadyEmittedPickID: false,
       bindFramebuffer,
       frameNumber: this.context.frameNumber,
+      sliceViewsPresent: this.sliceViews.size > 0,
+      cameraMovementInProgress: this.isCameraMoving,
     };
 
     mat4.copy(
@@ -987,6 +1011,7 @@ export class PerspectivePanel extends RenderedDataPanel {
         };
         gl.depthMask(true);
         bindMaxProjectionBuffer();
+        renderContext.bindMaxProjectionBuffer = bindMaxProjectionBuffer;
         gl.clearColor(0.0, 0.0, 0.0, 0.0);
         gl.clearDepth(0.0);
         gl.clear(

src/perspective_view/render_layer.ts

@@ -55,6 +55,21 @@ export interface PerspectiveViewRenderContext
    * Specifies the ID of the depth frame buffer texture to query during rendering.
    */
   depthBufferTexture?: WebGLTexture | null;
+
+  /**
+   * Specifies if there are any slice views
+   */
+  sliceViewsPresent: boolean;
+
+  /**
+   * Specifies if the camera is moving
+   */
+  cameraMovementInProgress: boolean;
+
+  /**
+   * Specifices how to bind the max projection buffer
+   */
+  bindMaxProjectionBuffer?: () => void | undefined;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging

src/rendered_data_panel.ts

@@ -165,6 +165,7 @@ export abstract class RenderedDataPanel extends RenderedPanel {
   pickRequestPending = false;
 
   private mouseStateForcer = () => this.blockOnPickRequest();
+  protected isMovingToMousePosition: boolean = false;
 
   inputEventMap: EventActionMap;
 
@@ -616,7 +617,9 @@ export abstract class RenderedDataPanel extends RenderedPanel {
     registerActionListener(element, "move-to-mouse-position", () => {
       const { mouseState } = this.viewer;
       if (mouseState.updateUnconditionally()) {
+        this.isMovingToMousePosition = true;
         this.navigationState.position.value = mouseState.position;
+        this.isMovingToMousePosition = false;
       }
     });
 

src/sliceview/uncompressed_chunk_format.ts

@@ -139,7 +139,11 @@ export class ChunkFormat
     );
   }
 
-  defineShader(builder: ShaderBuilder, numChannelDimensions: number) {
+  defineShader(
+    builder: ShaderBuilder,
+    numChannelDimensions: number,
+    inVertexShader: boolean = false,
+  ) {
     super.defineShader(builder, numChannelDimensions);
     const { textureDims } = this;
     const textureVecType = `ivec${this.textureDims}`;
@@ -153,35 +157,39 @@ export class ChunkFormat
       "uVolumeChunkStrides",
       4 + numChannelDimensions,
     );
-    builder.addFragmentCode(
-      textureAccessHelper.getAccessor(
-        "readVolumeData",
-        "uVolumeChunkSampler",
-        this.dataType,
-      ),
+    const textureSamplerCode = textureAccessHelper.getAccessor(
+      "readVolumeData",
+      "uVolumeChunkSampler",
+      this.dataType,
     );
     const shaderType = getShaderType(this.dataType);
-    let code = `
+    let dataAccessCode = `
 ${shaderType} getDataValueAt(highp ivec3 p`;
     for (let channelDim = 0; channelDim < numChannelDimensions; ++channelDim) {
-      code += `, highp int channelIndex${channelDim}`;
+      dataAccessCode += `, highp int channelIndex${channelDim}`;
     }
-    code += `) {
+    dataAccessCode += `) {
   highp ${textureVecType} offset = uVolumeChunkStrides[0]
                      + p.x * uVolumeChunkStrides[1]
                      + p.y * uVolumeChunkStrides[2]
                      + p.z * uVolumeChunkStrides[3];
 `;
     for (let channelDim = 0; channelDim < numChannelDimensions; ++channelDim) {
-      code += `
+      dataAccessCode += `
   offset += channelIndex${channelDim} * uVolumeChunkStrides[${4 + channelDim}];
 `;
     }
-    code += `
+    dataAccessCode += `
   return readVolumeData(offset);
 }
 `;
-    builder.addFragmentCode(code);
+    if (inVertexShader) {
+      builder.addVertexCode(textureSamplerCode);
+      builder.addVertexCode(dataAccessCode);
+    } else {
+      builder.addFragmentCode(textureSamplerCode);
+      builder.addFragmentCode(dataAccessCode);
+    }
   }
 
   /**

src/sliceview/volume/frontend.ts

@@ -52,7 +52,11 @@ export interface ChunkFormat {
    *
    * where value_type is `getShaderType(this.dataType)`.
    */
-  defineShader: (builder: ShaderBuilder, numChannelDimensions: number) => void;
+  defineShader: (
+    builder: ShaderBuilder,
+    numChannelDimensions: number,
+    inVertexShader?: boolean,
+  ) => void;
 
   /**
    * Called once per RenderLayer when starting to draw chunks, on the ChunkFormat of the first