@kitware/vtk.js 24.14.3 → 24.16.1

package/Rendering/Core/Camera.js

@@ -61,7 +61,6 @@ function vtkCamera(publicAPI, model) {
     model.position[2] = z; // recompute the focal distance
 
     publicAPI.computeDistance();
-    publicAPI.computeCameraLightTransform();
     publicAPI.modified();
   };
 
@@ -75,7 +74,6 @@ function vtkCamera(publicAPI, model) {
     model.focalPoint[2] = z; // recompute the focal distance
 
     publicAPI.computeDistance();
-    publicAPI.computeCameraLightTransform();
     publicAPI.modified();
   };
 
@@ -97,7 +95,6 @@ function vtkCamera(publicAPI, model) {
     model.focalPoint[0] = model.position[0] + vec[0] * model.distance;
     model.focalPoint[1] = model.position[1] + vec[1] * model.distance;
     model.focalPoint[2] = model.position[2] + vec[2] * model.distance;
-    publicAPI.computeCameraLightTransform();
     publicAPI.modified();
   }; //----------------------------------------------------------------------------
   // This method must be called when the focal point or camera position changes

package/Rendering/Core/RenderWindowInteractor.d.ts

@@ -173,6 +173,16 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 * 
 	 * @param {IRenderWindowInteractorEvent} callData 
 	 */
+	invokePointerEnter(callData: IRenderWindowInteractorEvent): void;
+
+	/**
+	 *
+	 */
+	invokePointerLeave(callData: IRenderWindowInteractorEvent): void;
+
+	/**
+	 *
+	 */
 	invokeMouseEnter(callData: IRenderWindowInteractorEvent): void;
 
 	/**
@@ -392,6 +402,18 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 * @param {InteractorEventCallback} cb The callback to be called.
 	 * @param {Number} [priority] The priority of the event.
 	 */
+	onPointerEnter(cb: InteractorEventCallback, priority?: number): Readonly<vtkSubscription>;
+
+	/**
+	 *
+	 * @param cb The callback to be called
+	 */
+	onPointerLeave(cb: InteractorEventCallback, priority?: number): Readonly<vtkSubscription>;
+
+	/**
+	 *
+	 * @param cb The callback to be called
+	 */
 	onMouseEnter(cb: InteractorEventCallback, priority?: number): Readonly<vtkSubscription>;
 
 	/**
@@ -949,11 +971,35 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 */
 	handleKeyUp(event: KeyboardEvent): void;
 
+	/**
+	 * 
+	 * @param {PointerEvent} event 
+	 */
+	handlePointerDown(event: PointerEvent): void;
+
+	/**
+	 * 
+	 * @param {PointerEvent} event 
+	 */
+	handlePointerUp(event: PointerEvent): void;
+
+	/**
+	 * 
+	 * @param {PointerEvent} event 
+	 */
+	handlePointerCancel(event: PointerEvent): void;
+
+	/**
+	 * 
+	 * @param {PointerEvent} event 
+	 */
+	handlePointerMove(event: PointerEvent): void;
+
 	/**
 	 *
-	 * @param {MouseEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleMouseDown(event: MouseEvent): void;
+	handleMouseDown(event: PointerEvent): void;
 
 	/**
 	 *
@@ -1011,9 +1057,9 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 
 	/**
 	 *
-	 * @param {MouseEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleMouseMove(event: MouseEvent): void;
+	handleMouseMove(event: PointerEvent): void;
 
 	/**
 	 *
@@ -1028,39 +1074,39 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 
 	/**
 	 *
-	 * @param {MouseEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleMouseEnter(event: MouseEvent): void;
+	handlePointerEnter(event: PointerEvent): void;
 
 	/**
 	 *
-	 * @param {MouseEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleMouseLeave(event: MouseEvent): void;
+	handlePointerLeave(event: PointerEvent): void;
 
 	/**
 	 *
-	 * @param {MouseEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleMouseUp(event: MouseEvent): void;
+	handleMouseUp(event: PointerEvent): void;
 
 	/**
 	 *
-	 * @param {TouchEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleTouchStart(event: TouchEvent): void;
+	handleTouchStart(event: PointerEvent): void;
 
 	/**
 	 *
-	 * @param {TouchEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleTouchMove(event: TouchEvent): void;
+	handleTouchMove(event: PointerEvent): void;
 
 	/**
 	 *
-	 * @param {TouchEvent} event 
+	 * @param {PointerEvent} event 
 	 */
-	handleTouchEnd(event: TouchEvent): void;
+	handleTouchEnd(event: PointerEvent): void;
 
 	/**
 	 *
@@ -1093,7 +1139,7 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 * @param event
 	 * @param positions
 	 */
-	recognizeGesture(event: 'TouchStart' | 'TouchMouve' | 'TouchEnd', positions: IPosition): void;
+	recognizeGesture(event: 'TouchStart' | 'TouchMove' | 'TouchEnd', positions: IPosition): void;
 
 	/**
 	 *

package/Rendering/Core/RenderWindowInteractor.js

@@ -1,3 +1,4 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
@@ -15,10 +16,11 @@ var vtkWarningMacro = macro.vtkWarningMacro,
 // Global methods
 // ----------------------------------------------------------------------------
 
+var EMPTY_MOUSE_EVENT = new MouseEvent('');
 var deviceInputMap = {
   'xr-standard': [Input.Trigger, Input.Grip, Input.TrackPad, Input.Thumbstick, Input.A, Input.B]
 };
-var handledEvents = ['StartAnimation', 'Animation', 'EndAnimation', 'MouseEnter', 'MouseLeave', 'StartMouseMove', 'MouseMove', 'EndMouseMove', 'LeftButtonPress', 'LeftButtonRelease', 'MiddleButtonPress', 'MiddleButtonRelease', 'RightButtonPress', 'RightButtonRelease', 'KeyPress', 'KeyDown', 'KeyUp', 'StartMouseWheel', 'MouseWheel', 'EndMouseWheel', 'StartPinch', 'Pinch', 'EndPinch', 'StartPan', 'Pan', 'EndPan', 'StartRotate', 'Rotate', 'EndRotate', 'Button3D', 'Move3D', 'StartPointerLock', 'EndPointerLock', 'StartInteraction', 'Interaction', 'EndInteraction', 'AnimationFrameRateUpdate'];
+var handledEvents = ['StartAnimation', 'Animation', 'EndAnimation', 'PointerEnter', 'PointerLeave', 'MouseEnter', 'MouseLeave', 'StartMouseMove', 'MouseMove', 'EndMouseMove', 'LeftButtonPress', 'LeftButtonRelease', 'MiddleButtonPress', 'MiddleButtonRelease', 'RightButtonPress', 'RightButtonRelease', 'KeyPress', 'KeyDown', 'KeyUp', 'StartMouseWheel', 'MouseWheel', 'EndMouseWheel', 'StartPinch', 'Pinch', 'EndPinch', 'StartPan', 'Pan', 'EndPan', 'StartRotate', 'Rotate', 'EndRotate', 'Button3D', 'Move3D', 'StartPointerLock', 'EndPointerLock', 'StartInteraction', 'Interaction', 'EndInteraction', 'AnimationFrameRateUpdate'];
 
 function preventDefault(event) {
   if (event.cancelable) {
@@ -27,6 +29,16 @@ function preventDefault(event) {
   }
 
   return false;
+}
+
+function pointerCacheToPositions(cache) {
+  var positions = Object.create(null);
+  cache.forEach(function (_ref) {
+    var pointerId = _ref.pointerId,
+        position = _ref.position;
+    positions[pointerId] = position;
+  });
+  return positions;
 } // ----------------------------------------------------------------------------
 // vtkRenderWindowInteractor methods
 // ----------------------------------------------------------------------------
@@ -36,9 +48,9 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkRenderWindowInteractor'); // Initialize list of requesters
 
-  var animationRequesters = new Set(); // track active event listeners to handle simultaneous button tracking
+  var animationRequesters = new Set(); // map from pointerId to { pointerId: number, position: [x, y] }
 
-  var activeListenerCount = 0; // Public API methods
+  var pointerCache = new Map(); // Public API methods
   //----------------------------------------------------------------------
 
   publicAPI.start = function () {
@@ -127,20 +139,13 @@ function vtkRenderWindowInteractor(publicAPI, model) {
       x: scaleX * (source.clientX - bounds.left),
       y: scaleY * (bounds.height - source.clientY + bounds.top),
       z: 0
-    };
-    updateCurrentRenderer(position.x, position.y);
-    return position;
-  }
-
-  function getTouchEventPositionsFor(touches) {
-    var positions = {};
+    }; // if multitouch, do not update the current renderer
 
-    for (var i = 0; i < touches.length; i++) {
-      var touch = touches[i];
-      positions[touch.identifier] = getScreenEventPositionFor(touch);
+    if (pointerCache.size <= 1 || !model.currentRenderer) {
+      updateCurrentRenderer(position.x, position.y);
     }
 
-    return positions;
+    return position;
   }
 
   function getModifierKeysFor(event) {
@@ -162,40 +167,8 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     return keys;
   }
 
-  function interactionRegistration(addListeners) {
-    var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    var rootElm = document;
-    var method = addListeners ? 'addEventListener' : 'removeEventListener';
-    var invMethod = addListeners ? 'removeEventListener' : 'addEventListener';
-
-    if (!force && !addListeners && activeListenerCount > 0) {
-      --activeListenerCount;
-    } // only add/remove listeners when there are no registered listeners
-
-
-    if (!activeListenerCount || force) {
-      activeListenerCount = 0;
-
-      if (model.container) {
-        model.container[invMethod]('mousemove', publicAPI.handleMouseMove);
-      }
-
-      rootElm[method]('mouseup', publicAPI.handleMouseUp);
-      rootElm[method]('mousemove', publicAPI.handleMouseMove);
-      rootElm[method]('touchend', publicAPI.handleTouchEnd, false);
-      rootElm[method]('touchcancel', publicAPI.handleTouchEnd, {
-        passive: false,
-        capture: false
-      });
-      rootElm[method]('touchmove', publicAPI.handleTouchMove, {
-        passive: false,
-        capture: false
-      });
-    }
-
-    if (!force && addListeners) {
-      ++activeListenerCount;
-    }
+  function getDeviceTypeFor(event) {
+    return event.pointerType || '';
   }
 
   publicAPI.bindEvents = function (container) {
@@ -204,40 +177,50 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
     container.addEventListener('wheel', publicAPI.handleWheel);
     container.addEventListener('DOMMouseScroll', publicAPI.handleWheel);
-    container.addEventListener('mouseenter', publicAPI.handleMouseEnter);
-    container.addEventListener('mouseleave', publicAPI.handleMouseLeave);
-    container.addEventListener('mousemove', publicAPI.handleMouseMove);
-    container.addEventListener('mousedown', publicAPI.handleMouseDown);
+    container.addEventListener('pointerenter', publicAPI.handlePointerEnter);
+    container.addEventListener('pointerleave', publicAPI.handlePointerLeave);
+    container.addEventListener('pointermove', publicAPI.handlePointerMove, {
+      passive: false
+    });
+    container.addEventListener('pointerdown', publicAPI.handlePointerDown, {
+      passive: false
+    });
+    container.addEventListener('pointerup', publicAPI.handlePointerUp);
+    container.addEventListener('pointercancel', publicAPI.handlePointerCancel);
     document.addEventListener('keypress', publicAPI.handleKeyPress);
     document.addEventListener('keydown', publicAPI.handleKeyDown);
     document.addEventListener('keyup', publicAPI.handleKeyUp);
-    document.addEventListener('pointerlockchange', publicAPI.handlePointerLockChange);
-    container.addEventListener('touchstart', publicAPI.handleTouchStart, {
-      passive: false,
-      capture: false
-    });
+    document.addEventListener('pointerlockchange', publicAPI.handlePointerLockChange); // using touchAction is more performant than preventDefault
+    // in a touchstart handler.
+
+    container.style.touchAction = 'none';
+    container.style.userSelect = 'none'; // disables tap highlight for when cursor is pointer
+
+    container.style.webkitTapHighlightColor = 'rgba(0,0,0,0)';
   };
 
   publicAPI.unbindEvents = function () {
-    // force unbinding listeners
-    interactionRegistration(false, true);
-    model.container.removeEventListener('contextmenu', preventDefault); // model.container.removeEventListener('click', preventDefault); // Avoid stopping event propagation
-
-    model.container.removeEventListener('wheel', publicAPI.handleWheel);
-    model.container.removeEventListener('DOMMouseScroll', publicAPI.handleWheel);
-    model.container.removeEventListener('mouseenter', publicAPI.handleMouseEnter);
-    model.container.removeEventListener('mouseleave', publicAPI.handleMouseLeave);
-    model.container.removeEventListener('mousemove', publicAPI.handleMouseMove);
-    model.container.removeEventListener('mousedown', publicAPI.handleMouseDown);
+    var container = model.container;
+    container.removeEventListener('contextmenu', preventDefault); // model.container.removeEventListener('click', preventDefault); // Avoid stopping event propagation
+
+    container.removeEventListener('wheel', publicAPI.handleWheel);
+    container.removeEventListener('DOMMouseScroll', publicAPI.handleWheel);
+    container.removeEventListener('pointerenter', publicAPI.handlePointerEnter);
+    container.removeEventListener('pointerleave', publicAPI.handlePointerLeave);
+    container.removeEventListener('pointermove', publicAPI.handlePointerMove, {
+      passive: false
+    });
+    container.removeEventListener('pointerdown', publicAPI.handlePointerDown, {
+      passive: false
+    });
+    container.removeEventListener('pointerup', publicAPI.handlePointerUp);
+    container.removeEventListener('pointercancel', publicAPI.handlePointerCancel);
     document.removeEventListener('keypress', publicAPI.handleKeyPress);
     document.removeEventListener('keydown', publicAPI.handleKeyDown);
     document.removeEventListener('keyup', publicAPI.handleKeyUp);
     document.removeEventListener('pointerlockchange', publicAPI.handlePointerLockChange);
-    model.container.removeEventListener('touchstart', publicAPI.handleTouchStart, {
-      passive: false,
-      capture: false
-    });
     model.container = null;
+    pointerCache.clear();
   };
 
   publicAPI.handleKeyPress = function (event) {
@@ -255,19 +238,131 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     publicAPI.keyUpEvent(data);
   };
 
-  publicAPI.handleMouseDown = function (event) {
-    if (event.button > 2) {
+  publicAPI.handlePointerEnter = function (event) {
+    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
+    });
+
+    publicAPI.pointerEnterEvent(callData);
+
+    if (callData.deviceType === 'mouse') {
+      publicAPI.mouseEnterEvent(callData);
+    }
+  };
+
+  publicAPI.handlePointerLeave = function (event) {
+    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
+    });
+
+    publicAPI.pointerLeaveEvent(callData);
+
+    if (callData.deviceType === 'mouse') {
+      publicAPI.mouseLeaveEvent(callData);
+    }
+  };
+
+  publicAPI.handlePointerDown = function (event) {
+    if (event.button > 2 || publicAPI.isPointerLocked()) {
       // ignore events from extra mouse buttons such as `back` and `forward`
       return;
     }
 
-    interactionRegistration(true);
     preventDefault(event);
 
-    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
+    if (event.target.hasPointerCapture(event.pointerId)) {
+      event.target.releasePointerCapture(event.pointerId);
+    }
+
+    model.container.setPointerCapture(event.pointerId);
+
+    if (pointerCache.has(event.pointerId)) {
+      vtkWarningMacro('[RenderWindowInteractor] duplicate pointerId detected');
+    }
+
+    pointerCache.set(event.pointerId, {
+      pointerId: event.pointerId,
       position: getScreenEventPositionFor(event)
     });
 
+    switch (event.pointerType) {
+      case 'pen':
+      case 'touch':
+        publicAPI.handleTouchStart(event);
+        break;
+
+      case 'mouse':
+      default:
+        publicAPI.handleMouseDown(event);
+        break;
+    }
+  };
+
+  publicAPI.handlePointerUp = function (event) {
+    if (pointerCache.has(event.pointerId)) {
+      preventDefault(event);
+      pointerCache.delete(event.pointerId);
+      model.container.releasePointerCapture(event.pointerId);
+
+      switch (event.pointerType) {
+        case 'pen':
+        case 'touch':
+          publicAPI.handleTouchEnd(event);
+          break;
+
+        case 'mouse':
+        default:
+          publicAPI.handleMouseUp(event);
+          break;
+      }
+    }
+  };
+
+  publicAPI.handlePointerCancel = function (event) {
+    if (pointerCache.has(event.pointerId)) {
+      pointerCache.delete(event.pointerId);
+
+      switch (event.pointerType) {
+        case 'pen':
+        case 'touch':
+          publicAPI.handleTouchEnd(event);
+          break;
+
+        case 'mouse':
+        default:
+          publicAPI.handleMouseUp(event);
+          break;
+      }
+    }
+  };
+
+  publicAPI.handlePointerMove = function (event) {
+    if (pointerCache.has(event.pointerId)) {
+      var pointer = pointerCache.get(event.pointerId);
+      pointer.position = getScreenEventPositionFor(event);
+
+      switch (event.pointerType) {
+        case 'pen':
+        case 'touch':
+          publicAPI.handleTouchMove(event);
+          break;
+
+        case 'mouse':
+        default:
+          publicAPI.handleMouseMove(event);
+          break;
+      }
+    }
+  };
+
+  publicAPI.handleMouseDown = function (event) {
+    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
+    });
+
     switch (event.button) {
       case 0:
         publicAPI.leftButtonPressEvent(callData);
@@ -457,10 +552,9 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   };
 
   publicAPI.handleMouseMove = function (event) {
-    // Do not consume event for move
-    // preventDefault(event);
     var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
-      position: getScreenEventPositionFor(event)
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
     });
 
     if (model.moveTimeoutID === 0) {
@@ -522,7 +616,8 @@ function vtkRenderWindowInteractor(publicAPI, model) {
      */
 
     var callData = _objectSpread(_objectSpread(_objectSpread({}, normalizeWheel(event)), getModifierKeysFor(event)), {}, {
-      position: getScreenEventPositionFor(event)
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
     });
 
     if (model.wheelTimeoutID === 0) {
@@ -540,28 +635,10 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     }, 200);
   };
 
