@kitware/vtk.js 25.2.4 → 25.5.0

package/Interaction/Style/InteractorStyleTrackballCamera.js

@@ -218,6 +218,10 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
 
   publicAPI.handleMouseRotate = function (renderer, position) {
+    if (!model.previousPosition) {
+      return;
+    }
+
     var rwi = model._interactor;
     var dx = position.x - model.previousPosition.x;
     var dy = position.y - model.previousPosition.y;
@@ -251,6 +255,10 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
 
   publicAPI.handleMouseSpin = function (renderer, position) {
+    if (!model.previousPosition) {
+      return;
+    }
+
     var rwi = model._interactor;
     var camera = renderer.getActiveCamera();
     var center = rwi.getView().getViewportCenter(renderer);
@@ -265,6 +273,10 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
 
   publicAPI.handleMousePan = function (renderer, position) {
+    if (!model.previousPosition) {
+      return;
+    }
+
     var camera = renderer.getActiveCamera(); // Calculate the focal depth since we'll be using it a lot
 
     var viewFocus = camera.getFocalPoint();
@@ -291,6 +303,10 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
 
   publicAPI.handleMouseDolly = function (renderer, position) {
+    if (!model.previousPosition) {
+      return;
+    }
+
     var dy = position.y - model.previousPosition.y;
     var rwi = model._interactor;
     var center = rwi.getView().getViewportCenter(renderer);

package/README.md

@@ -48,8 +48,8 @@ In general VTK tries to be as portable as possible; the specific configurations
 
 vtk.js supports the following development environments:
 
-- Node 12+
-- NPM 6+
+- Node 14+
+- NPM 7+
 
 and we use [@babel/preset-env](https://www.npmjs.com/package/@babel/preset-env) with the [defaults](https://github.com/Kitware/vtk-js/blob/master/.browserslistrc) set of [browsers target](https://browserl.ist/?q=defaults).
 But when built from source this could be adjusted to support any browser as long they provide WebGL.

package/Rendering/Core/Renderer.d.ts

@@ -35,6 +35,10 @@ export interface IRendererInitialValues extends IViewportInitialValues {
 	occlusionRatio?: number;
 	maximumNumberOfPeels?: number;
 	texturedBackground?: boolean;
+	environmentTexture?: vtkTexture;
+	environmentTextureDiffuseStrength?: number;
+	environmentTextureSpecularStrength?: number;
+	useEnvironmentTextureAsBackground?: boolean;
 	pass?: number;
 }
 
@@ -115,7 +119,25 @@ export interface vtkRenderer extends vtkViewport {
 	 * 
 	 * @default null
 	 */
-	getBackgroundTexture(): vtkTexture;
+	getEnvironmentTexture(): vtkTexture;
+
+	/**
+	 * Returns the diffuse strength of the set environment texture.
+	 * @default 1
+	 */
+	getEnvironmentTextureDiffuseStrength(): number;
+
+	/**
+	 * Returns the specular strength of the set environment texture.
+	 * @default 1
+	 */
+	getEnvironmentTextureSpecularStrength(): number;
+
+	/**
+	  * Gets whether or not the environment texture is being used as the background for the view.
+	  * @default false
+	  */
+	getUseEnvironmentTextureAsBackground(): boolean;
 
 	/**
 	 * 
@@ -347,9 +369,27 @@ export interface vtkRenderer extends vtkViewport {
 
 	/**
 	 * 
-	 * @param {vtkTexture} backgroundTexture 
+	 * @param {vtkTexture} environmentTexture 
+	 */
+	setEnvironmentTexture(environmentTexture: vtkTexture): boolean;
+
+	/**
+	 * Sets the diffuse strength of the set environment texture.
+	 * @param {number} diffuseStrength the new diffuse strength.
 	 */
-	setBackgroundTexture(backgroundTexture: vtkTexture): boolean;
+	setEnvironmentTextureDiffuseStrength(diffuseStrength: number): boolean;
+
+	 /**
+	  * Sets the specular strength of the set environment texture.
+	  * @param {number} specularStrength the new specular strength.
+	  */
+	setEnvironmentTextureSpecularStrength(specularStrength: number): boolean;
+
+	/**
+	  * Sets whether or not to use the environment texture as the background for the view.
+	  * @param {number} textureAsBackground
+	  */
+	setUseEnvironmentTextureAsBackground(textureAsBackground: boolean): boolean;
 
 	/**
 	 * 

package/Rendering/Core/Renderer.js

@@ -593,6 +593,10 @@ var DEFAULT_VALUES = {
   delegate: null,
   texturedBackground: false,
   backgroundTexture: null,
+  environmentTexture: null,
+  environmentTextureDiffuseStrength: 1,
+  environmentTextureSpecularStrength: 1,
+  useEnvironmentTextureAsBackground: false,
   pass: 0
 }; // ----------------------------------------------------------------------------
 
@@ -611,7 +615,7 @@ function extend(publicAPI, model) {
   if (model.background.length === 3) model.background.push(1); // Build VTK API
 
   get(publicAPI, model, ['_renderWindow', 'allocatedRenderTime', 'timeFactor', 'lastRenderTimeInSeconds', 'numberOfPropsRendered', 'lastRenderingUsedDepthPeeling', 'selector']);
-  setGet(publicAPI, model, ['twoSidedLighting', 'lightFollowCamera', 'automaticLightCreation', 'erase', 'draw', 'nearClippingPlaneTolerance', 'clippingRangeExpansion', 'backingStore', 'interactive', 'layer', 'preserveColorBuffer', 'preserveDepthBuffer', 'useDepthPeeling', 'occlusionRatio', 'maximumNumberOfPeels', 'delegate', 'backgroundTexture', 'texturedBackground', 'useShadows', 'pass']);
+  setGet(publicAPI, model, ['twoSidedLighting', 'lightFollowCamera', 'automaticLightCreation', 'erase', 'draw', 'nearClippingPlaneTolerance', 'clippingRangeExpansion', 'backingStore', 'interactive', 'layer', 'preserveColorBuffer', 'preserveDepthBuffer', 'useDepthPeeling', 'occlusionRatio', 'maximumNumberOfPeels', 'delegate', 'backgroundTexture', 'texturedBackground', 'environmentTexture', 'environmentTextureDiffuseStrength', 'environmentTextureSpecularStrength', 'useEnvironmentTextureAsBackground', 'useShadows', 'pass']);
   getArray(publicAPI, model, ['actors', 'volumes', 'lights']);
   setGetArray(publicAPI, model, ['background'], 4, 1.0);
   moveToProtected(publicAPI, model, ['renderWindow']); // Object methods

package/Rendering/Core/Texture.d.ts

@@ -5,6 +5,7 @@ export interface ITextureInitialValues {
 	interpolate?: boolean;
 	edgeClamp?: boolean;
 	imageLoaded?: boolean;
+	mipLevel?: number;
 }
 
 export interface vtkTexture extends vtkAlgorithm {
@@ -34,6 +35,11 @@ export interface vtkTexture extends vtkAlgorithm {
 	 */
 	getImageLoaded(): boolean;
 
+	/**
+	 * 
+	 */
+	getMipLevel(): number;
+
 	/**
 	 * 
 	 * @param repeat 
@@ -62,6 +68,11 @@ export interface vtkTexture extends vtkAlgorithm {
 	 * @default null
 	 */
 	setImage(image: any): void;
+
+	/**
+	 * @param level
+	 */
+	setMipLevel(level: number): boolean;
 }
 
 /**
@@ -79,6 +90,17 @@ export function extend(publicAPI: object, model: object, initialValues?: ITextur
  */
 export function newInstance(initialValues?: ITextureInitialValues): vtkTexture;
 
+/**
+ * Method used to create mipmaps from given texture data. Works best with textures that have a 
+ * width and a height that are powers of two.
+ * 
+ * @param nativeArray the array of data to create mipmaps from.
+ * @param width the width of the data
+ * @param height the height of the data
+ * @param level the level to which additional mipmaps are generated.
+ */
+export function generateMipmaps(nativeArray: any, width: number, height: number, level: number): Array<Uint8ClampedArray>;
+
 /** 
  * vtkTexture is an image algorithm that handles loading and binding of texture maps.
  * It obtains its data from an input image data dataset type. 

package/Rendering/Core/Texture.js

@@ -1,5 +1,10 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 // vtkTexture methods
 // ----------------------------------------------------------------------------
 
@@ -103,19 +108,160 @@ function vtkTexture(publicAPI, model) {
     var dimensionality = (width > 1) + (height > 1) + (depth > 1);
     return dimensionality;
   };
-} // ----------------------------------------------------------------------------
+
+  publicAPI.getInputAsJsImageData = function () {
+    if (!model.imageLoaded || publicAPI.getInputData()) return null;
+
+    if (model.jsImageData) {
+      return model.jsImageData();
+    }
+
+    if (model.canvas) {
+      var context = model.canvas.getContext('2d');
+      var imageData = context.getImageData(0, 0, model.canvas.width, model.canvas.height);
+      return imageData;
+    }
+
+    if (model.image) {
+      var canvas = document.createElement('canvas');
+      canvas.width = model.image.width;
+      canvas.height = model.image.height;
+
+      var _context = canvas.getContext('2d');
+
+      _context.translate(0, canvas.height);
+
+      _context.scale(1, -1);
+
+      _context.drawImage(model.image, 0, 0, model.image.width, model.image.height);
+
+      var _imageData = _context.getImageData(0, 0, canvas.width, canvas.height);
+
+      return _imageData;
+    }
+
+    return null;
+  };
+} // Use nativeArray instead of self
+
+
+var generateMipmaps = function generateMipmaps(nativeArray, width, height, level) {
+  // TODO: FIX UNEVEN TEXTURE MIP GENERATION:
+  // When textures don't have standard ratios, higher mip levels
+  // result in their color chanels getting messed up and shifting
+  // 3x3 gaussian kernel
+  var g3m = [1, 2, 1]; // eslint-disable-line
+
+  var g3w = 4; // eslint-disable-line
+
+  var kernel = g3m;
+  var kernelWeight = g3w;
+  var hs = nativeArray.length / (width * height); // TODO: support for textures with depth more than 1
+
+  var currentWidth = width;
+  var currentHeight = height;
+  var imageData = nativeArray;
+  var maps = [imageData];
+
+  for (var i = 0; i < level; i++) {
+    var oldData = _toConsumableArray(imageData);
+
+    currentWidth /= 2;
+    currentHeight /= 2;
+    imageData = new Uint8ClampedArray(currentWidth * currentHeight * hs);
+    var vs = hs * currentWidth; // Scale down
+
+    var shift = 0;
+
+    for (var p = 0; p < imageData.length; p += hs) {
+      if (p % vs === 0) {
+        shift += 2 * hs * currentWidth;
+      }
+
+      for (var c = 0; c < hs; c++) {
+        var sample = oldData[shift + c];
+        sample += oldData[shift + hs + c];
+        sample += oldData[shift - 2 * vs + c];
+        sample += oldData[shift - 2 * vs + hs + c];
+        sample /= 4;
+        imageData[p + c] = sample;
+      }
+
+      shift += 2 * hs;
+    } // Horizontal Pass
+
+
+    var dataCopy = _toConsumableArray(imageData);
+
+    for (var _p = 0; _p < imageData.length; _p += hs) {
+      for (var _c = 0; _c < hs; _c++) {
+        var x = -(kernel.length - 1) / 2;
+        var kw = kernelWeight;
+        var value = 0.0;
+
+        for (var k = 0; k < kernel.length; k++) {
+          var index = _p + _c + x * hs;
+          var lineShift = index % vs - (_p + _c) % vs;
+          if (lineShift > hs) index += vs;
+          if (lineShift < -hs) index -= vs;
+
+          if (dataCopy[index]) {
+            value += dataCopy[index] * kernel[k];
+          } else {
+            kw -= kernel[k];
+          }
+
+          x += 1;
+        }
+
+        imageData[_p + _c] = value / kw;
+      }
+    } // Vertical Pass
+
+
+    dataCopy = _toConsumableArray(imageData);
+
+    for (var _p2 = 0; _p2 < imageData.length; _p2 += hs) {
+      for (var _c2 = 0; _c2 < hs; _c2++) {
+        var _x = -(kernel.length - 1) / 2;
+
+        var _kw = kernelWeight;
+        var _value = 0.0;
+
+        for (var _k = 0; _k < kernel.length; _k++) {
+          var _index = _p2 + _c2 + _x * vs;
+
+          if (dataCopy[_index]) {
+            _value += dataCopy[_index] * kernel[_k];
+          } else {
+            _kw -= kernel[_k];
+          }
+
+          _x += 1;
+        }
+
+        imageData[_p2 + _c2] = _value / _kw;
+      }
+    }
+
+    maps.push(imageData);
+  }
+
+  return maps;
+}; // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
 
 var DEFAULT_VALUES = {
-  repeat: false,
-  interpolate: false,
-  edgeClamp: false,
   image: null,
   canvas: null,
+  jsImageData: null,
   imageLoaded: false,
-  jsImageData: null
+  repeat: false,
+  interpolate: false,
+  edgeClamp: false,
+  mipLevel: 0
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -125,15 +271,18 @@ function extend(publicAPI, model) {
   macro.obj(publicAPI, model);
   macro.algo(publicAPI, model, 6, 0);
   macro.get(publicAPI, model, ['canvas', 'image', 'jsImageData', 'imageLoaded']);
-  macro.setGet(publicAPI, model, ['repeat', 'edgeClamp', 'interpolate']);
+  macro.setGet(publicAPI, model, ['repeat', 'edgeClamp', 'interpolate', 'mipLevel']);
   vtkTexture(publicAPI, model);
 } // ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkTexture'); // ----------------------------------------------------------------------------
+var newInstance = macro.newInstance(extend, 'vtkTexture');
+var STATIC = {
+  generateMipmaps: generateMipmaps
+}; // ----------------------------------------------------------------------------
 
-var vtkTexture$1 = {
+var vtkTexture$1 = _objectSpread({
   newInstance: newInstance,
   extend: extend
-};
+}, STATIC);
 
-export { vtkTexture$1 as default, extend, newInstance };
+export { STATIC, vtkTexture$1 as default, extend, newInstance };

package/Rendering/Core/VolumeMapper.d.ts

@@ -94,6 +94,24 @@ export interface vtkVolumeMapper extends vtkAbstractMapper {
 	 */
 	getAnisotropy(): number;
 
+	/**
+	 * Get local ambient occlusion flag
+	 * @default false
+	 */
+	getLocalAmbientOcclusion(): boolean;
+
+	/**
+	 * Get kernel size for local ambient occlusion
+	 * @default 15
+	 */
+	getLAOKernelSize(): number;
+
+	/**
+	 * Get kernel radius for local ambient occlusion
+	 * @default 7
+	 */
+	getLAOKernelRadius(): number;
+
 	/**
 	 * 
 	 * @param x 
@@ -186,7 +204,28 @@ export interface vtkVolumeMapper extends vtkAbstractMapper {
 	 * Value of -1.0 means light scatters backward, value of 1.0 means light scatters forward.
 	 * @param anisotropy
 	 */
-	setAnisotropy(anisotropy: number): number;
+	setAnisotropy(anisotropy: number): void;
+
+	/**
+	 * Set whether to turn on local ambient occlusion (LAO). LAO is only effective if shading is on and volumeScatterBlendCoef is set to 0.
+	 * LAO effect is added to ambient lighting, so the ambient component of the actor needs to be great than 0.
+	 * @param localAmbientOcclusion
+	 */
+	setLocalAmbientOcclusion(localAmbientOcclusion: boolean): void;
+
+	/**
+	 * Set kernel size for local ambient occlusion. It specifies the number of rays that are randomly sampled in the hemisphere.
+	 * Value is clipped between 1 and 32.
+	 * @param LAOKernelSize
+	 */
+	setLAOKernelSize(LAOKernelSize: number): void;
+
+	/**
+	 * Set kernel radius for local ambient occlusion. It specifies the number of samples that are considered on each random ray.
+	 * Value must be greater than or equal to 1.
+	 * @param LAOKernelRadius
+	 */
+	setLAOKernelRadius(LAOKernelRadius: number): void;
 
 	/**
 	 * 

package/Rendering/Core/VolumeMapper.js

@@ -1,8 +1,12 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { O as createUninitializedBounds, D as clampValue } from '../../Common/Core/Math/index.js';
+import { O as createUninitializedBounds, D as clampValue, K as floor } from '../../Common/Core/Math/index.js';
 import Constants from './VolumeMapper/Constants.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 var BlendMode = Constants.BlendMode,
     FilterMode = Constants.FilterMode; // ----------------------------------------------------------------------------
 // vtkVolumeMapper methods
@@ -12,6 +16,8 @@ function vtkVolumeMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkVolumeMapper');
 
+  var superClass = _objectSpread({}, publicAPI);
+
   publicAPI.getBounds = function () {
     var input = publicAPI.getInputData();
 
@@ -78,23 +84,27 @@ function vtkVolumeMapper(publicAPI, model) {
   };
 
   publicAPI.setGlobalIlluminationReach = function (gl) {
-    model.globalIlluminationReach = clampValue(gl, 0.0, 1.0);
-    publicAPI.modified();
+    return superClass.setGlobalIlluminationReach(clampValue(gl, 0.0, 1.0));
   };
 
   publicAPI.setVolumetricScatteringBlending = function (vsb) {
-    model.volumetricScatteringBlending = clampValue(vsb, 0.0, 1.0);
-    publicAPI.modified();
+    return superClass.setVolumetricScatteringBlending(clampValue(vsb, 0.0, 1.0));
   };
 
   publicAPI.setVolumeShadowSamplingDistFactor = function (vsdf) {
-    model.volumeShadowSamplingDistFactor = vsdf >= 1.0 ? vsdf : 1.0;
-    publicAPI.modified();
+    return superClass.setVolumeShadowSamplingDistFactor(vsdf >= 1.0 ? vsdf : 1.0);
   };
 
   publicAPI.setAnisotropy = function (at) {
-    model.anisotropy = clampValue(at, -0.99, 0.99);
-    publicAPI.modified();
+    return superClass.setAnisotropy(clampValue(at, -0.99, 0.99));
+  };
+
+  publicAPI.setLAOKernelSize = function (ks) {
+    return superClass.setLAOKernelSize(floor(clampValue(ks, 1, 32)));
+  };
+
+  publicAPI.setLAOKernelRadius = function (kr) {
+    return superClass.setLAOKernelRadius(kr >= 1 ? kr : 1);
   };
 } // ----------------------------------------------------------------------------
 // Object factory
@@ -119,14 +129,18 @@ var DEFAULT_VALUES = {
   volumetricScatteringBlending: 0.0,
   globalIlluminationReach: 0.0,
   volumeShadowSamplingDistFactor: 5.0,
-  anisotropy: 0.0
+  anisotropy: 0.0,
+  // local ambient occlusion
+  localAmbientOcclusion: false,
+  LAOKernelSize: 15,
+  LAOKernelRadius: 7
 }; // ----------------------------------------------------------------------------
 
 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', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'volumeShadowSamplingDistFactor', 'anisotropy']);
+  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'blendMode', 'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'volumeShadowSamplingDistFactor', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius']);
   macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);
   macro.event(publicAPI, model, 'lightingActivated'); // Object methods
 

package/Rendering/OpenGL/RenderWindow/ContextProxy.js

@@ -0,0 +1,65 @@
+function createContextProxyHandler() {
+  var cache = new Map();
+  var getParameterHandler = {
+    apply: function apply(target, gl, args) {
+      if (cache.has(args[0])) {
+        return cache.get(args[0]);
+      }
+
+      return target.apply(gl, args);
+    }
+  }; // only supports single-value setters
+
+  function cachedSetterHandler(key) {
+    return {
+      apply: function apply(target, gl, args) {
+        cache.set(key, args[0]);
+        return target.apply(gl, args);
+      }
+    };
+  } // When a property is accessed on the webgl context proxy,
+  // it's accessed is intercepted. If the property name matches
+  // any of the keys of `propHandlers`, then that handler is called
+  // with the following arguments: (gl, prop, receiver, propValue)
+  // - gl (WebGL2RenderingContext): the underlying webgl context
+  // - propName (string): the property name
+  // - receiver (Proxy): the webgl context proxy
+  // - propValue (unknown): the value of `gl[propName]`
+
+
+  var propHandlers = Object.create(null); // Sets getParameter(property) as a cached getter proxy.
+  // propValue.bind(gl) is to avoid Illegal Invocation errors.
+
+  propHandlers.getParameter = function (gl, prop, receiver, propValue) {
+    return new Proxy(propValue.bind(gl), getParameterHandler);
+  }; // Sets depthMask(flag) as a cached setter proxy.
+
+
+  propHandlers.depthMask = function (gl, prop, receiver, propValue) {
+    return new Proxy(propValue.bind(gl), cachedSetterHandler(gl.DEPTH_WRITEMASK));
+  };
+
+  return {
+    get: function get(gl, prop, receiver) {
+      var value = Reflect.get(gl, prop, receiver);
+
+      if (value instanceof Function) {
+        // prevents Illegal Invocation errors
+        value = value.bind(gl);
+      }
+
+      var propHandler = propHandlers[prop];
+
+      if (propHandler) {
+        return propHandler(gl, prop, receiver, value);
+      }
+
+      return value;
+    }
+  };
+}
+var ContextProxy = {
+  createContextProxyHandler: createContextProxyHandler
+};
+
+export { createContextProxyHandler, ContextProxy as default };

package/Rendering/OpenGL/RenderWindow.js

@@ -12,6 +12,7 @@ import vtkTextureUnitManager from './TextureUnitManager.js';
 import vtkViewNodeFactory from './ViewNodeFactory.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkRenderWindowViewNode from '../SceneGraph/RenderWindowViewNode.js';
+import { createContextProxyHandler } from './RenderWindow/ContextProxy.js';
 
 var vtkDebugMacro = macro.vtkDebugMacro,
     vtkErrorMacro = macro.vtkErrorMacro;
@@ -84,6 +85,7 @@ function popMonitorGLContextCount(cb) {
 function vtkOpenGLRenderWindow(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLRenderWindow');
+  var cachingContextHandler = createContextProxyHandler();
 
   publicAPI.getViewNodeFactory = function () {
     return model.myFactory;
@@ -256,7 +258,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
       result = model.canvas.getContext('webgl', options) || model.canvas.getContext('experimental-webgl', options);
     }
 
-    return result;
+    return new Proxy(result, cachingContextHandler);
   }; // Request an XR session on the user device with WebXR,
   // typically in response to a user request such as a button press