@kitware/vtk.js 33.0.0-beta.1 → 33.0.0-beta.3

package/IO/XML/XMLPolyDataWriter.js

@@ -36,6 +36,7 @@ function vtkXMLPolyDataWriter(publicAPI, model) {
     });
     publicAPI.processDataSetAttributes(piece, 'PointData', dataObject.getPointData());
     publicAPI.processDataSetAttributes(piece, 'CellData', dataObject.getCellData());
+    publicAPI.processDataSetAttributes(piece, 'FieldData', dataObject.getFieldData());
     publicAPI.processDataArray(piece.ele('Points'), dataObject.getPoints());
     POLYDATA_FIELDS.forEach(cellType => {
       const cellTypeName = camelize(cellType);

package/Interaction/Manipulators/KeyboardCameraManipulator.d.ts

@@ -0,0 +1,113 @@
+import { Vector3 } from './../../types';
+import { vtkObject } from './../../interfaces';
+import vtkCompositeKeyboardManipulator from './CompositeKeyboardManipulator';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+import vtkCamera from './../../Rendering/Core/Camera';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+
+export interface vtkKeyboardCameraManipulator
+  extends vtkObject,
+    vtkCompositeKeyboardManipulator {
+  /**
+   * Returns whether a movement is ongoing.
+   */
+  inMotion(): boolean;
+
+  /**
+   * Reset the movement speed to be proportional to the longest length of the renderer's bounds.
+   */
+  resetMovementSpeed(): void;
+
+  /**
+   * Initialize a movement of the current camera.
+   */
+  startMovement(): void;
+
+  /**
+   * Cancel any ongoing camera movement.
+   */
+  endMovement(): void;
+
+  /**
+   * Update active camera direction, depending on currently pressed keys.
+   */
+  calculateCurrentDirection(): void;
+
+  /**
+   * Returns the direction vector of the given camera for the given key.
+   * @param key the movedkey
+   * @param camera the camera
+   */
+  getDirectionFromKey(key: KeyboardEvent['key'], camera: vtkCamera): Vector3;
+
+  /**
+   * Moves the given camera, in the given direction, at the given speed.
+   * @param camera the moved camera
+   * @param direction the direction of the movemnt
+   * @param speed the speed
+   */
+  moveCamera(camera: vtkCamera, direction: Vector3, speed: number): void;
+
+  /**
+   * Handles a keypress event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyPress(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+
+  /**
+   * Handles a keydown event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyDown(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+
+  /**
+   * Handles a keyup event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyUp(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+}
+
+export interface IKeyboardCameraManipulatorInitialValues {
+  movementSpeed?: number;
+  moveForwardKeys?: KeyboardEvent['key'][];
+  moveLeftKeys?: KeyboardEvent['key'][];
+  moveBackwardKeys?: KeyboardEvent['key'][];
+  moveRightKeys?: KeyboardEvent['key'][];
+  moveUpKeys?: KeyboardEvent['key'][];
+  moveDownKeys?: KeyboardEvent['key'][];
+}
+
+export function newInstance(
+  initialValues?: IKeyboardCameraManipulatorInitialValues
+): vtkKeyboardCameraManipulator;
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IKeyboardCameraManipulatorInitialValues
+): void;
+
+export const vtkKeyboardCameraManipulator: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkKeyboardCameraManipulator;

package/Interaction/Manipulators/MouseCameraTrackballRollManipulator.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
-import { r as radiansFromDegrees, C as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { r as radiansFromDegrees, A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 
 // ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballRollManipulator methods

package/Interaction/Style/InteractorStyleTrackballCamera.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkInteractorStyle from '../../Rendering/Core/InteractorStyle.js';
 import vtkInteractorStyleConstants from '../../Rendering/Core/InteractorStyle/Constants.js';
-import { C as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 import { Device, Input } from '../../Rendering/Core/RenderWindowInteractor/Constants.js';
 
 const {

package/Rendering/Core/Glyph3DMapper.d.ts

@@ -12,11 +12,11 @@ interface IPrimitiveCount {
 export interface IGlyph3DMapperInitialValues extends IMapperInitialValues {
   orient?: boolean;
   orientationMode?: OrientationModes;
-  orientationArray?: number[];
+  orientationArray?: string;
   scaling?: boolean;
   scaleFactor?: number;
   scaleMode?: ScaleModes;
-  scaleArray?: number[];
+  scaleArray?: string;
   matrixArray?: number[];
   normalArray?: number[];
   colorArray?: number[];
@@ -24,29 +24,26 @@ export interface IGlyph3DMapperInitialValues extends IMapperInitialValues {
 
 export interface vtkGlyph3DMapper extends vtkMapper {
   /**
-   * An orientation array is a vtkDataArray with 3 components. The first
-   * component is the angle of rotation along the X axis. The second component
-   * is the angle of rotation along the Y axis. The third component is the
-   * angle of rotation along the Z axis. Orientation is specified in X,Y,Z
-   * order but the rotations are performed in Z,X an Y.
-   *
-   * This definition is compliant with SetOrientation method on vtkProp3D.
+   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+   * @return {Bounds} The bounds for the mapper.
+   */
+  getBounds(): Bounds;
+
+  /**
    *
-   * By using vector or normal there is a degree of freedom or rotation left
-   * (underconstrained). With the orientation array, there is no degree of
-   * freedom left.
    */
-  getOrientationMode(): OrientationModes;
+  buildArrays(): void;
 
   /**
-   * Get orientation as string
+   *
    */
-  getOrientationModeAsString(): string;
+  getPrimitiveCount(): IPrimitiveCount;
 
   /**
-   * Get orientation as array
+   * Get scale mode
+   * @default `SCALE_BY_MAGNITUDE`
    */
-  getOrientationArrayData(): number[];
+  getScaleMode(): ScaleModes;
 
   /**
    * Get scale factor to scale object by.
@@ -54,15 +51,20 @@ export interface vtkGlyph3DMapper extends vtkMapper {
   getScaleFactor(): number;
 
   /**
-   * Get scale mode
-   * @default `SCALE_BY_MAGNITUDE`
+   * Get scale mode as string
    */
-  getScaleMode(): ScaleModes;
+  getScaleModeAsString(): string;
 
   /**
-   * Get scale mode as string
+   * Sets the name of the array to use as scale values.
+   * @param {String} arrayName Name of the array
    */
-  getScaleModeAsString(): string;
+  setScaleArray(arrayName: Nullable<string>): boolean;
+
+  /**
+   * Gets the name of the array used as scale values.
+   */
+  getScaleArray(): string;
 
   /**
    * Get scale mode as array
@@ -70,20 +72,29 @@ export interface vtkGlyph3DMapper extends vtkMapper {
   getScaleArrayData(): number[];
 
   /**
-   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
-   * @return {Bounds} The bounds for the mapper.
+   * An orientation array is a vtkDataArray with 3 components. The first
+   * component is the angle of rotation along the X axis. The second component
+   * is the angle of rotation along the Y axis. The third component is the
+   * angle of rotation along the Z axis. Orientation is specified in X,Y,Z
+   * order but the rotations are performed in Z,X an Y.
+   *
+   * This definition is compliant with SetOrientation method on vtkProp3D.
+   *
+   * By using vector or normal there is a degree of freedom or rotation left
+   * (underconstrained). With the orientation array, there is no degree of
+   * freedom left.
    */
-  getBounds(): Bounds;
+  getOrientationMode(): OrientationModes;
 
   /**
-   *
+   * Get orientation as string
    */
-  buildArrays(): void;
+  getOrientationModeAsString(): string;
 
   /**
-   *
+   * Get orientation as array
    */
-  getPrimitiveCount(): IPrimitiveCount;
+  getOrientationArrayData(): number[];
 
   /**
    * Sets the name of the array to use as orientation.
@@ -91,6 +102,11 @@ export interface vtkGlyph3DMapper extends vtkMapper {
    */
   setOrientationArray(arrayName: Nullable<string>): boolean;
 
+  /**
+   * Gets the name of the array used as orientation values.
+   */
+  getOrientationArray(): string;
+
   /**
    * Orientation mode indicates if the OrientationArray provides the direction
    * vector for the orientation or the rotations around each axes.

package/Rendering/Core/ImageCPRMapper.js

@@ -1,4 +1,4 @@
-import { vec3, mat4, quat } from 'gl-matrix';
+import { quat, vec3, mat4 } from 'gl-matrix';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import { m as macro } from '../../macros2.js';

package/Rendering/Core/ImageProperty.d.ts

@@ -94,6 +94,28 @@ export interface vtkImageProperty extends vtkObject {
    */
   getScalarOpacity(idx?: number): vtkPiecewiseFunction;
 
+  /**
+   * Enable label outline rendering.
+   * @param {Boolean} useLabelOutline
+   */
+  setUseLabelOutline(useLabelOutline: boolean): boolean;
+
+  /**
+   * Check if label outline rendering.
+   */
+  getUseLabelOutline(): boolean;
+
+  /**
+   * Set the 0 to 1 opacity of the label outline.
+   * @param {Number} opacity
+   */
+  setLabelOutlineOpacity(opacity: number): boolean;
+
+  /**
+   * Get the 0 to 1 opacity of the label outline.
+   */
+  getLabelOutlineOpacity(): number;
+
   /**
    * gets the label outline thickness
    */

package/Rendering/Core/PointPicker.js

@@ -80,6 +80,9 @@ function vtkPointPicker(publicAPI, model) {
             if (maxDist <= tolerance && maxDist < minPtDist) {
               // within tolerance
               minPtId = ptId;
+              x[0];
+              x[1];
+              x[2];
               minPtDist = maxDist;
               tMin = t;
             }
@@ -108,13 +111,19 @@ function vtkPointPicker(publicAPI, model) {
           if (maxDist <= tolerance && maxDist < minPtDist) {
             // within tolerance
             minPtId = ptId;
+            x[0];
+            x[1];
+            x[2];
             minPtDist = maxDist;
             tMin = t;
           }
         }
       }
     }
-    model.pointId = minPtId;
+    if (minPtId > -1 && tMin < model.globalTMin) {
+      model.globalTMin = tMin;
+      model.pointId = minPtId;
+    }
     return tMin;
   };
 }