-  publicAPI.handleMouseEnter = function (event) {
-    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
-      position: getScreenEventPositionFor(event)
-    });
-
-    publicAPI.mouseEnterEvent(callData);
-  };
-
-  publicAPI.handleMouseLeave = function (event) {
-    var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
-      position: getScreenEventPositionFor(event)
-    });
-
-    publicAPI.mouseLeaveEvent(callData);
-  };
-
   publicAPI.handleMouseUp = function (event) {
-    interactionRegistration(false);
-    preventDefault(event);
-
     var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(event)), {}, {
-      position: getScreenEventPositionFor(event)
+      position: getScreenEventPositionFor(event),
+      deviceType: getDeviceTypeFor(event)
     });
 
     switch (event.button) {
@@ -584,107 +661,85 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   };
 
   publicAPI.handleTouchStart = function (event) {
-    interactionRegistration(true);
-    preventDefault(event); // If multitouch
-
-    if (model.recognizeGestures && event.touches.length > 1) {
-      var positions = getTouchEventPositionsFor(event.touches); // did we just transition to multitouch?
-
-      if (event.touches.length === 2) {
-        var touch = event.touches[0];
-        var callData = {
-          position: getScreenEventPositionFor(touch),
-          shiftKey: false,
-          altKey: false,
-          controlKey: false
-        };
+    var pointers = _toConsumableArray(pointerCache.values()); // If multitouch
+
+
+    if (model.recognizeGestures && pointers.length > 1) {
+      var positions = pointerCacheToPositions(pointerCache); // did we just transition to multitouch?
+
+      if (pointers.length === 2) {
+        var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+          position: pointers[0].position,
+          deviceType: getDeviceTypeFor(event)
+        });
+
         publicAPI.leftButtonReleaseEvent(callData);
       } // handle the gesture
 
 
       publicAPI.recognizeGesture('TouchStart', positions);
     } else {
-      var _touch = event.touches[0];
-      var _callData = {
-        position: getScreenEventPositionFor(_touch),
-        shiftKey: false,
-        altKey: false,
-        controlKey: false
-      };
+      var _callData = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+        position: getScreenEventPositionFor(event),
+        deviceType: getDeviceTypeFor(event)
+      });
+
       publicAPI.leftButtonPressEvent(_callData);
     }
   };
 
   publicAPI.handleTouchMove = function (event) {
-    preventDefault(event);
+    var pointers = _toConsumableArray(pointerCache.values());
 
-    if (model.recognizeGestures && event.touches.length > 1) {
-      var positions = getTouchEventPositionsFor(event.touches);
+    if (model.recognizeGestures && pointers.length > 1) {
+      var positions = pointerCacheToPositions(pointerCache);
       publicAPI.recognizeGesture('TouchMove', positions);
     } else {
-      var touch = event.touches[0];
-      var callData = {
-        position: getScreenEventPositionFor(touch),
-        shiftKey: false,
-        altKey: false,
-        controlKey: false
-      };
+      var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+        position: pointers[0].position,
+        deviceType: getDeviceTypeFor(event)
+      });
+
       publicAPI.mouseMoveEvent(callData);
     }
   };
 
   publicAPI.handleTouchEnd = function (event) {
-    preventDefault(event);
+    var pointers = _toConsumableArray(pointerCache.values());
 
     if (model.recognizeGestures) {
       // No more fingers down
-      if (event.touches.length === 0) {
-        // If just one finger released, consider as left button
-        if (event.changedTouches.length === 1) {
-          var touch = event.changedTouches[0];
-          var callData = {
-            position: getScreenEventPositionFor(touch),
-            shiftKey: false,
-            altKey: false,
-            controlKey: false
-          };
-          publicAPI.leftButtonReleaseEvent(callData);
-          interactionRegistration(false);
-        } else {
-          // If more than one finger released, recognize touchend
-          var positions = getTouchEventPositionsFor(event.changedTouches);
-          publicAPI.recognizeGesture('TouchEnd', positions);
-          interactionRegistration(false);
-        }
-      } else if (event.touches.length === 1) {
+      if (pointers.length === 0) {
+        var callData = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+          position: pointers[0].position,
+          deviceType: getDeviceTypeFor(event)
+        });
+
+        publicAPI.leftButtonReleaseEvent(callData);
+      } else if (pointers.length === 1) {
         // If one finger left, end touch and start button press
-        var _positions = getTouchEventPositionsFor(event.changedTouches);
-
-        publicAPI.recognizeGesture('TouchEnd', _positions);
-        var _touch2 = event.touches[0];
-        var _callData2 = {
-          position: getScreenEventPositionFor(_touch2),
-          shiftKey: false,
-          altKey: false,
-          controlKey: false
-        };
+        var positions = pointerCacheToPositions(pointerCache);
+        publicAPI.recognizeGesture('TouchEnd', positions);
+
+        var _callData2 = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+          position: pointers[0].position,
+          deviceType: getDeviceTypeFor(event)
+        });
+
         publicAPI.leftButtonPressEvent(_callData2);
       } else {
         // If more than one finger left, keep touch move
-        var _positions2 = getTouchEventPositionsFor(event.touches);
+        var _positions = pointerCacheToPositions(pointerCache);
 
-        publicAPI.recognizeGesture('TouchMove', _positions2);
+        publicAPI.recognizeGesture('TouchMove', _positions);
       }
     } else {
-      var _touch3 = event.changedTouches[0];
-      var _callData3 = {
-        position: getScreenEventPositionFor(_touch3),
-        shiftKey: false,
-        altKey: false,
-        controlKey: false
-      };
+      var _callData3 = _objectSpread(_objectSpread({}, getModifierKeysFor(EMPTY_MOUSE_EVENT)), {}, {
+        position: pointers[0].position,
+        deviceType: getDeviceTypeFor(event)
+      });
+
       publicAPI.leftButtonReleaseEvent(_callData3);
-      interactionRegistration(false);
     }
   };
 

package/Rendering/Core/VolumeMapper.js

@@ -92,15 +92,16 @@ var DEFAULT_VALUES = {
   ipScalarRange: [-1000000.0, 1000000.0],
   filterMode: FilterMode.OFF,
   // ignored by WebGL so no behavior change
-  preferSizeOverAccuracy: false // Whether to use halfFloat representation of float, when it is inaccurate
-
+  preferSizeOverAccuracy: false,
+  // Whether to use halfFloat representation of float, when it is inaccurate
+  computeNormalFromOpacity: false
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkAbstractMapper.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'blendMode', 'filterMode', 'preferSizeOverAccuracy']);
+  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'blendMode', 'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity']);
   macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);
   macro.event(publicAPI, model, 'lightingActivated'); // Object methods
 

package/Rendering/OpenGL/VolumeMapper.js

@@ -153,6 +153,11 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
 
     if (model.gopacity) {
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::GradientOpacityOn', '#define vtkGradientOpacityOn').result;
+    } // set normal from density
+
+
+    if (model.renderable.getComputeNormalFromOpacity()) {
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::vtkComputeNormalFromOpacity', "#define vtkComputeNormalFromOpacity").result;
     } // if we have a ztexture then declare it and use it
 
 

package/Rendering/OpenGL/glsl/vtkVolumeFS.glsl.js