package/Rendering/Core/Prop3D.js

@@ -1,7 +1,7 @@
 import { mat4, quat } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { C as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
 import vtkProp from './Prop.js';
 
 const VTK_EPSILON = 1e-6;

package/Rendering/Core/RenderWindowInteractor.d.ts

@@ -63,7 +63,7 @@ export interface IRenderWindowInteractorInitialValues {
   mouseScrollDebounceByPass?: boolean;
 }
 
-interface IPosition {
+export interface IPosition {
   type: string;
 }
 

package/Rendering/Core/RenderWindowInteractor.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { C as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 import Constants from './RenderWindowInteractor/Constants.js';
 
 const {

package/Rendering/Misc/CanvasView.js

@@ -134,8 +134,10 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Create internal instances
-  model.canvas = document.createElement('canvas');
-  model.canvas.style.width = '100%';
+  if (!model.canvas) {
+    model.canvas = document.createElement('canvas');
+    model.canvas.style.width = '100%';
+  }
 
   // Create internal bgImage
   model.bgImage = new Image();

package/Rendering/Misc/RemoteView.d.ts

@@ -13,21 +13,27 @@ interface IRemoteViewInitialValues {
   rpcGestureEvent?: any;
   rpcWheelEvent?: any;
   viewStream?: vtkViewStream;
+  canvasElement?: HTMLCanvasElement;
 }
 
 export interface vtkRemoteView extends vtkObject {
   /**
-   * Get container element
+   * Get container HTML element
    */
   getContainer(): HTMLElement;
 
   /**
-   *
+   * Get vtkViewStream object
    */
   getViewStream(): vtkViewStream;
 
   /**
-   *
+   * Get the canvas HTML element
+   */
+  getCanvasElement(): HTMLCanvasElement;
+
+  /**
+   * Get the vtkCanvasView object
    */
   getCanvasView(): vtkCanvasView;
 

package/Rendering/Misc/RemoteView.js

@@ -17,7 +17,9 @@ function vtkRemoteView(publicAPI, model) {
   model.classHierarchy.push('vtkRemoteView');
 
   // Constructor
-  model.canvasView = vtkCanvasView.newInstance();
+  model.canvasView = vtkCanvasView.newInstance({
+    canvas: model.canvasElement
+  });
   model.interactorStyle = vtkInteractorStyleRemoteMouse.newInstance();
   model.interactor = vtkRenderWindowInteractor.newInstance();
   model.interactor.setView(model.canvasView);
@@ -60,6 +62,7 @@ function vtkRemoteView(publicAPI, model) {
       model.viewStream.delete();
     }
   }, publicAPI.delete);
+  publicAPI.getCanvasElement = () => model.canvasView.getCanvas();
 
   // --------------------------------------------------------------------------
   // remote handing
@@ -194,7 +197,8 @@ const DEFAULT_VALUES = {
   stillRatio: 1,
   rpcMouseEvent: 'viewport.mouse.interaction',
   rpcGestureEvent: null,
-  rpcWheelEvent: null
+  rpcWheelEvent: null,
+  canvasElement: null
 };
 
 // ----------------------------------------------------------------------------
@@ -203,7 +207,7 @@ function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['container', 'viewStream', 'canvasView', 'interactor', 'interactorStyle', 'interactiveQuality', 'interactiveRatio', 'stillQuality', 'stillRatio']);
+  macro.get(publicAPI, model, ['container', 'viewStream', 'canvasView', 'interactor', 'interactorStyle', 'interactiveQuality', 'interactiveRatio', 'stillQuality', 'stillRatio', 'canvasElement']);
   macro.setGet(publicAPI, model, ['session', 'rpcMouseEvent', 'rpcGestureEvent', 'rpcWheelEvent']);
 
   // Object methods

package/Rendering/Misc/SynchronizableRenderWindow/ObjectManager.d.ts

@@ -1,6 +1,6 @@
 import { vtkObject } from './../../../interfaces';
 import { Nullable } from './../../../types';
-import { ISynchronizerContext, IViewState } from '..';
+import { ISynchronizerContext, IViewState } from '../SynchronizableRenderWindow';
 
 export type BuilderFunction = <T extends vtkObject>(
   type: string,

package/Rendering/OpenGL/ImageMapper.js

@@ -167,9 +167,9 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // check for the outline thickness and opacity
     const vtkImageLabelOutline = actor.getProperty().getUseLabelOutline();
     if (vtkImageLabelOutline === true) {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutline::Dec', ['uniform int outlineThickness;', 'uniform float vpWidth;', 'uniform float vpHeight;', 'uniform float vpOffsetX;', 'uniform float vpOffsetY;', 'uniform mat4 PCWCMatrix;', 'uniform mat4 vWCtoIDX;', 'uniform ivec3 imageDimensions;']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutline::Dec', ['uniform int outlineThickness;', 'uniform float vpWidth;', 'uniform float vpHeight;', 'uniform float vpOffsetX;', 'uniform float vpOffsetY;', 'uniform mat4 PCWCMatrix;', 'uniform mat4 vWCtoIDX;', 'uniform ivec3 imageDimensions;', 'uniform int sliceAxis;']).result;
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ImageLabelOutlineOn', '#define vtkImageLabelOutlineOn').result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutlineHelperFunction', ['#ifdef vtkImageLabelOutlineOn', 'vec3 fragCoordToIndexSpace(vec4 fragCoord) {', '  vec4 pcPos = vec4(', '    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,', '    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,', '    (fragCoord.z - 0.5) * 2.0,', '    1.0);', '', '  vec4 worldCoord = PCWCMatrix * pcPos;', '  vec4 vertex = (worldCoord/worldCoord.w);', '', '  vec3 index = (vWCtoIDX * vertex).xyz;', '', '  // half voxel fix for labelmapOutline', '  return (index + vec3(0.5)) / vec3(imageDimensions);', '}', '#endif']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutlineHelperFunction', ['#ifdef vtkImageLabelOutlineOn', 'vec3 fragCoordToIndexSpace(vec4 fragCoord) {', '  vec4 pcPos = vec4(', '    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,', '    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,', '    (fragCoord.z - 0.5) * 2.0,', '    1.0);', '', '  vec4 worldCoord = PCWCMatrix * pcPos;', '  vec4 vertex = (worldCoord/worldCoord.w);', '', '  vec3 index = (vWCtoIDX * vertex).xyz;', '', '  // half voxel fix for labelmapOutline', '  return (index + vec3(0.5)) / vec3(imageDimensions);', '}', 'vec2 getSliceCoords(vec3 coord, int axis) {', '  if (axis == 0) return coord.yz;', '  if (axis == 1) return coord.xz;', '  if (axis == 2) return coord.xy;', '}', '#endif']).result;
     }
     if (iComps) {
       const rgba = ['r', 'g', 'b', 'a'];
@@ -201,7 +201,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', [...splitStringOnEnter(`
                 #ifdef vtkImageLabelOutlineOn
                   vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord);
-                  float centerValue = texture2D(texture1, centerPosIS.xy).r;
+                  float centerValue = texture2D(texture1, getSliceCoords(centerPosIS, sliceAxis)).r;
                   bool pixelOnBorder = false;
                   vec3 tColor = texture2D(colorTexture1, vec2(centerValue * cscale0 + cshift0, 0.5)).rgb;
                   float scalarOpacity = texture2D(pwfTexture1, vec2(centerValue * pwfscale0 + pwfshift0, 0.5)).r;
@@ -212,7 +212,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
                   int actualThickness = int(textureValue * 255.0);
 
                   if (segmentIndex == 0){
-                    gl_FragData[0] = vec4(0.0, 1.0, 1.0, 0.0);
+                    gl_FragData[0] = vec4(0.0, 0.0, 0.0, 0.0);
                     return;
                   }
 
@@ -225,7 +225,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
                         gl_FragCoord.y + float(j),
                         gl_FragCoord.z, gl_FragCoord.w);
                       vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);
-                      float value = texture2D(texture1, neighborPosIS.xy).r;
+                      float value = texture2D(texture1, getSliceCoords(neighborPosIS, sliceAxis)).r;
                       if (value != centerValue) {
                         pixelOnBorder = true;
                         break;
@@ -474,7 +474,14 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (vtkImageLabelOutline === true) {
       const worldToIndex = image.getWorldToIndex();
       const imageDimensions = image.getDimensions();
-      program.setUniform3i('imageDimensions', imageDimensions[0], imageDimensions[1], 1);
+      let sliceAxis = model.renderable.getClosestIJKAxis().ijkMode;
+
+      // SlicingMode.NONE equates to SlicingMode.K
+      if (sliceAxis === SlicingMode.NONE) {
+        sliceAxis = SlicingMode.K;
+      }
+      program.setUniform3i('imageDimensions', imageDimensions[0], imageDimensions[1], imageDimensions[2]);
+      program.setUniformi('sliceAxis', sliceAxis);
       program.setUniformMatrix('vWCtoIDX', worldToIndex);
       const labelOutlineKeyMats = model.openGLCamera.getKeyMatrices(ren);
 
@@ -896,7 +903,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
   };
   publicAPI.updatelabelOutlineThicknessTexture = image => {
-    const labelOutlineThicknessArray = image.getProperty().getLabelOutlineThickness();
+    const labelOutlineThicknessArray = image.getProperty().getLabelOutlineThicknessByReference();
     const lTex = model._openGLRenderWindow.getGraphicsResourceForObject(labelOutlineThicknessArray);
 
     // compute the join of the labelOutlineThicknessArray so that

package/Rendering/OpenGL/Texture/supportsNorm16Linear.js

@@ -0,0 +1,97 @@
+/**
+ * Even when the EXT_texture_norm16 extension is present, linear filtering
+ * might not be supported for normalized fixed point textures.
+ *
+ * This is a driver bug. See https://github.com/KhronosGroup/WebGL/issues/3706
+ * @return {boolean}
+ */
+function supportsNorm16Linear() {
+  try {
+    const canvasSize = 4;
+    const texWidth = 2;
+    const texHeight = 1;
+    const texData = new Int16Array([0, 2 ** 15 - 1]);
+    const pixelToCheck = [1, 1];
+    const canvas = document.createElement('canvas');
+    canvas.width = canvasSize;
+    canvas.height = canvasSize;
+    const gl = canvas.getContext('webgl2');
+    if (!gl) {
+      return false;
+    }
+    const ext = gl.getExtension('EXT_texture_norm16');
+    if (!ext) {
+      return false;
+    }
+    const vs = `#version 300 es
+    void main() {
+      gl_PointSize = ${canvasSize.toFixed(1)};
+      gl_Position = vec4(0, 0, 0, 1);
+    }
+  `;
+    const fs = `#version 300 es
+    precision highp float;
+    precision highp int;
+    precision highp sampler2D;
+
+    uniform sampler2D u_image;
+
+    out vec4 color;
+
+    void main() {
+        vec4 intColor = texture(u_image, gl_PointCoord.xy);
+        color = vec4(vec3(intColor.rrr), 1);
+    }
+    `;
+    const vertexShader = gl.createShader(gl.VERTEX_SHADER);
+    gl.shaderSource(vertexShader, vs);
+    gl.compileShader(vertexShader);
+    if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
+      return false;
+    }
+    const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(fragmentShader, fs);
+    gl.compileShader(fragmentShader);
+    if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
+      return false;
+    }
+    const program = gl.createProgram();
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.linkProgram(program);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+      return false;
+    }
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texImage2D(gl.TEXTURE_2D, 0, ext.R16_SNORM_EXT, texWidth, texHeight, 0, gl.RED, gl.SHORT, texData);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.useProgram(program);
+    gl.drawArrays(gl.POINTS, 0, 1);
+    const pixel = new Uint8Array(4);
+    gl.readPixels(pixelToCheck[0], pixelToCheck[1], 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);
+    const [r, g, b] = pixel;
+    const webglLoseContext = gl.getExtension('WEBGL_lose_context');
+    if (webglLoseContext) {
+      webglLoseContext.loseContext();
+    }
+    return r === g && g === b && r !== 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * @type {boolean | undefined}
+ */
+let supportsNorm16LinearCache;
+function supportsNorm16LinearCached() {
+  // Only create a canvas+texture+shaders the first time
+  if (supportsNorm16LinearCache === undefined) {
+    supportsNorm16LinearCache = supportsNorm16Linear();
+  }
+  return supportsNorm16LinearCache;
+}
+
+export { supportsNorm16LinearCached as default };