@@ -1,3 +1,3 @@
-var vtkVolumeFS = "//VTK::System::Dec\n\n/*=========================================================================\n\n  Program:   Visualization Toolkit\n  Module:    vtkVolumeFS.glsl\n\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\n  All rights reserved.\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\n\n     This software is distributed WITHOUT ANY WARRANTY; without even\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n     PURPOSE.  See the above copyright notice for more information.\n\n=========================================================================*/\n// Template for the volume mappers fragment shader\n\n// the output of this shader\n//VTK::Output::Dec\n\nvarying vec3 vertexVCVSOutput;\n\n// first declare the settings from the mapper\n// that impact the code paths in here\n\n// always set vtkNumComponents 1,2,3,4\n//VTK::NumComponents\n\n// possibly define vtkTrilinearOn\n//VTK::TrilinearOn\n\n// possibly define vtkIndependentComponents\n//VTK::IndependentComponentsOn\n\n// possibly define any \"proportional\" components\n//VTK::vtkProportionalComponents\n\n// Define the blend mode to use\n#define vtkBlendMode //VTK::BlendMode\n\n// Possibly define vtkImageLabelOutlineOn\n//VTK::ImageLabelOutlineOn\n\n#ifdef vtkImageLabelOutlineOn\nuniform int outlineThickness;\nuniform float vpWidth;\nuniform float vpHeight;\nuniform float vpOffsetX;\nuniform float vpOffsetY;\nuniform mat4 PCWCMatrix;\nuniform mat4 vWCtoIDX;\n#endif\n\n// define vtkLightComplexity\n//VTK::LightComplexity\n#if vtkLightComplexity > 0\nuniform float vSpecularPower;\nuniform float vAmbient;\nuniform float vDiffuse;\nuniform float vSpecular;\n//VTK::Light::Dec\n#endif\n\n// possibly define vtkGradientOpacityOn\n//VTK::GradientOpacityOn\n#ifdef vtkGradientOpacityOn\nuniform float goscale0;\nuniform float goshift0;\nuniform float gomin0;\nuniform float gomax0;\n#if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\nuniform float goscale1;\nuniform float goshift1;\nuniform float gomin1;\nuniform float gomax1;\n#if vtkNumComponents >= 3\nuniform float goscale2;\nuniform float goshift2;\nuniform float gomin2;\nuniform float gomax2;\n#endif\n#if vtkNumComponents >= 4\nuniform float goscale3;\nuniform float goshift3;\nuniform float gomin3;\nuniform float gomax3;\n#endif\n#endif\n#endif\n\n// if you want to see the raw tiled\n// data in webgl1 uncomment the following line\n// #define debugtile\n\n// camera values\nuniform float camThick;\nuniform float camNear;\nuniform float camFar;\nuniform int cameraParallel;\n\n// values describing the volume geometry\nuniform vec3 vOriginVC;\nuniform vec3 vSpacing;\nuniform ivec3 volumeDimensions; // 3d texture dimensions\nuniform vec3 vPlaneNormal0;\nuniform float vPlaneDistance0;\nuniform vec3 vPlaneNormal1;\nuniform float vPlaneDistance1;\nuniform vec3 vPlaneNormal2;\nuniform float vPlaneDistance2;\nuniform vec3 vPlaneNormal3;\nuniform float vPlaneDistance3;\nuniform vec3 vPlaneNormal4;\nuniform float vPlaneDistance4;\nuniform vec3 vPlaneNormal5;\nuniform float vPlaneDistance5;\n\n//VTK::ClipPlane::Dec\n\n// opacity and color textures\nuniform sampler2D otexture;\nuniform float oshift0;\nuniform float oscale0;\nuniform sampler2D ctexture;\nuniform float cshift0;\nuniform float cscale0;\n\n// jitter texture\nuniform sampler2D jtexture;\n\n// some 3D texture values\nuniform float sampleDistance;\nuniform vec3 vVCToIJK;\n\n// the heights defined below are the locations\n// for the up to four components of the tfuns\n// the tfuns have a height of 2XnumComps pixels so the\n// values are computed to hit the middle of the two rows\n// for that component\n#ifdef vtkIndependentComponentsOn\n#if vtkNumComponents == 2\nuniform float mix0;\nuniform float mix1;\n#define height0 0.25\n#define height1 0.75\n#endif\n#if vtkNumComponents == 3\nuniform float mix0;\nuniform float mix1;\nuniform float mix2;\n#define height0 0.17\n#define height1 0.5\n#define height2 0.83\n#endif\n#if vtkNumComponents == 4\nuniform float mix0;\nuniform float mix1;\nuniform float mix2;\nuniform float mix3;\n#define height0 0.125\n#define height1 0.375\n#define height2 0.625\n#define height3 0.875\n#endif\n#endif\n\n#if vtkNumComponents >= 2\nuniform float oshift1;\nuniform float oscale1;\nuniform float cshift1;\nuniform float cscale1;\n#endif\n#if vtkNumComponents >= 3\nuniform float oshift2;\nuniform float oscale2;\nuniform float cshift2;\nuniform float cscale2;\n#endif\n#if vtkNumComponents >= 4\nuniform float oshift3;\nuniform float oscale3;\nuniform float cshift3;\nuniform float cscale3;\n#endif\n\nuniform vec4 ipScalarRangeMin;\nuniform vec4 ipScalarRangeMax;\n\n// declaration for intermixed geometry\n//VTK::ZBuffer::Dec\n\n//=======================================================================\n// global and custom variables (a temporary section before photorealistics rendering module is complete)\nvec3 rayDirVC;\n\n//=======================================================================\n// Webgl2 specific version of functions\n#if __VERSION__ == 300\n\nuniform highp sampler3D texture1;\n\nvec4 getTextureValue(vec3 pos)\n{\n  vec4 tmp = texture(texture1, pos);\n#if vtkNumComponents == 1\n  tmp.a = tmp.r;\n#endif\n#if vtkNumComponents == 2\n  tmp.a = tmp.g;\n#endif\n#if vtkNumComponents == 3\n  tmp.a = length(tmp.rgb);\n#endif\n  return tmp;\n}\n\n//=======================================================================\n// WebGL1 specific version of functions\n#else\n\nuniform sampler2D texture1;\n\nuniform float texWidth;\nuniform float texHeight;\nuniform int xreps;\nuniform int xstride;\nuniform int ystride;\n\n// if computing trilinear values from multiple z slices\n#ifdef vtkTrilinearOn\nvec4 getTextureValue(vec3 ijk)\n{\n  float zoff = 1.0/float(volumeDimensions.z);\n  vec4 val1 = getOneTextureValue(ijk);\n  vec4 val2 = getOneTextureValue(vec3(ijk.xy, ijk.z + zoff));\n\n  float indexZ = float(volumeDimensions)*ijk.z;\n  float zmix =  indexZ - floor(indexZ);\n\n  return mix(val1, val2, zmix);\n}\n\nvec4 getOneTextureValue(vec3 ijk)\n#else // nearest or fast linear\nvec4 getTextureValue(vec3 ijk)\n#endif\n{\n  vec3 tdims = vec3(volumeDimensions);\n\n#ifdef debugtile\n  vec2 tpos = vec2(ijk.x, ijk.y);\n  vec4 tmp = texture2D(texture1, tpos);\n  tmp.a = 1.0;\n\n#else\n  int z = int(ijk.z * tdims.z);\n  int yz = z / xreps;\n  int xz = z - yz*xreps;\n\n  int tileWidth = volumeDimensions.x/xstride;\n  int tileHeight = volumeDimensions.y/ystride;\n\n  xz *= tileWidth;\n  yz *= tileHeight;\n\n  float ni = float(xz) + (ijk.x*float(tileWidth));\n  float nj = float(yz) + (ijk.y*float(tileHeight));\n\n  vec2 tpos = vec2(ni/texWidth, nj/texHeight);\n\n  vec4 tmp = texture2D(texture1, tpos);\n\n#if vtkNumComponents == 1\n  tmp.a = tmp.r;\n#endif\n#if vtkNumComponents == 2\n  tmp.g = tmp.a;\n#endif\n#if vtkNumComponents == 3\n  tmp.a = length(tmp.rgb);\n#endif\n#endif\n\n  return tmp;\n}\n\n// End of Webgl1 specific code\n//=======================================================================\n#endif\n\n//=======================================================================\n// compute the normal and gradient magnitude for a position\nvec4 computeNormal(vec3 pos, float scalar, vec3 tstep)\n{\n  vec4 result;\n\n  result.x = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)).a - scalar;\n  result.y = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)).a - scalar;\n  result.z = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)).a - scalar;\n\n  // divide by spacing\n  result.xyz /= vSpacing;\n\n  result.w = length(result.xyz);\n\n  // rotate to View Coords\n  result.xyz =\n    result.x * vPlaneNormal0 +\n    result.y * vPlaneNormal2 +\n    result.z * vPlaneNormal4;\n\n  if (result.w > 0.0)\n  {\n    result.xyz /= result.w;\n  }\n  return result;\n}\n\n#ifdef vtkImageLabelOutlineOn\nvec3 fragCoordToIndexSpace(vec4 fragCoord) {\n  vec4 pcPos = vec4(\n    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,\n    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,\n    (fragCoord.z - 0.5) * 2.0,\n    1.0);\n\n  vec4 worldCoord = PCWCMatrix * pcPos;\n  vec4 vertex = (worldCoord/worldCoord.w);\n\n  vec3 index = (vWCtoIDX * vertex).xyz;\n\n  // half voxel fix for labelmapOutline \n  return (index + vec3(0.5)) / vec3(volumeDimensions);\n}\n#endif\n\n//=======================================================================\n// compute the normals and gradient magnitudes for a position\n// for independent components\nmat4 computeMat4Normal(vec3 pos, vec4 tValue, vec3 tstep)\n{\n  mat4 result;\n  vec4 distX = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)) - tValue;\n  vec4 distY = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)) - tValue;\n  vec4 distZ = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)) - tValue;\n\n  // divide by spacing\n  distX /= vSpacing.x;\n  distY /= vSpacing.y;\n  distZ /= vSpacing.z;\n\n  mat3 rot;\n  rot[0] = vPlaneNormal0;\n  rot[1] = vPlaneNormal2;\n  rot[2] = vPlaneNormal4;\n\n#if !defined(vtkComponent0Proportional)\n  result[0].xyz = vec3(distX.r, distY.r, distZ.r);\n  result[0].a = length(result[0].xyz);\n  result[0].xyz *= rot;\n  if (result[0].w > 0.0)\n  {\n    result[0].xyz /= result[0].w;\n  }\n#endif\n\n// optionally compute the 2nd component\n#if vtkNumComponents >= 2 && !defined(vtkComponent1Proportional)\n  result[1].xyz = vec3(distX.g, distY.g, distZ.g);\n  result[1].a = length(result[1].xyz);\n  result[1].xyz *= rot;\n  if (result[1].w > 0.0)\n  {\n    result[1].xyz /= result[1].w;\n  }\n#endif\n\n// optionally compute the 3rd component\n#if vtkNumComponents >= 3 && !defined(vtkComponent2Proportional)\n  result[2].xyz = vec3(distX.b, distY.b, distZ.b);\n  result[2].a = length(result[2].xyz);\n  result[2].xyz *= rot;\n  if (result[2].w > 0.0)\n  {\n    result[2].xyz /= result[2].w;\n  }\n#endif\n\n// optionally compute the 4th component\n#if vtkNumComponents >= 4 && !defined(vtkComponent3Proportional)\n  result[3].xyz = vec3(distX.a, distY.a, distZ.a);\n  result[3].a = length(result[3].xyz);\n  result[3].xyz *= rot;\n  if (result[3].w > 0.0)\n  {\n    result[3].xyz /= result[3].w;\n  }\n#endif\n\n  return result;\n}\n\n//=======================================================================\n// Given a normal compute the gradient opacity factors\n//\nfloat computeGradientOpacityFactor(\n  vec4 normal, float goscale, float goshift, float gomin, float gomax)\n{\n#if defined(vtkGradientOpacityOn)\n  return clamp(normal.a*goscale + goshift, gomin, gomax);\n#else\n  return 1.0;\n#endif\n}\n\n\n//=======================================================================\n// surface light contribution\n\n#if vtkLightComplexity == 3\n// convert vector position from idx to vc\nvec3 IStoVC(vec3 posIS){\n  vec3 posVC = posIS / vVCToIJK;\n  return posVC.x * vPlaneNormal0 + posVC.y * vPlaneNormal2 + posVC.z * vPlaneNormal4 + vOriginVC;\n}\n#endif\n\n#if vtkLightComplexity > 0\nvoid applyLighting(inout vec3 tColor, vec4 normal)\n{\n  vec3 diffuse = vec3(0.0, 0.0, 0.0);\n  vec3 specular = vec3(0.0, 0.0, 0.0);\n  float df, sf = 0.0;\n  for (int i = 0; i < lightNum; i++){\n      df = abs(dot(normal.rgb, -lightDirectionVC[i]));\n      diffuse += df * lightColor[i];\n      sf = pow( abs(dot(lightHalfAngleVC[i],normal.rgb)), vSpecularPower);\n      specular += sf * lightColor[i];\n  }\n  tColor.rgb = tColor.rgb*(diffuse*vDiffuse + vAmbient) + specular*vSpecular;\n}\n  #if vtkLightComplexity < 3\n    void applyLightingDirectional(inout vec3 tColor, vec4 normal)\n    {\n      // everything in VC\n      vec3 diffuse = vec3(0.0);\n      vec3 specular = vec3(0.0);\n      vec3 vertLightDirection;\n      for (int i = 0; i < lightNum; i++){\n        float ndotL,ndotH;\n        vertLightDirection = lightDirectionVC[i];\n        ndotL = dot(normal.xyz, vertLightDirection);\n        if (ndotL < 0.0 && twoSidedLighting)\n        {\n          ndotL = -ndotL;\n        }\n        if (ndotL > 0.0)\n        {\n          diffuse += ndotL * lightColor[i];\n          //specular\n          ndotH = dot(normal.xyz, normalize(rayDirVC + vertLightDirection));\n          if (ndotH < 0.0 && twoSidedLighting)\n          {\n            ndotH = -ndotH;\n          }\n          if (ndotH > 0.0)\n          {\n            specular += pow(ndotH, vSpecularPower) * lightColor[i];\n          }\n        }\n      }\n      tColor.rgb = tColor.rgb*(diffuse*vDiffuse + vAmbient) + specular*vSpecular;\n    }\n  #else\n    void applyLightingPositional(inout vec3 tColor, vec4 normal, vec3 posVC)\n    {\n      // everything in VC\n      vec3 diffuse = vec3(0.0);\n      vec3 specular = vec3(0.0);\n      vec3 vertLightDirection;\n      for (int i = 0; i < lightNum; i++){\n        float distance,attenuation,ndotL,ndotH;\n        vec3 lightDir;\n        if (lightPositional[i] == 1){\n          lightDir = lightDirectionVC[i];\n          vertLightDirection = lightPositionVC[i] - posVC;  // or reverse...?\n          distance = length(vertLightDirection);\n          vertLightDirection = normalize(vertLightDirection);\n          attenuation = 1.0 / (lightAttenuation[i].x\n                              + lightAttenuation[i].y * distance\n                              + lightAttenuation[i].z * distance * distance);\n          // per OpenGL standard cone angle is 90 or less for a spot light`,\n          if (lightConeAngle[i] <= 90.0){\n            float coneDot = dot(normalize(posVC - lightPositionVC[i]), lightDir);\n            if (coneDot >= cos(radians(lightConeAngle[i]))){  // if inside cone\n              attenuation = attenuation * pow(coneDot, lightExponent[i]);\n            }\n            else {\n              attenuation = 0.0;\n            }\n          }\n          ndotL = dot(normal.xyz, vertLightDirection);\n          if (ndotL < 0.0 && twoSidedLighting)\n          {\n            ndotL = -ndotL;\n          }\n          if (ndotL > 0.0)\n          {\n            diffuse += ndotL * attenuation * lightColor[i];\n            //specular\n            ndotH = dot(normal.xyz, normalize(rayDirVC + vertLightDirection));\n            if (ndotH < 0.0 && twoSidedLighting)\n            {\n              ndotH = -ndotH;\n            }\n            if (ndotH > 0.0)\n            {\n              specular += pow(ndotH, vSpecularPower) * attenuation * lightColor[i];\n            }\n          }\n        } else {\n          vertLightDirection = lightDirectionVC[i];\n          ndotL = dot(normal.xyz, vertLightDirection);\n          if (ndotL < 0.0 && twoSidedLighting)\n          {\n            ndotL = -ndotL;\n          }\n          if (ndotL > 0.0)\n          {\n            diffuse += ndotL * lightColor[i];\n            //specular\n            ndotH = dot(normal.xyz, normalize(rayDirVC + vertLightDirection));\n            if (ndotH < 0.0 && twoSidedLighting)\n            {\n              ndotH = -ndotH;\n            }\n            if (ndotH > 0.0)\n            {\n              specular += pow(ndotH, vSpecularPower) * lightColor[i];\n            }\n          }\n        }\n      }\n      tColor.rgb = tColor.rgb * (diffuse * vDiffuse + vAmbient) + specular*vSpecular;\n    }\n  #endif \n#endif\n\n//=======================================================================\n// Given a texture value compute the color and opacity\n//\nvec4 getColorForValue(vec4 tValue, vec3 posIS, vec3 tstep)\n{\n#ifdef vtkImageLabelOutlineOn\n  vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord); // pos in texture space\n  vec4 centerValue = getTextureValue(centerPosIS);\n  bool pixelOnBorder = false;\n  vec4 tColor = texture2D(ctexture, vec2(centerValue.r * cscale0 + cshift0, 0.5));\n\n  // Get alpha of segment from opacity function.\n  tColor.a = texture2D(otexture, vec2(centerValue.r * oscale0 + oshift0, 0.5)).r;\n\n  // Only perform outline check on fragments rendering voxels that aren't invisible.\n  // Saves a bunch of needless checks on the background.\n  // TODO define epsilon when building shader?\n  if (float(tColor.a) > 0.01) {\n    for (int i = -outlineThickness; i <= outlineThickness; i++) {\n      for (int j = -outlineThickness; j <= outlineThickness; j++) {\n        if (i == 0 || j == 0) {\n          continue;\n        }\n\n        vec4 neighborPixelCoord = vec4(gl_FragCoord.x + float(i),\n          gl_FragCoord.y + float(j),\n          gl_FragCoord.z, gl_FragCoord.w);\n\n        vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\n        vec4 value = getTextureValue(neighborPosIS);\n\n        // If any of my neighbours are not the same value as I\n        // am, this means I am on the border of the segment.\n        // We can break the loops\n        if (any(notEqual(value, centerValue))) {\n          pixelOnBorder = true;\n          break;\n        }\n      }\n\n      if (pixelOnBorder == true) {\n        break;\n      }\n    }\n\n    // If I am on the border, I am displayed at full opacity\n    if (pixelOnBorder == true) {\n      tColor.a = 1.0;\n    }\n  }\n\n#else\n  // compute the normal and gradient magnitude if needed\n  // We compute it as a vec4 if possible otherwise a mat4\n  //\n  vec4 goFactor = vec4(1.0,1.0,1.0,1.0);\n\n  // compute the normal vectors as needed\n  #if (vtkLightComplexity > 0) || defined(vtkGradientOpacityOn)\n    #if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\n      mat4 normalMat = computeMat4Normal(posIS, tValue, tstep);\n      #if !defined(vtkComponent0Proportional)\n        vec4 normal0 = normalMat[0];\n      #endif\n      #if !defined(vtkComponent1Proportional)\n        vec4 normal1 = normalMat[1];\n      #endif\n      #if vtkNumComponents > 2\n        #if !defined(vtkComponent2Proportional)\n          vec4 normal2 = normalMat[2];\n        #endif\n        #if vtkNumComponents > 3\n          #if !defined(vtkComponent3Proportional)\n            vec4 normal3 = normalMat[3];\n          #endif\n        #endif\n      #endif\n    #else\n      vec4 normal0 = computeNormal(posIS, tValue.a, tstep);\n    #endif\n  #endif\n\n  // compute gradient opacity factors as needed\n  #if defined(vtkGradientOpacityOn)\n    #if !defined(vtkComponent0Proportional)\n      goFactor.x =\n        computeGradientOpacityFactor(normal0, goscale0, goshift0, gomin0, gomax0);\n    #endif\n    #if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\n      #if !defined(vtkComponent1Proportional)\n        goFactor.y =\n          computeGradientOpacityFactor(normal1, goscale1, goshift1, gomin1, gomax1);\n      #endif\n      #if vtkNumComponents > 2\n        #if !defined(vtkComponent2Proportional)\n          goFactor.z =\n            computeGradientOpacityFactor(normal2, goscale2, goshift2, gomin2, gomax2);\n        #endif\n        #if vtkNumComponents > 3\n          #if !defined(vtkComponent3Proportional)\n            goFactor.w =\n              computeGradientOpacityFactor(normal3, goscale3, goshift3, gomin3, gomax3);\n          #endif\n        #endif\n      #endif\n    #endif\n  #endif\n\n  // single component is always independent\n  #if vtkNumComponents == 1\n    vec4 tColor = texture2D(ctexture, vec2(tValue.r * cscale0 + cshift0, 0.5));\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, 0.5)).r;\n  #endif\n\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n    vec4 tColor = mix0*texture2D(ctexture, vec2(tValue.r * cscale0 + cshift0, height0));\n    #if !defined(vtkComponent0Proportional)\n      tColor.a = goFactor.x*mix0*texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, height0)).r;\n    #else\n      float pwfValue = texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, height0)).r;\n      tColor *= pwfValue;\n      tColor.a *= mix(pwfValue, 1.0, (1.0 - mix0));\n    #endif\n\n    vec3 tColor1 = mix1*texture2D(ctexture, vec2(tValue.g * cscale1 + cshift1, height1)).rgb;\n    #if !defined(vtkComponent1Proportional)\n      tColor.a += goFactor.y*mix1*texture2D(otexture, vec2(tValue.g * oscale1 + oshift1, height1)).r;\n    #else\n      float pwfValue = texture2D(otexture, vec2(tValue.g * oscale1 + oshift1, height1)).r;\n      tColor1 *= pwfValue;\n      tColor.a *= mix(pwfValue, 1.0, (1.0 - mix1));\n    #endif\n\n    #if vtkNumComponents >= 3\n      vec3 tColor2 = mix2*texture2D(ctexture, vec2(tValue.b * cscale2 + cshift2, height2)).rgb;\n      #if !defined(vtkComponent2Proportional)\n        tColor.a += goFactor.z*mix2*texture2D(otexture, vec2(tValue.b * oscale2 + oshift2, height2)).r;\n      #else\n        float pwfValue = texture2D(otexture, vec2(tValue.b * oscale2 + oshift2, height2)).r;\n        tColor2 *= pwfValue;\n        tColor.a *= mix(pwfValue, 1.0, (1.0 - mix2));\n      #endif\n\n      #if vtkNumComponents >= 4\n        vec3 tColor3 = mix3*texture2D(ctexture, vec2(tValue.a * cscale3 + cshift3, height3)).rgb;\n        #if !defined(vtkComponent3Proportional)\n          tColor.a += goFactor.w*mix3*texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, height3)).r;\n        #else\n          float pwfValue = texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, height3)).r;\n          tColor3 *= pwfValue;\n          tColor.a *= mix(pwfValue, 1.0, (1.0 - mix3));\n        #endif\n      #endif\n    #endif\n  #else // then not independent\n\n  #if vtkNumComponents == 2\n    float lum = tValue.r * cscale0 + cshift0;\n    float alpha = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale1 + oshift1, 0.5)).r;\n    vec4 tColor = vec4(lum, lum, lum, alpha);\n  #endif\n  #if vtkNumComponents == 3\n    vec4 tColor;\n    tColor.r = tValue.r * cscale0 + cshift0;\n    tColor.g = tValue.g * cscale1 + cshift1;\n    tColor.b = tValue.b * cscale2 + cshift2;\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale0 + oshift0, 0.5)).r;\n  #endif\n  #if vtkNumComponents == 4\n    vec4 tColor;\n    tColor.r = tValue.r * cscale0 + cshift0;\n    tColor.g = tValue.g * cscale1 + cshift1;\n    tColor.b = tValue.b * cscale2 + cshift2;\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, 0.5)).r;\n  #endif\n  #endif // dependent\n\n  // apply lighting if requested as appropriate\n  #if vtkLightComplexity > 0\n    #if !defined(vtkComponent0Proportional)\n      #if vtkLightComplexity < 3\n        applyLightingDirectional(tColor.rgb, vec4(normalize(normal0.xyz),normal0.w));\n      #else\n        applyLightingPositional(tColor.rgb, vec4(normalize(normal0.xyz),normal0.w), IStoVC(posIS));\n      #endif\n    #endif\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n    #if !defined(vtkComponent1Proportional)\n      applyLighting(tColor1, normal1);\n    #endif\n  #if vtkNumComponents >= 3\n    #if !defined(vtkComponent2Proportional)\n      applyLighting(tColor2, normal2);\n    #endif\n  #if vtkNumComponents >= 4\n    #if !defined(vtkComponent3Proportional)\n      applyLighting(tColor3, normal3);\n    #endif\n  #endif\n  #endif\n  #endif\n  #endif\n\n// perform final independent blend as needed\n#if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n  tColor.rgb += tColor1;\n#if vtkNumComponents >= 3\n  tColor.rgb += tColor2;\n#if vtkNumComponents >= 4\n  tColor.rgb += tColor3;\n#endif\n#endif\n#endif\n\n#endif\n\n\n\n\n\n\n\nreturn tColor;\n}\n\nbool valueWithinScalarRange(vec4 val, vec4 min, vec4 max) {\n  bool withinRange = false;\n  #if vtkNumComponents == 1\n    if (val.r >= min.r && val.r <= max.r) {\n      withinRange = true;\n    }\n  #endif\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents == 2\n     if (val.r >= min.r && val.r <= max.r &&\n        val.g >= min.g && val.g <= max.g) {\n      withinRange = true;\n    }\n  #endif\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 3\n    if (all(greaterThanEqual(val, ipScalarRangeMin)) &&\n        all(lessThanEqual(val, ipScalarRangeMax))) {\n      withinRange = true;\n    }\n  #endif\n  return withinRange;\n}\n\n//=======================================================================\n// Apply the specified blend mode operation along the ray's path.\n//\nvoid applyBlend(vec3 posIS, vec3 endIS, float sampleDistanceIS, vec3 tdims)\n{\n  vec3 tstep = 1.0/tdims;\n\n  // start slightly inside and apply some jitter\n  vec3 delta = endIS - posIS;\n  vec3 stepIS = normalize(delta)*sampleDistanceIS;\n  float raySteps = length(delta)/sampleDistanceIS;\n\n  // avoid 0.0 jitter\n  float jitter = 0.01 + 0.99*texture2D(jtexture, gl_FragCoord.xy/32.0).r;\n  float stepsTraveled = jitter;\n\n  // local vars for the loop\n  vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n  vec4 tValue;\n  vec4 tColor;\n\n  // if we have less than one step then pick the middle point\n  // as our value\n  // if (raySteps <= 1.0)\n  // {\n  //   posIS = (posIS + endIS)*0.5;\n  // }\n\n  // Perform initial step at the volume boundary\n  // compute the scalar\n  tValue = getTextureValue(posIS);\n\n  #if vtkBlendMode == 0 // COMPOSITE_BLEND\n    // now map through opacity and color\n    tColor = getColorForValue(tValue, posIS, tstep);\n\n    // handle very thin volumes\n    if (raySteps <= 1.0)\n    {\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps);\n      gl_FragData[0] = tColor;\n      return;\n    }\n\n    tColor.a = 1.0 - pow(1.0 - tColor.a, jitter);\n    color = vec4(tColor.rgb*tColor.a, tColor.a);\n    posIS += (jitter*stepIS);\n\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // now map through opacity and color\n      tColor = getColorForValue(tValue, posIS, tstep);\n\n      float mix = (1.0 - color.a);\n\n      // this line should not be needed but nvidia seems to not handle\n      // the break correctly on windows/chrome 58 angle\n      //mix = mix * sign(max(raySteps - stepsTraveled - 1.0, 0.0));\n\n      color = color + vec4(tColor.rgb*tColor.a, tColor.a)*mix;\n      stepsTraveled++;\n      posIS += stepIS;\n      if (color.a > 0.99) { color.a = 1.0; break; }\n    }\n\n    if (color.a < 0.99 && (raySteps - stepsTraveled) > 0.0)\n    {\n      posIS = endIS;\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // now map through opacity and color\n      tColor = getColorForValue(tValue, posIS, tstep);\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps - stepsTraveled);\n\n      float mix = (1.0 - color.a);\n      color = color + vec4(tColor.rgb*tColor.a, tColor.a)*mix;\n    }\n\n    gl_FragData[0] = vec4(color.rgb/color.a, color.a);\n  #endif\n  #if vtkBlendMode == 1 || vtkBlendMode == 2\n    // MAXIMUM_INTENSITY_BLEND || MINIMUM_INTENSITY_BLEND\n    // Find maximum/minimum intensity along the ray.\n\n    // Define the operation we will use (min or max)\n    #if vtkBlendMode == 1\n    #define OP max\n    #else\n    #define OP min\n    #endif\n\n    // If the clipping range is shorter than the sample distance\n    // we can skip the sampling loop along the ray.\n    if (raySteps <= 1.0)\n    {\n      gl_FragData[0] = getColorForValue(tValue, posIS, tstep);\n      return;\n    }\n\n    vec4 value = tValue;\n    posIS += (jitter*stepIS);\n\n    // Sample along the ray until MaximumSamplesValue,\n    // ending slightly inside the total distance\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      // If we have reached the last step, break\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // Update the maximum value if necessary\n      value = OP(tValue, value);\n\n      // Otherwise, continue along the ray\n      stepsTraveled++;\n      posIS += stepIS;\n    }\n\n    // Perform the last step along the ray using the\n    // residual distance\n    posIS = endIS;\n    tValue = getTextureValue(posIS);\n    value = OP(tValue, value);\n\n    // Now map through opacity and color\n    gl_FragData[0] = getColorForValue(value, posIS, tstep);\n  #endif\n  #if vtkBlendMode == 3 || vtkBlendMode == 4 //AVERAGE_INTENSITY_BLEND || ADDITIVE_BLEND\n    vec4 sum = vec4(0.);\n\n    if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n      sum += tValue;\n    }\n\n    if (raySteps <= 1.0) {\n      gl_FragData[0] = getColorForValue(sum, posIS, tstep);\n      return;\n    }\n\n    posIS += (jitter*stepIS);\n\n    // Sample along the ray until MaximumSamplesValue,\n    // ending slightly inside the total distance\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      // If we have reached the last step, break\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // One can control the scalar range by setting the AverageIPScalarRange to disregard scalar values, not in the range of interest, from the average computation.\n      // Notes:\n      // - We are comparing all values in the texture to see if any of them\n      //   are outside of the scalar range. In the future we might want to allow\n      //   scalar ranges for each component.\n      if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n        // Sum the values across each step in the path\n        sum += tValue;\n      }\n      stepsTraveled++;\n      posIS += stepIS;\n    }\n\n    // Perform the last step along the ray using the\n    // residual distance\n    posIS = endIS;\n\n    // compute the scalar\n    tValue = getTextureValue(posIS);\n\n    // One can control the scalar range by setting the IPScalarRange to disregard scalar values, not in the range of interest, from the average computation\n    if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n      sum += tValue;\n\n      stepsTraveled++;\n    }\n\n    #if vtkBlendMode == 3 // Average\n      sum /= vec4(stepsTraveled, stepsTraveled, stepsTraveled, 1.0);\n    #endif\n\n    gl_FragData[0] = getColorForValue(sum, posIS, tstep);\n  #endif\n}\n\n//=======================================================================\n// Compute a new start and end point for a given ray based\n// on the provided bounded clipping plane (aka a rectangle)\nvoid getRayPointIntersectionBounds(\n  vec3 rayPos, vec3 rayDir,\n  vec3 planeDir, float planeDist,\n  inout vec2 tbounds, vec3 vPlaneX, vec3 vPlaneY,\n  float vSize1, float vSize2)\n{\n  float result = dot(rayDir, planeDir);\n  if (abs(result) < 1e-6)\n  {\n    return;\n  }\n  result = -1.0 * (dot(rayPos, planeDir) + planeDist) / result;\n  vec3 xposVC = rayPos + rayDir*result;\n  vec3 vxpos = xposVC - vOriginVC;\n  vec2 vpos = vec2(\n    dot(vxpos, vPlaneX),\n    dot(vxpos, vPlaneY));\n\n  // on some apple nvidia systems this does not work\n  // if (vpos.x < 0.0 || vpos.x > vSize1 ||\n  //     vpos.y < 0.0 || vpos.y > vSize2)\n  // even just\n  // if (vpos.x < 0.0 || vpos.y < 0.0)\n  // fails\n  // so instead we compute a value that represents in and out\n  //and then compute the return using this value\n  float xcheck = max(0.0, vpos.x * (vpos.x - vSize1)); //  0 means in bounds\n  float check = sign(max(xcheck, vpos.y * (vpos.y - vSize2))); //  0 means in bounds, 1 = out\n\n  tbounds = mix(\n   vec2(min(tbounds.x, result), max(tbounds.y, result)), // in value\n   tbounds, // out value\n   check);  // 0 in 1 out\n}\n\n//=======================================================================\n// given a\n// - ray direction (rayDir)\n// - starting point (vertexVCVSOutput)\n// - bounding planes of the volume\n// - optionally depth buffer values\n// - far clipping plane\n// compute the start/end distances of the ray we need to cast\nvec2 computeRayDistances(vec3 rayDir, vec3 tdims)\n{\n  vec2 dists = vec2(100.0*camFar, -1.0);\n\n  vec3 vSize = vSpacing*tdims;\n\n  // all this is in View Coordinates\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal0, vPlaneDistance0, dists, vPlaneNormal2, vPlaneNormal4,\n    vSize.y, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal1, vPlaneDistance1, dists, vPlaneNormal2, vPlaneNormal4,\n    vSize.y, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal2, vPlaneDistance2, dists, vPlaneNormal0, vPlaneNormal4,\n    vSize.x, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal3, vPlaneDistance3, dists, vPlaneNormal0, vPlaneNormal4,\n    vSize.x, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal4, vPlaneDistance4, dists, vPlaneNormal0, vPlaneNormal2,\n    vSize.x, vSize.y);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal5, vPlaneDistance5, dists, vPlaneNormal0, vPlaneNormal2,\n    vSize.x, vSize.y);\n\n  //VTK::ClipPlane::Impl\n\n  // do not go behind front clipping plane\n  dists.x = max(0.0,dists.x);\n\n  // do not go PAST far clipping plane\n  float farDist = -camThick/rayDir.z;\n  dists.y = min(farDist,dists.y);\n\n  // Do not go past the zbuffer value if set\n  // This is used for intermixing opaque geometry\n  //VTK::ZBuffer::Impl\n\n  return dists;\n}\n\n//=======================================================================\n// Compute the index space starting position (pos) and end\n// position\n//\nvoid computeIndexSpaceValues(out vec3 pos, out vec3 endPos, out float sampleDistanceIS, vec3 rayDir, vec2 dists)\n{\n  // compute starting and ending values in volume space\n  pos = vertexVCVSOutput + dists.x*rayDir;\n  pos = pos - vOriginVC;\n  // convert to volume basis and origin\n  pos = vec3(\n    dot(pos, vPlaneNormal0),\n    dot(pos, vPlaneNormal2),\n    dot(pos, vPlaneNormal4));\n\n  endPos = vertexVCVSOutput + dists.y*rayDir;\n  endPos = endPos - vOriginVC;\n  endPos = vec3(\n    dot(endPos, vPlaneNormal0),\n    dot(endPos, vPlaneNormal2),\n    dot(endPos, vPlaneNormal4));\n\n  float delta = length(endPos - pos);\n\n  pos *= vVCToIJK;\n  endPos *= vVCToIJK;\n\n  float delta2 = length(endPos - pos);\n  sampleDistanceIS = sampleDistance*delta2/delta;\n}\n\nvoid main()\n{\n\n  if (cameraParallel == 1)\n  {\n    // Camera is parallel, so the rayDir is just the direction of the camera.\n    rayDirVC = vec3(0.0, 0.0, -1.0);\n  } else {\n    // camera is at 0,0,0 so rayDir for perspective is just the vc coord\n    rayDirVC = normalize(vertexVCVSOutput);\n  }\n\n  vec3 tdims = vec3(volumeDimensions);\n\n  // compute the start and end points for the ray\n  vec2 rayStartEndDistancesVC = computeRayDistances(rayDirVC, tdims);\n\n  // do we need to composite? aka does the ray have any length\n  // If not, bail out early\n  if (rayStartEndDistancesVC.y <= rayStartEndDistancesVC.x)\n  {\n    discard;\n  }\n\n  // IS = Index Space\n  vec3 posIS;\n  vec3 endIS;\n  float sampleDistanceIS;\n  computeIndexSpaceValues(posIS, endIS, sampleDistanceIS, rayDirVC, rayStartEndDistancesVC);\n\n  // Perform the blending operation along the ray\n  applyBlend(posIS, endIS, sampleDistanceIS, tdims);\n}\n";
+var vtkVolumeFS = "//VTK::System::Dec\n\n/*=========================================================================\n\n  Program:   Visualization Toolkit\n  Module:    vtkVolumeFS.glsl\n\n  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen\n  All rights reserved.\n  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.\n\n     This software is distributed WITHOUT ANY WARRANTY; without even\n     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n     PURPOSE.  See the above copyright notice for more information.\n\n=========================================================================*/\n// Template for the volume mappers fragment shader\n\n// the output of this shader\n//VTK::Output::Dec\n\nvarying vec3 vertexVCVSOutput;\n\n// first declare the settings from the mapper\n// that impact the code paths in here\n\n// always set vtkNumComponents 1,2,3,4\n//VTK::NumComponents\n\n// possibly define vtkTrilinearOn\n//VTK::TrilinearOn\n\n// possibly define vtkIndependentComponents\n//VTK::IndependentComponentsOn\n\n// possibly define any \"proportional\" components\n//VTK::vtkProportionalComponents\n\n// Define the blend mode to use\n#define vtkBlendMode //VTK::BlendMode\n\n// Possibly define vtkImageLabelOutlineOn\n//VTK::ImageLabelOutlineOn\n\n#ifdef vtkImageLabelOutlineOn\nuniform int outlineThickness;\nuniform float vpWidth;\nuniform float vpHeight;\nuniform float vpOffsetX;\nuniform float vpOffsetY;\nuniform mat4 PCWCMatrix;\nuniform mat4 vWCtoIDX;\n#endif\n\n// define vtkLightComplexity\n//VTK::LightComplexity\n#if vtkLightComplexity > 0\nuniform float vSpecularPower;\nuniform float vAmbient;\nuniform float vDiffuse;\nuniform float vSpecular;\n//VTK::Light::Dec\n#endif\n\n// define vtkComputeNormalFromOpacity\n//VTK::vtkComputeNormalFromOpacity\n\n// possibly define vtkGradientOpacityOn\n//VTK::GradientOpacityOn\n#ifdef vtkGradientOpacityOn\nuniform float goscale0;\nuniform float goshift0;\nuniform float gomin0;\nuniform float gomax0;\n#if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\nuniform float goscale1;\nuniform float goshift1;\nuniform float gomin1;\nuniform float gomax1;\n#if vtkNumComponents >= 3\nuniform float goscale2;\nuniform float goshift2;\nuniform float gomin2;\nuniform float gomax2;\n#endif\n#if vtkNumComponents >= 4\nuniform float goscale3;\nuniform float goshift3;\nuniform float gomin3;\nuniform float gomax3;\n#endif\n#endif\n#endif\n\n// if you want to see the raw tiled\n// data in webgl1 uncomment the following line\n// #define debugtile\n\n// camera values\nuniform float camThick;\nuniform float camNear;\nuniform float camFar;\nuniform int cameraParallel;\n\n// values describing the volume geometry\nuniform vec3 vOriginVC;\nuniform vec3 vSpacing;\nuniform ivec3 volumeDimensions; // 3d texture dimensions\nuniform vec3 vPlaneNormal0;\nuniform float vPlaneDistance0;\nuniform vec3 vPlaneNormal1;\nuniform float vPlaneDistance1;\nuniform vec3 vPlaneNormal2;\nuniform float vPlaneDistance2;\nuniform vec3 vPlaneNormal3;\nuniform float vPlaneDistance3;\nuniform vec3 vPlaneNormal4;\nuniform float vPlaneDistance4;\nuniform vec3 vPlaneNormal5;\nuniform float vPlaneDistance5;\n\n//VTK::ClipPlane::Dec\n\n// opacity and color textures\nuniform sampler2D otexture;\nuniform float oshift0;\nuniform float oscale0;\nuniform sampler2D ctexture;\nuniform float cshift0;\nuniform float cscale0;\n\n// jitter texture\nuniform sampler2D jtexture;\n\n// some 3D texture values\nuniform float sampleDistance;\nuniform vec3 vVCToIJK;\n\n// the heights defined below are the locations\n// for the up to four components of the tfuns\n// the tfuns have a height of 2XnumComps pixels so the\n// values are computed to hit the middle of the two rows\n// for that component\n#ifdef vtkIndependentComponentsOn\n#if vtkNumComponents == 2\nuniform float mix0;\nuniform float mix1;\n#define height0 0.25\n#define height1 0.75\n#endif\n#if vtkNumComponents == 3\nuniform float mix0;\nuniform float mix1;\nuniform float mix2;\n#define height0 0.17\n#define height1 0.5\n#define height2 0.83\n#endif\n#if vtkNumComponents == 4\nuniform float mix0;\nuniform float mix1;\nuniform float mix2;\nuniform float mix3;\n#define height0 0.125\n#define height1 0.375\n#define height2 0.625\n#define height3 0.875\n#endif\n#endif\n\n#if vtkNumComponents >= 2\nuniform float oshift1;\nuniform float oscale1;\nuniform float cshift1;\nuniform float cscale1;\n#endif\n#if vtkNumComponents >= 3\nuniform float oshift2;\nuniform float oscale2;\nuniform float cshift2;\nuniform float cscale2;\n#endif\n#if vtkNumComponents >= 4\nuniform float oshift3;\nuniform float oscale3;\nuniform float cshift3;\nuniform float cscale3;\n#endif\n\nuniform vec4 ipScalarRangeMin;\nuniform vec4 ipScalarRangeMax;\n\n// declaration for intermixed geometry\n//VTK::ZBuffer::Dec\n\n//=======================================================================\n// global and custom variables (a temporary section before photorealistics rendering module is complete)\nvec3 rayDirVC;\n\n//=======================================================================\n// Webgl2 specific version of functions\n#if __VERSION__ == 300\n\nuniform highp sampler3D texture1;\n\nvec4 getTextureValue(vec3 pos)\n{\n  vec4 tmp = texture(texture1, pos);\n#if vtkNumComponents == 1\n  tmp.a = tmp.r;\n#endif\n#if vtkNumComponents == 2\n  tmp.a = tmp.g;\n#endif\n#if vtkNumComponents == 3\n  tmp.a = length(tmp.rgb);\n#endif\n  return tmp;\n}\n\n//=======================================================================\n// WebGL1 specific version of functions\n#else\n\nuniform sampler2D texture1;\n\nuniform float texWidth;\nuniform float texHeight;\nuniform int xreps;\nuniform int xstride;\nuniform int ystride;\n\n// if computing trilinear values from multiple z slices\n#ifdef vtkTrilinearOn\nvec4 getTextureValue(vec3 ijk)\n{\n  float zoff = 1.0/float(volumeDimensions.z);\n  vec4 val1 = getOneTextureValue(ijk);\n  vec4 val2 = getOneTextureValue(vec3(ijk.xy, ijk.z + zoff));\n\n  float indexZ = float(volumeDimensions)*ijk.z;\n  float zmix =  indexZ - floor(indexZ);\n\n  return mix(val1, val2, zmix);\n}\n\nvec4 getOneTextureValue(vec3 ijk)\n#else // nearest or fast linear\nvec4 getTextureValue(vec3 ijk)\n#endif\n{\n  vec3 tdims = vec3(volumeDimensions);\n\n#ifdef debugtile\n  vec2 tpos = vec2(ijk.x, ijk.y);\n  vec4 tmp = texture2D(texture1, tpos);\n  tmp.a = 1.0;\n\n#else\n  int z = int(ijk.z * tdims.z);\n  int yz = z / xreps;\n  int xz = z - yz*xreps;\n\n  int tileWidth = volumeDimensions.x/xstride;\n  int tileHeight = volumeDimensions.y/ystride;\n\n  xz *= tileWidth;\n  yz *= tileHeight;\n\n  float ni = float(xz) + (ijk.x*float(tileWidth));\n  float nj = float(yz) + (ijk.y*float(tileHeight));\n\n  vec2 tpos = vec2(ni/texWidth, nj/texHeight);\n\n  vec4 tmp = texture2D(texture1, tpos);\n\n#if vtkNumComponents == 1\n  tmp.a = tmp.r;\n#endif\n#if vtkNumComponents == 2\n  tmp.g = tmp.a;\n#endif\n#if vtkNumComponents == 3\n  tmp.a = length(tmp.rgb);\n#endif\n#endif\n\n  return tmp;\n}\n\n// End of Webgl1 specific code\n//=======================================================================\n#endif\n\n//=======================================================================\n// Given a normal compute the gradient opacity factors\nfloat computeGradientOpacityFactor(\n  float normalMag, float goscale, float goshift, float gomin, float gomax)\n{\n#if defined(vtkGradientOpacityOn)\n  return clamp(normalMag * goscale + goshift, gomin, gomax);\n#else\n  return 1.0;\n#endif\n}\n\n//=======================================================================\n//Rotate gradients to view coordinate\n#if (vtkLightComplexity > 0) || (defined vtkGradientOpacityOn)\nvoid rotateToViewCoord(inout vec3 normalIDX){\n  normalIDX.xyz =\n  normalIDX.x * vPlaneNormal0 +\n  normalIDX.y * vPlaneNormal2 +\n  normalIDX.z * vPlaneNormal4;\n}\n#endif\n//=======================================================================\n// compute the normal and gradient magnitude for a position, uses forward difference\n#if vtkLightComplexity > 0\n  #ifdef vtkComputeNormalFromOpacity\n    #ifdef vtkGradientOpacityOn\n      vec4 computeNormalForDensity(vec3 pos, float scalar, vec3 tstep, out mat3 scalarInterp, out vec3 secondaryGradientMag)\n      {\n        vec4 result;\n        scalarInterp[0][0] = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)).a;\n        scalarInterp[0][1] = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)).a;\n        scalarInterp[0][2] = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)).a;\n        // look up scalar values for computing secondary gradient\n        scalarInterp[1][0] = getTextureValue(pos + vec3(2.0*tstep.x, 0.0, 0.0)).a;\n        scalarInterp[1][1] = getTextureValue(pos + vec3(0.0, 2.0*tstep.y, 0.0)).a;\n        scalarInterp[1][2] = getTextureValue(pos + vec3(0.0, 0.0, 2.0*tstep.z)).a;\n        scalarInterp[2][0] = getTextureValue(pos + vec3(tstep.x, tstep.y, 0.0)).a;\n        scalarInterp[2][1] = getTextureValue(pos + vec3(tstep.x, 0.0, tstep.z)).a;\n        scalarInterp[2][2] = getTextureValue(pos + vec3(0.0, tstep.y, tstep.z)).a;\n        result.x = scalarInterp[0][0] - scalar;\n        result.y = scalarInterp[0][1] - scalar;\n        result.z = scalarInterp[0][2] - scalar;\n        // divide by spacing\n        result.xyz /= vSpacing;\n        result.w = length(result.xyz);\n        rotateToViewCoord(result.xyz);\n        secondaryGradientMag.x = length(vec3(scalarInterp[1][0] - scalarInterp[0][0],\n                                             scalarInterp[2][0] - scalarInterp[0][0],\n                                             scalarInterp[2][1] - scalarInterp[0][0]) / vSpacing);\n        secondaryGradientMag.y = length(vec3(scalarInterp[2][0] - scalarInterp[0][1],\n                                             scalarInterp[1][1] - scalarInterp[0][1],\n                                             scalarInterp[2][2] - scalarInterp[0][1]) / vSpacing);\n        secondaryGradientMag.z = length(vec3(scalarInterp[2][1] - scalarInterp[0][2],\n                                             scalarInterp[2][2] - scalarInterp[0][2],\n                                             scalarInterp[1][2] - scalarInterp[0][2]) / vSpacing);\n        if (length(result.xyz) > 0.0) {\n          return vec4(normalize(result.xyz),result.w);\n        } else {\n          return vec4(0.0);\n        }\n      }\n\n      vec4 computeDensityNormal(float scalar, float gradientMag, mat3 scalarInterp, vec3 secondaryGradientMag)\n      {\n        vec4 opacityG;\n        vec3 opacityInterp = vec3(0.0);\n        float opacity = texture2D(otexture, vec2(scalar * oscale0 + oshift0, 0.5)).r;\n        if (gradientMag >= 0.0){\n          opacity *= computeGradientOpacityFactor(gradientMag, goscale0, goshift0, gomin0, gomax0);\n        }\n        opacityInterp.x = texture2D(otexture, vec2(scalarInterp[0][0] * oscale0 + oshift0, 0.5)).r; \n        if (secondaryGradientMag.x >= 0.0){\n        // opacityInterp.x *= computeGradientOpacityFactor(secondaryGradientMag.x, goscale0, goshift0, gomin0, gomax0);\n        }\n    \n        opacityInterp.y = texture2D(otexture, vec2(scalarInterp[0][1] * oscale0 + oshift0, 0.5)).r;\n        if (secondaryGradientMag.y >= 0.0){\n        // opacityInterp.y *= computeGradientOpacityFactor(secondaryGradientMag.y, goscale0, goshift0, gomin0, gomax0);\n        }\n\n        opacityInterp.z = texture2D(otexture, vec2(scalarInterp[0][2] * oscale0 + oshift0, 0.5)).r;\n        if (secondaryGradientMag.z >= 0.0){\n        // opacityInterp.z *= computeGradientOpacityFactor(secondaryGradientMag.z, goscale0, goshift0, gomin0, gomax0);\n        }\n\n        opacityG.xyz = opacityInterp - vec3(opacity,opacity,opacity);\n        // divide by spacing\n        opacityG.xyz /= vSpacing;\n        opacityG.w = length(opacityG.xyz);\n        rotateToViewCoord(opacityG.xyz);\n        if (length(opacityG.xyz) > 0.0) {  \n          return vec4(normalize(opacityG.xyz),opacityG.w);\n        } else {\n          return vec4(0.0);\n        }\n      } \n\n    #else\n    //if gradient opacity not on but using density gradient\n      vec4 computeDensityNormal(float scalar, vec3 scalarInterp) \n      { \n        vec4 opacityG; \n        float opacity = texture2D(otexture, vec2(scalar * oscale0 + oshift0, 0.5)).r; \n        opacityG.x = texture2D(otexture, vec2(scalarInterp.x * oscale0 + oshift0, 0.5)).r - opacity; \n        opacityG.y = texture2D(otexture, vec2(scalarInterp.y * oscale0 + oshift0, 0.5)).r - opacity; \n        opacityG.z = texture2D(otexture, vec2(scalarInterp.z * oscale0 + oshift0, 0.5)).r - opacity; \n        // divide by spacing \n        opacityG.xyz /= vSpacing; \n        opacityG.w = length(opacityG.xyz); \n        // rotate to View Coords \n        rotateToViewCoord(opacityG.xyz);\n        if (length(opacityG.xyz) > 0.0) {     \n          return vec4(normalize(opacityG.xyz),opacityG.w); \n        } else { \n          return vec4(0.0); \n        } \n      } \n      vec4 computeNormalForDensity(vec3 pos, float scalar, vec3 tstep, out vec3 scalarInterp) \n      { \n        vec4 result; \n        scalarInterp.x = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)).a; \n        scalarInterp.y = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)).a; \n        scalarInterp.z = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)).a; \n        result.x = scalarInterp.x - scalar; \n        result.y = scalarInterp.y - scalar; \n        result.z = scalarInterp.z - scalar;   \n        // divide by spacing\n        result.xyz /= vSpacing;\n        result.w = length(result.xyz); \n        // rotate to View Coords \n        rotateToViewCoord(result.xyz);      \n        if (length(result.xyz) > 0.0) {     \n          return vec4(normalize(result.xyz),result.w); \n        } else { \n          return vec4(0.0); \n        } \n      }           \n    #endif\n  #endif\n  // compute scalar density\n  vec4 computeNormal(vec3 pos, float scalar, vec3 tstep)  \n  {  \n    vec4 result;  \n    result.x = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)).a - scalar;  \n    result.y = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)).a - scalar;  \n    result.z = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)).a - scalar;  \n    // divide by spacing  \n    result.xyz /= vSpacing;  \n    result.w = length(result.xyz);  \n    // rotate to View Coords  \n    rotateToViewCoord(result.xyz);\n    return vec4(normalize(result.xyz),result.w);  \n  }  \n#endif\n\n#ifdef vtkImageLabelOutlineOn\nvec3 fragCoordToIndexSpace(vec4 fragCoord) {\n  vec4 pcPos = vec4(\n    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,\n    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,\n    (fragCoord.z - 0.5) * 2.0,\n    1.0);\n\n  vec4 worldCoord = PCWCMatrix * pcPos;\n  vec4 vertex = (worldCoord/worldCoord.w);\n\n  vec3 index = (vWCtoIDX * vertex).xyz;\n\n  // half voxel fix for labelmapOutline \n  return (index + vec3(0.5)) / vec3(volumeDimensions);\n}\n#endif\n\n//=======================================================================\n// compute the normals and gradient magnitudes for a position\n// for independent components\nmat4 computeMat4Normal(vec3 pos, vec4 tValue, vec3 tstep)\n{\n  mat4 result;\n  vec4 distX = getTextureValue(pos + vec3(tstep.x, 0.0, 0.0)) - tValue;\n  vec4 distY = getTextureValue(pos + vec3(0.0, tstep.y, 0.0)) - tValue;\n  vec4 distZ = getTextureValue(pos + vec3(0.0, 0.0, tstep.z)) - tValue;\n\n  // divide by spacing\n  distX /= vSpacing.x;\n  distY /= vSpacing.y;\n  distZ /= vSpacing.z;\n\n  mat3 rot;\n  rot[0] = vPlaneNormal0;\n  rot[1] = vPlaneNormal2;\n  rot[2] = vPlaneNormal4;\n\n#if !defined(vtkComponent0Proportional)\n  result[0].xyz = vec3(distX.r, distY.r, distZ.r);\n  result[0].a = length(result[0].xyz);\n  result[0].xyz *= rot;\n  if (result[0].w > 0.0)\n  {\n    result[0].xyz /= result[0].w;\n  }\n#endif\n\n// optionally compute the 2nd component\n#if vtkNumComponents >= 2 && !defined(vtkComponent1Proportional)\n  result[1].xyz = vec3(distX.g, distY.g, distZ.g);\n  result[1].a = length(result[1].xyz);\n  result[1].xyz *= rot;\n  if (result[1].w > 0.0)\n  {\n    result[1].xyz /= result[1].w;\n  }\n#endif\n\n// optionally compute the 3rd component\n#if vtkNumComponents >= 3 && !defined(vtkComponent2Proportional)\n  result[2].xyz = vec3(distX.b, distY.b, distZ.b);\n  result[2].a = length(result[2].xyz);\n  result[2].xyz *= rot;\n  if (result[2].w > 0.0)\n  {\n    result[2].xyz /= result[2].w;\n  }\n#endif\n\n// optionally compute the 4th component\n#if vtkNumComponents >= 4 && !defined(vtkComponent3Proportional)\n  result[3].xyz = vec3(distX.a, distY.a, distZ.a);\n  result[3].a = length(result[3].xyz);\n  result[3].xyz *= rot;\n  if (result[3].w > 0.0)\n  {\n    result[3].xyz /= result[3].w;\n  }\n#endif\n\n  return result;\n}\n\n//=======================================================================\n// surface light contribution\n\n#if vtkLightComplexity == 3\n// convert vector position from idx to vc\nvec3 IStoVC(vec3 posIS){\n  vec3 posVC = posIS / vVCToIJK;\n  return posVC.x * vPlaneNormal0 + posVC.y * vPlaneNormal2 + posVC.z * vPlaneNormal4 + vOriginVC;\n}\n#endif\n\n#if vtkLightComplexity > 0\n  void applyLighting(inout vec3 tColor, vec4 normal)\n  {\n    vec3 diffuse = vec3(0.0, 0.0, 0.0);\n    vec3 specular = vec3(0.0, 0.0, 0.0);\n    float df, sf = 0.0;\n    for (int i = 0; i < lightNum; i++){\n        df = abs(dot(normal.rgb, -lightDirectionVC[i]));\n        diffuse += df * lightColor[i];\n        sf = pow( abs(dot(lightHalfAngleVC[i],normal.rgb)), vSpecularPower);\n        specular += sf * lightColor[i];\n    }\n    tColor.rgb = tColor.rgb*(diffuse*vDiffuse + vAmbient) + specular*vSpecular;\n  }\n  #if vtkLightComplexity < 3\n    void applyLightingDirectional(inout vec3 tColor, vec4 normal)\n    {\n      // everything in VC\n      vec3 diffuse = vec3(0.0);\n      vec3 specular = vec3(0.0);\n      vec3 vertLightDirection;\n      for (int i = 0; i < lightNum; i++){\n        float ndotL,vdotR;\n        vertLightDirection = lightDirectionVC[i];\n        ndotL = dot(normal.xyz, vertLightDirection);\n        if (ndotL < 0.0 && twoSidedLighting)\n        {\n          ndotL = -ndotL;\n        }\n        if (ndotL > 0.0)\n        {\n          diffuse += ndotL * lightColor[i];\n          //specular\n          vdotR = dot(-rayDirVC, normalize(2.0 * ndotL * -normal.xyz + vertLightDirection));\n          if (vdotR > 0.0)\n          {\n            specular += pow(vdotR, vSpecularPower) * lightColor[i];\n          }\n        }\n      }  \n      tColor.rgb = tColor.rgb*(diffuse*vDiffuse + vAmbient) + specular*vSpecular;    \n    }\n  #else\n    void applyLightingPositional(inout vec3 tColor, vec4 normal, vec3 posVC)\n    {\n      // everything in VC\n      vec3 diffuse = vec3(0.0);\n      vec3 specular = vec3(0.0);\n      vec3 vertLightDirection;\n      for (int i = 0; i < lightNum; i++){\n        float distance,attenuation,ndotL,vdotR;\n        vec3 lightDir;\n        if (lightPositional[i] == 1){\n          lightDir = lightDirectionVC[i];\n          vertLightDirection = posVC - lightPositionVC[i]; \n          distance = length(vertLightDirection);\n          vertLightDirection = normalize(vertLightDirection);\n          attenuation = 1.0 / (lightAttenuation[i].x\n                              + lightAttenuation[i].y * distance\n                              + lightAttenuation[i].z * distance * distance);\n          // per OpenGL standard cone angle is 90 or less for a spot light\n          if (lightConeAngle[i] <= 90.0){\n            float coneDot = dot(vertLightDirection, lightDir);\n            if (coneDot >= cos(radians(lightConeAngle[i]))){  // if inside cone\n              attenuation = attenuation * pow(coneDot, lightExponent[i]);\n            }\n            else {\n              attenuation = 0.0;\n            }\n          }\n          ndotL = dot(normal.xyz, vertLightDirection);\n          if (ndotL < 0.0 && twoSidedLighting)\n          {\n            ndotL = -ndotL;\n          }\n          if (ndotL > 0.0)\n          {\n            diffuse += ndotL * attenuation * lightColor[i];\n            //specular\n            vdotR = dot(-rayDirVC, normalize(2.0 * ndotL * -normal.xyz + vertLightDirection));\n            if (vdotR > 0.0)\n            {\n              specular += pow(vdotR, vSpecularPower) * attenuation * lightColor[i];\n            }\n          }\n        } else {\n          vertLightDirection = lightDirectionVC[i];\n          ndotL = dot(normal.xyz, vertLightDirection);\n          if (ndotL < 0.0 && twoSidedLighting)\n          {\n            ndotL = -ndotL;\n          }\n          if (ndotL > 0.0)\n          {\n            diffuse += ndotL * lightColor[i];\n            //specular\n            vdotR = dot(-rayDirVC, normalize(2.0 * ndotL * -normal.xyz + vertLightDirection));\n            if (vdotR > 0.0)\n            {\n              specular += pow(vdotR, vSpecularPower) * lightColor[i];\n            }\n          }\n        }\n      }\n      tColor.rgb = tColor.rgb * (diffuse * vDiffuse + vAmbient) + specular*vSpecular;\n    }\n  #endif \n#endif\n\n//=======================================================================\n// Given a texture value compute the color and opacity\n//\nvec4 getColorForValue(vec4 tValue, vec3 posIS, vec3 tstep)\n{\n#ifdef vtkImageLabelOutlineOn\n  vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord); // pos in texture space\n  vec4 centerValue = getTextureValue(centerPosIS);\n  bool pixelOnBorder = false;\n  vec4 tColor = texture2D(ctexture, vec2(centerValue.r * cscale0 + cshift0, 0.5));\n\n  // Get alpha of segment from opacity function.\n  tColor.a = texture2D(otexture, vec2(centerValue.r * oscale0 + oshift0, 0.5)).r;\n\n  // Only perform outline check on fragments rendering voxels that aren't invisible.\n  // Saves a bunch of needless checks on the background.\n  // TODO define epsilon when building shader?\n  if (float(tColor.a) > 0.01) {\n    for (int i = -outlineThickness; i <= outlineThickness; i++) {\n      for (int j = -outlineThickness; j <= outlineThickness; j++) {\n        if (i == 0 || j == 0) {\n          continue;\n        }\n\n        vec4 neighborPixelCoord = vec4(gl_FragCoord.x + float(i),\n          gl_FragCoord.y + float(j),\n          gl_FragCoord.z, gl_FragCoord.w);\n\n        vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);\n        vec4 value = getTextureValue(neighborPosIS);\n\n        // If any of my neighbours are not the same value as I\n        // am, this means I am on the border of the segment.\n        // We can break the loops\n        if (any(notEqual(value, centerValue))) {\n          pixelOnBorder = true;\n          break;\n        }\n      }\n\n      if (pixelOnBorder == true) {\n        break;\n      }\n    }\n\n    // If I am on the border, I am displayed at full opacity\n    if (pixelOnBorder == true) {\n      tColor.a = 1.0;\n    }\n  }\n\n#else\n  // compute the normal and gradient magnitude if needed\n  // We compute it as a vec4 if possible otherwise a mat4\n  //\n  vec4 goFactor = vec4(1.0,1.0,1.0,1.0);\n\n  // compute the normal vectors as needed\n  #if (vtkLightComplexity > 0) || defined(vtkGradientOpacityOn)\n    #if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\n      mat4 normalMat = computeMat4Normal(posIS, tValue, tstep);\n      #if !defined(vtkComponent0Proportional)\n        vec4 normal0 = normalMat[0];\n      #endif\n      #if !defined(vtkComponent1Proportional)\n        vec4 normal1 = normalMat[1];\n      #endif\n      #if vtkNumComponents > 2\n        #if !defined(vtkComponent2Proportional)\n          vec4 normal2 = normalMat[2];\n        #endif\n        #if vtkNumComponents > 3\n          #if !defined(vtkComponent3Proportional)\n            vec4 normal3 = normalMat[3];\n          #endif\n        #endif\n      #endif\n    #else\n      #ifdef vtkComputeNormalFromOpacity\n        #ifdef vtkGradientOpacityOn\n          mat3 scalarInterp;  \n          vec3 secondaryGradientMag;  \n          vec4 normalOpacity = vec4(0.0);  \n          vec4 normal0 = computeNormalForDensity(posIS, tValue.a, tstep, scalarInterp, secondaryGradientMag);  \n          normalOpacity = computeDensityNormal(tValue.a, normal0.w, scalarInterp,secondaryGradientMag);       \n          if (length(normalOpacity) == 0.0){  \n            normalOpacity = normal0;   \n          }                      \n        #else\n          vec3 scalarInterp;  \n          vec4 normal0 = computeNormalForDensity(posIS, tValue.a, tstep, scalarInterp);  \n          vec4 normalOpacity;          \n          if (length(normal0)>0.0){  \n            normalOpacity = computeDensityNormal(tValue.a,scalarInterp);  \n            if (length(normalOpacity)==0.0){  \n              normalOpacity = normal0;  \n            }  \n          }                \n        #endif\n      #else \n        vec4 normal0 = computeNormal(posIS, tValue.a, tstep);                \n      #endif\n    #endif\n  #endif\n\n  // compute gradient opacity factors as needed\n  #if defined(vtkGradientOpacityOn)\n    #if !defined(vtkComponent0Proportional)\n      goFactor.x =\n        computeGradientOpacityFactor(normal0.a, goscale0, goshift0, gomin0, gomax0);\n    #endif\n    #if defined(vtkIndependentComponentsOn) && (vtkNumComponents > 1)\n      #if !defined(vtkComponent1Proportional)\n        goFactor.y =\n          computeGradientOpacityFactor(normal1.a, goscale1, goshift1, gomin1, gomax1);\n      #endif\n      #if vtkNumComponents > 2\n        #if !defined(vtkComponent2Proportional)\n          goFactor.z =\n            computeGradientOpacityFactor(normal2.a, goscale2, goshift2, gomin2, gomax2);\n        #endif\n        #if vtkNumComponents > 3\n          #if !defined(vtkComponent3Proportional)\n            goFactor.w =\n              computeGradientOpacityFactor(normal3.a, goscale3, goshift3, gomin3, gomax3);\n          #endif\n        #endif\n      #endif\n    #endif\n  #endif\n\n  // single component is always independent\n  #if vtkNumComponents == 1\n    vec4 tColor = texture2D(ctexture, vec2(tValue.r * cscale0 + cshift0, 0.5));\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, 0.5)).r;\n  #endif\n\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n    vec4 tColor = mix0*texture2D(ctexture, vec2(tValue.r * cscale0 + cshift0, height0));\n    #if !defined(vtkComponent0Proportional)\n      tColor.a = goFactor.x*mix0*texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, height0)).r;\n    #else\n      float pwfValue = texture2D(otexture, vec2(tValue.r * oscale0 + oshift0, height0)).r;\n      tColor *= pwfValue;\n      tColor.a *= mix(pwfValue, 1.0, (1.0 - mix0));\n    #endif\n\n    vec3 tColor1 = mix1*texture2D(ctexture, vec2(tValue.g * cscale1 + cshift1, height1)).rgb;\n    #if !defined(vtkComponent1Proportional)\n      tColor.a += goFactor.y*mix1*texture2D(otexture, vec2(tValue.g * oscale1 + oshift1, height1)).r;\n    #else\n      float pwfValue = texture2D(otexture, vec2(tValue.g * oscale1 + oshift1, height1)).r;\n      tColor1 *= pwfValue;\n      tColor.a *= mix(pwfValue, 1.0, (1.0 - mix1));\n    #endif\n\n    #if vtkNumComponents >= 3\n      vec3 tColor2 = mix2*texture2D(ctexture, vec2(tValue.b * cscale2 + cshift2, height2)).rgb;\n      #if !defined(vtkComponent2Proportional)\n        tColor.a += goFactor.z*mix2*texture2D(otexture, vec2(tValue.b * oscale2 + oshift2, height2)).r;\n      #else\n        float pwfValue = texture2D(otexture, vec2(tValue.b * oscale2 + oshift2, height2)).r;\n        tColor2 *= pwfValue;\n        tColor.a *= mix(pwfValue, 1.0, (1.0 - mix2));\n      #endif\n\n      #if vtkNumComponents >= 4\n        vec3 tColor3 = mix3*texture2D(ctexture, vec2(tValue.a * cscale3 + cshift3, height3)).rgb;\n        #if !defined(vtkComponent3Proportional)\n          tColor.a += goFactor.w*mix3*texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, height3)).r;\n        #else\n          float pwfValue = texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, height3)).r;\n          tColor3 *= pwfValue;\n          tColor.a *= mix(pwfValue, 1.0, (1.0 - mix3));\n        #endif\n      #endif\n    #endif\n  #else // then not independent\n\n  #if vtkNumComponents == 2\n    float lum = tValue.r * cscale0 + cshift0;\n    float alpha = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale1 + oshift1, 0.5)).r;\n    vec4 tColor = vec4(lum, lum, lum, alpha);\n  #endif\n  #if vtkNumComponents == 3\n    vec4 tColor;\n    tColor.r = tValue.r * cscale0 + cshift0;\n    tColor.g = tValue.g * cscale1 + cshift1;\n    tColor.b = tValue.b * cscale2 + cshift2;\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale0 + oshift0, 0.5)).r;\n  #endif\n  #if vtkNumComponents == 4\n    vec4 tColor;\n    tColor.r = tValue.r * cscale0 + cshift0;\n    tColor.g = tValue.g * cscale1 + cshift1;\n    tColor.b = tValue.b * cscale2 + cshift2;\n    tColor.a = goFactor.x*texture2D(otexture, vec2(tValue.a * oscale3 + oshift3, 0.5)).r;\n  #endif\n  #endif // dependent\n\n  // apply lighting if requested as appropriate\n  #if vtkLightComplexity > 0\n    #if !defined(vtkComponent0Proportional)\n        #if vtkLightComplexity < 3\n          #ifdef vtkComputeNormalFromOpacity\n            applyLightingDirectional(tColor.rgb, normalOpacity);\n          #else\n            applyLightingDirectional(tColor.rgb, normal0);\n          #endif\n        #else\n          #ifdef vtkComputeNormalFromOpacity\n            applyLightingPositional(tColor.rgb, normalOpacity, IStoVC(posIS));        \n          #else\n            applyLightingPositional(tColor.rgb, normal0, IStoVC(posIS));        \n          #endif\n        #endif\n    #endif\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n    #if !defined(vtkComponent1Proportional)\n      applyLighting(tColor1, normal1);\n    #endif\n  #if vtkNumComponents >= 3\n    #if !defined(vtkComponent2Proportional)\n      applyLighting(tColor2, normal2);\n    #endif\n  #if vtkNumComponents >= 4\n    #if !defined(vtkComponent3Proportional)\n      applyLighting(tColor3, normal3);\n    #endif\n  #endif\n  #endif\n  #endif\n  #endif\n\n// perform final independent blend as needed\n#if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 2\n  tColor.rgb += tColor1;\n#if vtkNumComponents >= 3\n  tColor.rgb += tColor2;\n#if vtkNumComponents >= 4\n  tColor.rgb += tColor3;\n#endif\n#endif\n#endif\n\n#endif\n\n\n\n\n\n\n\nreturn tColor;\n}\n\nbool valueWithinScalarRange(vec4 val, vec4 min, vec4 max) {\n  bool withinRange = false;\n  #if vtkNumComponents == 1\n    if (val.r >= min.r && val.r <= max.r) {\n      withinRange = true;\n    }\n  #endif\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents == 2\n     if (val.r >= min.r && val.r <= max.r &&\n        val.g >= min.g && val.g <= max.g) {\n      withinRange = true;\n    }\n  #endif\n  #if defined(vtkIndependentComponentsOn) && vtkNumComponents >= 3\n    if (all(greaterThanEqual(val, ipScalarRangeMin)) &&\n        all(lessThanEqual(val, ipScalarRangeMax))) {\n      withinRange = true;\n    }\n  #endif\n  return withinRange;\n}\n\n//=======================================================================\n// Apply the specified blend mode operation along the ray's path.\n//\nvoid applyBlend(vec3 posIS, vec3 endIS, float sampleDistanceIS, vec3 tdims)\n{\n  vec3 tstep = 1.0/tdims;\n\n  // start slightly inside and apply some jitter\n  vec3 delta = endIS - posIS;\n  vec3 stepIS = normalize(delta)*sampleDistanceIS;\n  float raySteps = length(delta)/sampleDistanceIS;\n\n  // avoid 0.0 jitter\n  float jitter = 0.01 + 0.99*texture2D(jtexture, gl_FragCoord.xy/32.0).r;\n  float stepsTraveled = jitter;\n\n  // local vars for the loop\n  vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n  vec4 tValue;\n  vec4 tColor;\n\n  // if we have less than one step then pick the middle point\n  // as our value\n  // if (raySteps <= 1.0)\n  // {\n  //   posIS = (posIS + endIS)*0.5;\n  // }\n\n  // Perform initial step at the volume boundary\n  // compute the scalar\n  tValue = getTextureValue(posIS);\n\n  #if vtkBlendMode == 0 // COMPOSITE_BLEND\n    // now map through opacity and color\n    tColor = getColorForValue(tValue, posIS, tstep);\n\n    // handle very thin volumes\n    if (raySteps <= 1.0)\n    {\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps);\n      gl_FragData[0] = tColor;\n      return;\n    }\n\n    tColor.a = 1.0 - pow(1.0 - tColor.a, jitter);\n    color = vec4(tColor.rgb*tColor.a, tColor.a);\n    posIS += (jitter*stepIS);\n\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // now map through opacity and color\n      tColor = getColorForValue(tValue, posIS, tstep);\n\n      float mix = (1.0 - color.a);\n\n      // this line should not be needed but nvidia seems to not handle\n      // the break correctly on windows/chrome 58 angle\n      //mix = mix * sign(max(raySteps - stepsTraveled - 1.0, 0.0));\n\n      color = color + vec4(tColor.rgb*tColor.a, tColor.a)*mix;\n      stepsTraveled++;\n      posIS += stepIS;\n      if (color.a > 0.99) { color.a = 1.0; break; }\n    }\n\n    if (color.a < 0.99 && (raySteps - stepsTraveled) > 0.0)\n    {\n      posIS = endIS;\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // now map through opacity and color\n      tColor = getColorForValue(tValue, posIS, tstep);\n      tColor.a = 1.0 - pow(1.0 - tColor.a, raySteps - stepsTraveled);\n\n      float mix = (1.0 - color.a);\n      color = color + vec4(tColor.rgb*tColor.a, tColor.a)*mix;\n    }\n\n    gl_FragData[0] = vec4(color.rgb/color.a, color.a);\n  #endif\n  #if vtkBlendMode == 1 || vtkBlendMode == 2\n    // MAXIMUM_INTENSITY_BLEND || MINIMUM_INTENSITY_BLEND\n    // Find maximum/minimum intensity along the ray.\n\n    // Define the operation we will use (min or max)\n    #if vtkBlendMode == 1\n    #define OP max\n    #else\n    #define OP min\n    #endif\n\n    // If the clipping range is shorter than the sample distance\n    // we can skip the sampling loop along the ray.\n    if (raySteps <= 1.0)\n    {\n      gl_FragData[0] = getColorForValue(tValue, posIS, tstep);\n      return;\n    }\n\n    vec4 value = tValue;\n    posIS += (jitter*stepIS);\n\n    // Sample along the ray until MaximumSamplesValue,\n    // ending slightly inside the total distance\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      // If we have reached the last step, break\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // Update the maximum value if necessary\n      value = OP(tValue, value);\n\n      // Otherwise, continue along the ray\n      stepsTraveled++;\n      posIS += stepIS;\n    }\n\n    // Perform the last step along the ray using the\n    // residual distance\n    posIS = endIS;\n    tValue = getTextureValue(posIS);\n    value = OP(tValue, value);\n\n    // Now map through opacity and color\n    gl_FragData[0] = getColorForValue(value, posIS, tstep);\n  #endif\n  #if vtkBlendMode == 3 || vtkBlendMode == 4 //AVERAGE_INTENSITY_BLEND || ADDITIVE_BLEND\n    vec4 sum = vec4(0.);\n\n    if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n      sum += tValue;\n    }\n\n    if (raySteps <= 1.0) {\n      gl_FragData[0] = getColorForValue(sum, posIS, tstep);\n      return;\n    }\n\n    posIS += (jitter*stepIS);\n\n    // Sample along the ray until MaximumSamplesValue,\n    // ending slightly inside the total distance\n    for (int i = 0; i < //VTK::MaximumSamplesValue ; ++i)\n    {\n      // If we have reached the last step, break\n      if (stepsTraveled + 1.0 >= raySteps) { break; }\n\n      // compute the scalar\n      tValue = getTextureValue(posIS);\n\n      // One can control the scalar range by setting the AverageIPScalarRange to disregard scalar values, not in the range of interest, from the average computation.\n      // Notes:\n      // - We are comparing all values in the texture to see if any of them\n      //   are outside of the scalar range. In the future we might want to allow\n      //   scalar ranges for each component.\n      if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n        // Sum the values across each step in the path\n        sum += tValue;\n      }\n      stepsTraveled++;\n      posIS += stepIS;\n    }\n\n    // Perform the last step along the ray using the\n    // residual distance\n    posIS = endIS;\n\n    // compute the scalar\n    tValue = getTextureValue(posIS);\n\n    // One can control the scalar range by setting the IPScalarRange to disregard scalar values, not in the range of interest, from the average computation\n    if (valueWithinScalarRange(tValue, ipScalarRangeMin, ipScalarRangeMax)) {\n      sum += tValue;\n\n      stepsTraveled++;\n    }\n\n    #if vtkBlendMode == 3 // Average\n      sum /= vec4(stepsTraveled, stepsTraveled, stepsTraveled, 1.0);\n    #endif\n\n    gl_FragData[0] = getColorForValue(sum, posIS, tstep);\n  #endif\n}\n\n//=======================================================================\n// Compute a new start and end point for a given ray based\n// on the provided bounded clipping plane (aka a rectangle)\nvoid getRayPointIntersectionBounds(\n  vec3 rayPos, vec3 rayDir,\n  vec3 planeDir, float planeDist,\n  inout vec2 tbounds, vec3 vPlaneX, vec3 vPlaneY,\n  float vSize1, float vSize2)\n{\n  float result = dot(rayDir, planeDir);\n  if (abs(result) < 1e-6)\n  {\n    return;\n  }\n  result = -1.0 * (dot(rayPos, planeDir) + planeDist) / result;\n  vec3 xposVC = rayPos + rayDir*result;\n  vec3 vxpos = xposVC - vOriginVC;\n  vec2 vpos = vec2(\n    dot(vxpos, vPlaneX),\n    dot(vxpos, vPlaneY));\n\n  // on some apple nvidia systems this does not work\n  // if (vpos.x < 0.0 || vpos.x > vSize1 ||\n  //     vpos.y < 0.0 || vpos.y > vSize2)\n  // even just\n  // if (vpos.x < 0.0 || vpos.y < 0.0)\n  // fails\n  // so instead we compute a value that represents in and out\n  //and then compute the return using this value\n  float xcheck = max(0.0, vpos.x * (vpos.x - vSize1)); //  0 means in bounds\n  float check = sign(max(xcheck, vpos.y * (vpos.y - vSize2))); //  0 means in bounds, 1 = out\n\n  tbounds = mix(\n   vec2(min(tbounds.x, result), max(tbounds.y, result)), // in value\n   tbounds, // out value\n   check);  // 0 in 1 out\n}\n\n//=======================================================================\n// given a\n// - ray direction (rayDir)\n// - starting point (vertexVCVSOutput)\n// - bounding planes of the volume\n// - optionally depth buffer values\n// - far clipping plane\n// compute the start/end distances of the ray we need to cast\nvec2 computeRayDistances(vec3 rayDir, vec3 tdims)\n{\n  vec2 dists = vec2(100.0*camFar, -1.0);\n\n  vec3 vSize = vSpacing*tdims;\n\n  // all this is in View Coordinates\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal0, vPlaneDistance0, dists, vPlaneNormal2, vPlaneNormal4,\n    vSize.y, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal1, vPlaneDistance1, dists, vPlaneNormal2, vPlaneNormal4,\n    vSize.y, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal2, vPlaneDistance2, dists, vPlaneNormal0, vPlaneNormal4,\n    vSize.x, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal3, vPlaneDistance3, dists, vPlaneNormal0, vPlaneNormal4,\n    vSize.x, vSize.z);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal4, vPlaneDistance4, dists, vPlaneNormal0, vPlaneNormal2,\n    vSize.x, vSize.y);\n  getRayPointIntersectionBounds(vertexVCVSOutput, rayDir,\n    vPlaneNormal5, vPlaneDistance5, dists, vPlaneNormal0, vPlaneNormal2,\n    vSize.x, vSize.y);\n\n  //VTK::ClipPlane::Impl\n\n  // do not go behind front clipping plane\n  dists.x = max(0.0,dists.x);\n\n  // do not go PAST far clipping plane\n  float farDist = -camThick/rayDir.z;\n  dists.y = min(farDist,dists.y);\n\n  // Do not go past the zbuffer value if set\n  // This is used for intermixing opaque geometry\n  //VTK::ZBuffer::Impl\n\n  return dists;\n}\n\n//=======================================================================\n// Compute the index space starting position (pos) and end\n// position\n//\nvoid computeIndexSpaceValues(out vec3 pos, out vec3 endPos, out float sampleDistanceIS, vec3 rayDir, vec2 dists)\n{\n  // compute starting and ending values in volume space\n  pos = vertexVCVSOutput + dists.x*rayDir;\n  pos = pos - vOriginVC;\n  // convert to volume basis and origin\n  pos = vec3(\n    dot(pos, vPlaneNormal0),\n    dot(pos, vPlaneNormal2),\n    dot(pos, vPlaneNormal4));\n\n  endPos = vertexVCVSOutput + dists.y*rayDir;\n  endPos = endPos - vOriginVC;\n  endPos = vec3(\n    dot(endPos, vPlaneNormal0),\n    dot(endPos, vPlaneNormal2),\n    dot(endPos, vPlaneNormal4));\n\n  float delta = length(endPos - pos);\n\n  pos *= vVCToIJK;\n  endPos *= vVCToIJK;\n\n  float delta2 = length(endPos - pos);\n  sampleDistanceIS = sampleDistance*delta2/delta;\n}\n\nvoid main()\n{\n\n  if (cameraParallel == 1)\n  {\n    // Camera is parallel, so the rayDir is just the direction of the camera.\n    rayDirVC = vec3(0.0, 0.0, -1.0);\n  } else {\n    // camera is at 0,0,0 so rayDir for perspective is just the vc coord\n    rayDirVC = normalize(vertexVCVSOutput);\n  }\n\n  vec3 tdims = vec3(volumeDimensions);\n\n  // compute the start and end points for the ray\n  vec2 rayStartEndDistancesVC = computeRayDistances(rayDirVC, tdims);\n\n  // do we need to composite? aka does the ray have any length\n  // If not, bail out early\n  if (rayStartEndDistancesVC.y <= rayStartEndDistancesVC.x)\n  {\n    discard;\n  }\n\n  // IS = Index Space\n  vec3 posIS;\n  vec3 endIS;\n  float sampleDistanceIS;\n  computeIndexSpaceValues(posIS, endIS, sampleDistanceIS, rayDirVC, rayStartEndDistancesVC);\n\n  // Perform the blending operation along the ray\n  applyBlend(posIS, endIS, sampleDistanceIS, tdims);\n}\n";
 
 export { vtkVolumeFS as v };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "24.14.3",
+  "version": "24.16.1",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",