@luma.gl/webgl 9.0.0-beta.3 → 9.0.0-beta.5

package/src/context/parameters/webgl-parameter-tables.ts

@@ -3,7 +3,6 @@
 
 // Tables describing WebGL parameters
 import {GL, GLParameters} from '@luma.gl/constants';
-import {isWebGL2} from '../context/webgl-checks';
 
 // DEFAULT SETTINGS - FOR FAST CACHE INITIALIZATION AND CONTEXT RESETS
 
@@ -94,24 +93,18 @@ export const GL_PARAMETER_DEFAULTS: GLParameters = {
 
 // SETTER TABLES - ENABLES SETTING ANY PARAMETER WITH A COMMON API
 
-const enable = (gl: WebGLRenderingContext, value: unknown, key: GL) =>
+const enable = (gl: WebGL2RenderingContext, value: unknown, key: GL) =>
   value ? gl.enable(key) : gl.disable(key);
-const hint = (gl: WebGLRenderingContext, value: GL, key: GL) => gl.hint(key, value);
-const pixelStorei = (gl: WebGLRenderingContext, value: number | boolean, key: GL) =>
+const hint = (gl: WebGL2RenderingContext, value: GL, key: GL) => gl.hint(key, value);
+const pixelStorei = (gl: WebGL2RenderingContext, value: number | boolean, key: GL) =>
   gl.pixelStorei(key, value);
 
-const bindFramebuffer = (gl: WebGLRenderingContext, value: unknown, key: GL) => {
-  let target;
-  if (key === GL.FRAMEBUFFER_BINDING) {
-    target = isWebGL2(gl) ? GL.DRAW_FRAMEBUFFER : GL.FRAMEBUFFER;
-  } else {
-    // GL.READ_FRAMEBUFFER_BINDING
-    target = GL.READ_FRAMEBUFFER;
-  }
+const bindFramebuffer = (gl: WebGL2RenderingContext, value: unknown, key: GL) => {
+  const target = (key === GL.FRAMEBUFFER_BINDING) ? GL.DRAW_FRAMEBUFFER : GL.READ_FRAMEBUFFER;
   return gl.bindFramebuffer(target, value);
 };
 
-const bindBuffer = (gl: WebGLRenderingContext, value: unknown, key: GL) => {
+const bindBuffer = (gl: WebGL2RenderingContext, value: unknown, key: GL) => {
   const bindingMap: Partial<Record<GL, GL>> = {
     [GL.ARRAY_BUFFER_BINDING]: GL.ARRAY_BUFFER,
     [GL.COPY_READ_BUFFER_BINDING]: GL.COPY_READ_BUFFER,
@@ -134,7 +127,7 @@ function isArray(array: unknown): boolean {
 // NOTE: When value type is a string, it will be handled by 'GL_COMPOSITE_PARAMETER_SETTERS'
 export const GL_PARAMETER_SETTERS = {
   [GL.BLEND]: enable,
-  [GL.BLEND_COLOR]: (gl: WebGLRenderingContext, value: [number, number, number, number]) =>
+  [GL.BLEND_COLOR]: (gl: WebGL2RenderingContext, value: [number, number, number, number]) =>
     gl.blendColor(...value),
   [GL.BLEND_EQUATION_RGB]: 'blendEquation',
   [GL.BLEND_EQUATION_ALPHA]: 'blendEquation',
@@ -142,26 +135,26 @@ export const GL_PARAMETER_SETTERS = {
   [GL.BLEND_DST_RGB]: 'blendFunc',
   [GL.BLEND_SRC_ALPHA]: 'blendFunc',
   [GL.BLEND_DST_ALPHA]: 'blendFunc',
-  [GL.COLOR_CLEAR_VALUE]: (gl: WebGLRenderingContext, value: [number, number, number, number]) =>
+  [GL.COLOR_CLEAR_VALUE]: (gl: WebGL2RenderingContext, value: [number, number, number, number]) =>
     gl.clearColor(...value),
-  [GL.COLOR_WRITEMASK]: (gl: WebGLRenderingContext, value: [boolean, boolean, boolean, boolean]) => gl.colorMask(...value),
+  [GL.COLOR_WRITEMASK]: (gl: WebGL2RenderingContext, value: [boolean, boolean, boolean, boolean]) => gl.colorMask(...value),
   [GL.CULL_FACE]: enable,
-  [GL.CULL_FACE_MODE]: (gl: WebGLRenderingContext, value) => gl.cullFace(value),
+  [GL.CULL_FACE_MODE]: (gl: WebGL2RenderingContext, value) => gl.cullFace(value),
   [GL.DEPTH_TEST]: enable,
-  [GL.DEPTH_CLEAR_VALUE]: (gl: WebGLRenderingContext, value) => gl.clearDepth(value),
-  [GL.DEPTH_FUNC]: (gl: WebGLRenderingContext, value) => gl.depthFunc(value),
-  [GL.DEPTH_RANGE]: (gl: WebGLRenderingContext, value: [number, number]) => gl.depthRange(...value),
-  [GL.DEPTH_WRITEMASK]: (gl: WebGLRenderingContext, value) => gl.depthMask(value),
+  [GL.DEPTH_CLEAR_VALUE]: (gl: WebGL2RenderingContext, value) => gl.clearDepth(value),
+  [GL.DEPTH_FUNC]: (gl: WebGL2RenderingContext, value) => gl.depthFunc(value),
+  [GL.DEPTH_RANGE]: (gl: WebGL2RenderingContext, value: [number, number]) => gl.depthRange(...value),
+  [GL.DEPTH_WRITEMASK]: (gl: WebGL2RenderingContext, value) => gl.depthMask(value),
   [GL.DITHER]: enable,
   [GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
 
-  [GL.CURRENT_PROGRAM]: (gl: WebGLRenderingContext, value) => gl.useProgram(value),
-  [GL.RENDERBUFFER_BINDING]: (gl: WebGLRenderingContext, value) =>
+  [GL.CURRENT_PROGRAM]: (gl: WebGL2RenderingContext, value) => gl.useProgram(value),
+  [GL.RENDERBUFFER_BINDING]: (gl: WebGL2RenderingContext, value) =>
     gl.bindRenderbuffer(GL.RENDERBUFFER, value),
-  [GL.TRANSFORM_FEEDBACK_BINDING]: (gl: WebGLRenderingContext, value) =>
-    (gl as WebGL2RenderingContext).bindTransformFeedback?.(GL.TRANSFORM_FEEDBACK, value),
-  [GL.VERTEX_ARRAY_BINDING]: (gl: WebGLRenderingContext, value) =>
-    (gl as WebGL2RenderingContext).bindVertexArray(value),
+  [GL.TRANSFORM_FEEDBACK_BINDING]: (gl: WebGL2RenderingContext, value) =>
+    (gl ).bindTransformFeedback?.(GL.TRANSFORM_FEEDBACK, value),
+  [GL.VERTEX_ARRAY_BINDING]: (gl: WebGL2RenderingContext, value) =>
+    (gl ).bindVertexArray(value),
   // NOTE: FRAMEBUFFER_BINDING and DRAW_FRAMEBUFFER_BINDING(WebGL2) refer same state.
   [GL.FRAMEBUFFER_BINDING]: bindFramebuffer,
   [GL.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
@@ -173,9 +166,9 @@ export const GL_PARAMETER_SETTERS = {
   [GL.PIXEL_PACK_BUFFER_BINDING]: bindBuffer,
   [GL.PIXEL_UNPACK_BUFFER_BINDING]: bindBuffer,
 
-  [GL.FRONT_FACE]: (gl: WebGLRenderingContext, value) => gl.frontFace(value),
+  [GL.FRONT_FACE]: (gl: WebGL2RenderingContext, value) => gl.frontFace(value),
   [GL.GENERATE_MIPMAP_HINT]: hint,
-  [GL.LINE_WIDTH]: (gl: WebGLRenderingContext, value) => gl.lineWidth(value),
+  [GL.LINE_WIDTH]: (gl: WebGL2RenderingContext, value) => gl.lineWidth(value),
   [GL.POLYGON_OFFSET_FILL]: enable,
   [GL.POLYGON_OFFSET_FACTOR]: 'polygonOffset',
   [GL.POLYGON_OFFSET_UNITS]: 'polygonOffset',
@@ -185,12 +178,12 @@ export const GL_PARAMETER_SETTERS = {
   [GL.SAMPLE_COVERAGE_VALUE]: 'sampleCoverage',
   [GL.SAMPLE_COVERAGE_INVERT]: 'sampleCoverage',
   [GL.SCISSOR_TEST]: enable,
-  [GL.SCISSOR_BOX]: (gl: WebGLRenderingContext, value: [number, number, number, number]) => gl.scissor(...value),
+  [GL.SCISSOR_BOX]: (gl: WebGL2RenderingContext, value: [number, number, number, number]) => gl.scissor(...value),
   [GL.STENCIL_TEST]: enable,
-  [GL.STENCIL_CLEAR_VALUE]: (gl: WebGLRenderingContext, value) => gl.clearStencil(value),
-  [GL.STENCIL_WRITEMASK]: (gl: WebGLRenderingContext, value) =>
+  [GL.STENCIL_CLEAR_VALUE]: (gl: WebGL2RenderingContext, value) => gl.clearStencil(value),
+  [GL.STENCIL_WRITEMASK]: (gl: WebGL2RenderingContext, value) =>
     gl.stencilMaskSeparate(GL.FRONT, value),
-  [GL.STENCIL_BACK_WRITEMASK]: (gl: WebGLRenderingContext, value) =>
+  [GL.STENCIL_BACK_WRITEMASK]: (gl: WebGL2RenderingContext, value) =>
     gl.stencilMaskSeparate(GL.BACK, value),
   [GL.STENCIL_FUNC]: 'stencilFuncFront',
   [GL.STENCIL_REF]: 'stencilFuncFront',
@@ -204,7 +197,7 @@ export const GL_PARAMETER_SETTERS = {
   [GL.STENCIL_BACK_FAIL]: 'stencilOpBack',
   [GL.STENCIL_BACK_PASS_DEPTH_FAIL]: 'stencilOpBack',
   [GL.STENCIL_BACK_PASS_DEPTH_PASS]: 'stencilOpBack',
-  [GL.VIEWPORT]: (gl: WebGLRenderingContext, value: [number, number, number, number]) => gl.viewport(...value),
+  [GL.VIEWPORT]: (gl: WebGL2RenderingContext, value: [number, number, number, number]) => gl.viewport(...value),
 
   // WEBGL1 PIXEL PACK/UNPACK MODES
   [GL.PACK_ALIGNMENT]: pixelStorei,
@@ -225,85 +218,85 @@ export const GL_PARAMETER_SETTERS = {
   [GL.UNPACK_SKIP_IMAGES]: pixelStorei,
 
   // Function-style setters
-  framebuffer: (gl: WebGLRenderingContext, framebuffer) => {
+  framebuffer: (gl: WebGL2RenderingContext, framebuffer) => {
     // accepts 1) a WebGLFramebuffer 2) null (default framebuffer), or 3) luma.gl Framebuffer class
     // framebuffer is null when restoring to default framebuffer, otherwise use the WebGL handle.
     const handle = framebuffer && 'handle' in framebuffer ? framebuffer.handle : framebuffer;
     return gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
   },
-  blend: (gl: WebGLRenderingContext, value) => (value ? gl.enable(GL.BLEND) : gl.disable(GL.BLEND)),
-  blendColor: (gl: WebGLRenderingContext, value: [number, number, number, number]) => gl.blendColor(...value),
-  blendEquation: (gl: WebGLRenderingContext, args: number | [number, number]) => {
+  blend: (gl: WebGL2RenderingContext, value) => (value ? gl.enable(GL.BLEND) : gl.disable(GL.BLEND)),
+  blendColor: (gl: WebGL2RenderingContext, value: [number, number, number, number]) => gl.blendColor(...value),
+  blendEquation: (gl: WebGL2RenderingContext, args: number | [number, number]) => {
     const separateModes = typeof args === 'number' ? [args, args] as [number, number]: args;
     gl.blendEquationSeparate(...separateModes);
   },
-  blendFunc: (gl: WebGLRenderingContext, args: [number, number] | [number, number, number, number]) => {
+  blendFunc: (gl: WebGL2RenderingContext, args: [number, number] | [number, number, number, number]) => {
     const separateFuncs = args?.length === 2 ? [...args, ...args] as [number, number, number, number] : args;
     gl.blendFuncSeparate(...separateFuncs);
   },
 
-  clearColor: (gl: WebGLRenderingContext, value: [number, number, number, number]) => gl.clearColor(...value),
-  clearDepth: (gl: WebGLRenderingContext, value) => gl.clearDepth(value),
-  clearStencil: (gl: WebGLRenderingContext, value) => gl.clearStencil(value),
+  clearColor: (gl: WebGL2RenderingContext, value: [number, number, number, number]) => gl.clearColor(...value),
+  clearDepth: (gl: WebGL2RenderingContext, value) => gl.clearDepth(value),
+  clearStencil: (gl: WebGL2RenderingContext, value) => gl.clearStencil(value),
 
-  colorMask: (gl: WebGLRenderingContext, value: [boolean, boolean, boolean, boolean]) => gl.colorMask(...value),
+  colorMask: (gl: WebGL2RenderingContext, value: [boolean, boolean, boolean, boolean]) => gl.colorMask(...value),
 
-  cull: (gl: WebGLRenderingContext, value) =>
+  cull: (gl: WebGL2RenderingContext, value) =>
     value ? gl.enable(GL.CULL_FACE) : gl.disable(GL.CULL_FACE),
-  cullFace: (gl: WebGLRenderingContext, value) => gl.cullFace(value),
+  cullFace: (gl: WebGL2RenderingContext, value) => gl.cullFace(value),
 
-  depthTest: (gl: WebGLRenderingContext, value) =>
+  depthTest: (gl: WebGL2RenderingContext, value) =>
     value ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST),
-  depthFunc: (gl: WebGLRenderingContext, value) => gl.depthFunc(value),
-  depthMask: (gl: WebGLRenderingContext, value) => gl.depthMask(value),
-  depthRange: (gl: WebGLRenderingContext, value: [number, number]) => gl.depthRange(...value),
+  depthFunc: (gl: WebGL2RenderingContext, value) => gl.depthFunc(value),
+  depthMask: (gl: WebGL2RenderingContext, value) => gl.depthMask(value),
+  depthRange: (gl: WebGL2RenderingContext, value: [number, number]) => gl.depthRange(...value),
 
-  dither: (gl: WebGLRenderingContext, value) =>
+  dither: (gl: WebGL2RenderingContext, value) =>
     value ? gl.enable(GL.DITHER) : gl.disable(GL.DITHER),
 
-  derivativeHint: (gl: WebGLRenderingContext, value) => {
+  derivativeHint: (gl: WebGL2RenderingContext, value) => {
     // gl1: 'OES_standard_derivatives'
     gl.hint(GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
   },
 
-  frontFace: (gl: WebGLRenderingContext, value) => gl.frontFace(value),
+  frontFace: (gl: WebGL2RenderingContext, value) => gl.frontFace(value),
 
-  mipmapHint: (gl: WebGLRenderingContext, value) => gl.hint(GL.GENERATE_MIPMAP_HINT, value),
+  mipmapHint: (gl: WebGL2RenderingContext, value) => gl.hint(GL.GENERATE_MIPMAP_HINT, value),
 
-  lineWidth: (gl: WebGLRenderingContext, value) => gl.lineWidth(value),
+  lineWidth: (gl: WebGL2RenderingContext, value) => gl.lineWidth(value),
 
-  polygonOffsetFill: (gl: WebGLRenderingContext, value) =>
+  polygonOffsetFill: (gl: WebGL2RenderingContext, value) =>
     value ? gl.enable(GL.POLYGON_OFFSET_FILL) : gl.disable(GL.POLYGON_OFFSET_FILL),
-  polygonOffset: (gl: WebGLRenderingContext, value: [number, number]) => gl.polygonOffset(...value),
+  polygonOffset: (gl: WebGL2RenderingContext, value: [number, number]) => gl.polygonOffset(...value),
 
-  sampleCoverage: (gl: WebGLRenderingContext, value: [number, boolean?]) => gl.sampleCoverage(...value),
+  sampleCoverage: (gl: WebGL2RenderingContext, value: [number, boolean?]) => gl.sampleCoverage(...value),
 
-  scissorTest: (gl: WebGLRenderingContext, value) =>
+  scissorTest: (gl: WebGL2RenderingContext, value) =>
     value ? gl.enable(GL.SCISSOR_TEST) : gl.disable(GL.SCISSOR_TEST),
-  scissor: (gl: WebGLRenderingContext, value: [number, number, number, number]) => gl.scissor(...value),
+  scissor: (gl: WebGL2RenderingContext, value: [number, number, number, number]) => gl.scissor(...value),
 
-  stencilTest: (gl: WebGLRenderingContext, value) =>
+  stencilTest: (gl: WebGL2RenderingContext, value) =>
     value ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST),
-  stencilMask: (gl: WebGLRenderingContext, value) => {
+  stencilMask: (gl: WebGL2RenderingContext, value) => {
     value = isArray(value) ? value : [value, value];
     const [mask, backMask] = value;
     gl.stencilMaskSeparate(GL.FRONT, mask);
     gl.stencilMaskSeparate(GL.BACK, backMask);
   },
-  stencilFunc: (gl: WebGLRenderingContext, args) => {
+  stencilFunc: (gl: WebGL2RenderingContext, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [func, ref, mask, backFunc, backRef, backMask] = args;
     gl.stencilFuncSeparate(GL.FRONT, func, ref, mask);
     gl.stencilFuncSeparate(GL.BACK, backFunc, backRef, backMask);
   },
-  stencilOp: (gl: WebGLRenderingContext, args) => {
+  stencilOp: (gl: WebGL2RenderingContext, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args;
     gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
     gl.stencilOpSeparate(GL.BACK, backSfail, backDpfail, backDppass);
   },
 
-  viewport: (gl: WebGLRenderingContext, value: [number, number, number, number]) => gl.viewport(...value)
+  viewport: (gl: WebGL2RenderingContext, value: [number, number, number, number]) => gl.viewport(...value)
 };
 
 function getValue(glEnum, values, cache) {
@@ -312,50 +305,50 @@ function getValue(glEnum, values, cache) {
 
 // COMPOSITE_WEBGL_PARAMETER_
 export const GL_COMPOSITE_PARAMETER_SETTERS = {
-  blendEquation: (gl: WebGLRenderingContext, values, cache) =>
+  blendEquation: (gl: WebGL2RenderingContext, values, cache) =>
     gl.blendEquationSeparate(
       getValue(GL.BLEND_EQUATION_RGB, values, cache),
       getValue(GL.BLEND_EQUATION_ALPHA, values, cache)
     ),
-  blendFunc: (gl: WebGLRenderingContext, values, cache) =>
+  blendFunc: (gl: WebGL2RenderingContext, values, cache) =>
     gl.blendFuncSeparate(
       getValue(GL.BLEND_SRC_RGB, values, cache),
       getValue(GL.BLEND_DST_RGB, values, cache),
       getValue(GL.BLEND_SRC_ALPHA, values, cache),
       getValue(GL.BLEND_DST_ALPHA, values, cache)
     ),
-  polygonOffset: (gl: WebGLRenderingContext, values, cache) =>
+  polygonOffset: (gl: WebGL2RenderingContext, values, cache) =>
     gl.polygonOffset(
       getValue(GL.POLYGON_OFFSET_FACTOR, values, cache),
       getValue(GL.POLYGON_OFFSET_UNITS, values, cache)
     ),
-  sampleCoverage: (gl: WebGLRenderingContext, values, cache) =>
+  sampleCoverage: (gl: WebGL2RenderingContext, values, cache) =>
     gl.sampleCoverage(
       getValue(GL.SAMPLE_COVERAGE_VALUE, values, cache),
       getValue(GL.SAMPLE_COVERAGE_INVERT, values, cache)
     ),
-  stencilFuncFront: (gl: WebGLRenderingContext, values, cache) =>
+  stencilFuncFront: (gl: WebGL2RenderingContext, values, cache) =>
     gl.stencilFuncSeparate(
       GL.FRONT,
       getValue(GL.STENCIL_FUNC, values, cache),
       getValue(GL.STENCIL_REF, values, cache),
       getValue(GL.STENCIL_VALUE_MASK, values, cache)
     ),
-  stencilFuncBack: (gl: WebGLRenderingContext, values, cache) =>
+  stencilFuncBack: (gl: WebGL2RenderingContext, values, cache) =>
     gl.stencilFuncSeparate(
       GL.BACK,
       getValue(GL.STENCIL_BACK_FUNC, values, cache),
       getValue(GL.STENCIL_BACK_REF, values, cache),
       getValue(GL.STENCIL_BACK_VALUE_MASK, values, cache)
     ),
-  stencilOpFront: (gl: WebGLRenderingContext, values, cache) =>
+  stencilOpFront: (gl: WebGL2RenderingContext, values, cache) =>
     gl.stencilOpSeparate(
       GL.FRONT,
       getValue(GL.STENCIL_FAIL, values, cache),
       getValue(GL.STENCIL_PASS_DEPTH_FAIL, values, cache),
       getValue(GL.STENCIL_PASS_DEPTH_PASS, values, cache)
     ),
-  stencilOpBack: (gl: WebGLRenderingContext, values, cache) =>
+  stencilOpBack: (gl: WebGL2RenderingContext, values, cache) =>
     gl.stencilOpSeparate(
       GL.BACK,
       getValue(GL.STENCIL_BACK_FAIL, values, cache),
@@ -589,7 +582,7 @@ export const GL_HOOKED_SETTERS = {
 
 // GETTER TABLE - FOR READING OUT AN ENTIRE CONTEXT
 
-const isEnabled = (gl: WebGLRenderingContext, key) => gl.isEnabled(key);
+const isEnabled = (gl: WebGL2RenderingContext, key) => gl.isEnabled(key);
 
 // Exceptions for any keys that cannot be queried by gl.getParameters
 export const GL_PARAMETER_GETTERS = {
@@ -602,8 +595,6 @@ export const GL_PARAMETER_GETTERS = {
   [GL.SAMPLE_COVERAGE]: isEnabled,
   [GL.SCISSOR_TEST]: isEnabled,
   [GL.STENCIL_TEST]: isEnabled,
-
-  // WebGL 2
   [GL.RASTERIZER_DISCARD]: isEnabled
 };
 

package/src/context/state-tracker/track-context-state.ts

@@ -12,7 +12,7 @@ import {deepArrayEqual} from './deep-array-equal';
 
 /* eslint-disable no-shadow */
 class GLState {
-  gl: WebGLRenderingContext;
+  gl: WebGL2RenderingContext;
   program: unknown = null;
   stateStack: object[] = [];
   enable = true;
@@ -20,7 +20,7 @@ class GLState {
   log;
 
   constructor(
-    gl: WebGLRenderingContext,
+    gl: WebGL2RenderingContext,
     {
       copyState = false, // Copy cache from params (slow) or initialize from WebGL defaults (fast)
       log = () => {} // Logging function, called when gl parameter change calls are actually issued
@@ -84,7 +84,7 @@ class GLState {
   }
 }
 
-function getContextState(gl: WebGLRenderingContext): GLState {
+function getContextState(gl: WebGL2RenderingContext): GLState {
   // @ts-expect-error
   return gl.state as GLState;
 }
@@ -100,13 +100,13 @@ function getContextState(gl: WebGLRenderingContext): GLState {
  * temporarily modifying, and then restoring state.
  */
 export function trackContextState(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   options?: {
     enable?: boolean;
     copyState?: boolean;
     log?: any;
   }
-): WebGLRenderingContext {
+): WebGL2RenderingContext {
   const {enable = true, copyState} = options;
   assert(copyState !== undefined);
   // @ts-expect-error
@@ -143,7 +143,7 @@ export function trackContextState(
 /**
  * Saves current WebGL context state onto an internal per-context stack
  */
-export function pushContextState(gl: WebGLRenderingContext): void {
+export function pushContextState(gl: WebGL2RenderingContext): void {
   let glState = getContextState(gl);
   if (!glState) {
     trackContextState(gl, {copyState: false});
@@ -156,7 +156,7 @@ export function pushContextState(gl: WebGLRenderingContext): void {
 /**
  * Restores previously saved WebGL context state
  */
-export function popContextState(gl: WebGLRenderingContext): void {
+export function popContextState(gl: WebGL2RenderingContext): void {
   const glState = getContextState(gl);
   assert(glState);
   glState.pop();
@@ -165,13 +165,13 @@ export function popContextState(gl: WebGLRenderingContext): void {
 // HELPER FUNCTIONS - INSTALL GET/SET INTERCEPTORS (SPYS) ON THE CONTEXT
 
 /**
-// Overrides a WebGLRenderingContext state "getter" function
+// Overrides a WebGL2RenderingContext state "getter" function
 // to return values directly from cache
  * @param gl
  * @param functionName
  */
-function installGetterOverride(gl: WebGLRenderingContext, functionName: string) {
-  // Get the original function from the WebGLRenderingContext
+function installGetterOverride(gl: WebGL2RenderingContext, functionName: string) {
+  // Get the original function from the WebGL2RenderingContext
   const originalGetterFunc = gl[functionName].bind(gl);
 
   // Wrap it with a spy so that we can update our state cache when it gets called
@@ -187,11 +187,11 @@ function installGetterOverride(gl: WebGLRenderingContext, functionName: string)
       glState.cache[pname] = originalGetterFunc(pname);
     }
 
-    // Optionally call the original function to do a "hard" query from the WebGLRenderingContext
+    // Optionally call the original function to do a "hard" query from the WebGL2RenderingContext
     return glState.enable
       ? // Call the getter the params so that it can e.g. serve from a cache
       glState.cache[pname]
-      : // Optionally call the original function to do a "hard" query from the WebGLRenderingContext
+      : // Optionally call the original function to do a "hard" query from the WebGL2RenderingContext
       originalGetterFunc(pname);
   };
 
@@ -203,7 +203,7 @@ function installGetterOverride(gl: WebGLRenderingContext, functionName: string)
 }
 
 /**
-// Overrides a WebGLRenderingContext state "setter" function
+// Overrides a WebGL2RenderingContext state "setter" function
 // to call a setter spy before the actual setter. Allows us to keep a cache
 // updated with a copy of the WebGL context state.
  * @param gl
@@ -211,9 +211,10 @@ function installGetterOverride(gl: WebGLRenderingContext, functionName: string)
  * @param setter
  * @returns
  */
-function installSetterSpy(gl: WebGLRenderingContext, functionName: string, setter: Function) {
-  // Get the original function from the WebGLRenderingContext
+function installSetterSpy(gl: WebGL2RenderingContext, functionName: string, setter: Function) {
+  // Get the original function from the WebGL2RenderingContext
   if (!gl[functionName]) {
+    // TODO - remove?
     // This could happen if we try to intercept WebGL2 method on a WebGL1 context
     return;
   }
@@ -228,7 +229,7 @@ function installSetterSpy(gl: WebGLRenderingContext, functionName: string, sette
     // eslint-disable-next-line @typescript-eslint/unbound-method
     const {valueChanged, oldValue} = setter(glState._updateCache, ...params);
 
-    // Call the original WebGLRenderingContext func to make sure the context actually gets updated
+    // Call the original WebGL2RenderingContext func to make sure the context actually gets updated
     if (valueChanged) {
       originalSetterFunc(...params);
     }
@@ -248,7 +249,7 @@ function installSetterSpy(gl: WebGLRenderingContext, functionName: string, sette
   });
 }
 
-function installProgramSpy(gl: WebGLRenderingContext): void {
+function installProgramSpy(gl: WebGL2RenderingContext): void {
   const originalUseProgram = gl.useProgram.bind(gl);
 
   gl.useProgram = function useProgramLuma(handle) {

package/src/context/state-tracker/with-parameters.ts

@@ -14,7 +14,7 @@ import {pushContextState, popContextState} from './track-context-state';
  * - Restores parameters
  * - Returns the return value of the supplied function
  */
-export function withGLParameters(device: Device | WebGLRenderingContext, parameters: GLParameters & {nocatch?: boolean}, func: any): any {
+export function withGLParameters(device: Device | WebGL2RenderingContext, parameters: GLParameters & {nocatch?: boolean}, func: any): any {
   const webglDevice = WebGLDevice.attach(device);
   const gl = webglDevice.gl;
 

package/src/index.ts

@@ -8,9 +8,7 @@
 // Higher level abstractions can be built on these classes
 
 // Types
-export type {WebGLLimits} from './adapter/device-helpers/device-limits';
-
-export {registerHeadlessGL} from './context/context/create-headless-context';
+export type {WebGLLimits} from './adapter/device-helpers/webgl-device-limits';
 
 // WebGL adapter classes
 export {WebGLDevice} from './adapter/webgl-device';
@@ -43,24 +41,13 @@ export {WEBGLTransformFeedback} from './adapter/resources/webgl-transform-feedba
 export {Accessor} from './classic/accessor';
 export type {AccessorObject} from './types';
 
-export {
-  isWebGL,
-  isWebGL2,
-  getWebGL2Context,
-  assertWebGLContext,
-  assertWebGL2Context
-} from './context/context/webgl-checks';
-
 // Unified parameter API
 
 export {setDeviceParameters, withDeviceParameters} from './adapter/converters/device-parameters';
 
 // HELPERS - EXPERIMENTAL
 export {getShaderLayout} from './adapter/helpers/get-shader-layout';
-export {
-  convertGLToTextureFormat,
-  _checkFloat32ColorAttachment
-} from './adapter/converters/texture-formats';
+export {convertGLToTextureFormat} from './adapter/converters/texture-formats';
 
 // TEST EXPORTS
 export {TEXTURE_FORMATS as _TEXTURE_FORMATS} from './adapter/converters/texture-formats';
@@ -72,8 +59,6 @@ export {
   pushContextState,
   popContextState
 } from './context/state-tracker/track-context-state';
-// Polyfills (supports a subset of WebGL2 APIs on WebGL1 contexts)
-export {polyfillContext} from './context/polyfill/polyfill-context';
 
 export {
   resetGLParameters,

package/dist/adapter/converters/device-parameters.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"device-parameters.js","names":["log","isObjectEmpty","pushContextState","popContextState","setGLParameters","WebGLDevice","withDeviceAndGLParameters","device","parameters","glParameters","func","gl","setDeviceParameters","withGLParameters","withDeviceParameters","webglDevice","attach","cullMode","disable","enable","cullFace","frontFace","map","ccw","cw","depthBias","undefined","polygonOffset","depthBiasSlopeScale","depthWriteEnabled","depthMask","mapBoolean","depthCompare","depthFunc","convertCompareFunction","stencilWriteMask","mask","stencilMaskSeparate","stencilReadMask","warn","stencilCompare","glValue","stencilFuncSeparate","stencilPassOperation","stencilFailOperation","stencilDepthFailOperation","dppass","convertStencilOperation","sfail","dpfail","stencilOpSeparate","blendColorOperation","blendAlphaOperation","colorEquation","convertBlendOperationToEquation","alphaEquation","blendEquationSeparate","colorSrcFactor","convertBlendFactorToFunction","blendColorSrcFactor","colorDstFactor","blendColorDstFactor","alphaSrcFactor","blendAlphaSrcFactor","alphaDstFactor","blendAlphaDstFactor","blendFuncSeparate","parameter","value","never","less","equal","greater","always","convertToCompareFunction","keep","zero","replace","invert","message","valueMap","Error"],"sources":["../../../src/adapter/converters/device-parameters.ts"],"sourcesContent":["// luma.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport {\n  Device,\n  Parameters,\n  CompareFunction,\n  StencilOperation,\n  log,\n  isObjectEmpty,\n  BlendOperation,\n  BlendFactor\n} from '@luma.gl/core';\nimport {GL} from '@luma.gl/constants';\nimport type {GLBlendEquation, GLBlendFunction, GLParameters} from '@luma.gl/constants';\nimport {pushContextState, popContextState} from '../../context/state-tracker/track-context-state';\nimport {setGLParameters} from '../../context/parameters/unified-parameter-api';\nimport {WebGLDevice} from '../webgl-device';\n\n/* eslint-disable no-unused-expressions */ // For expression ? gl.enable() : gl.disable()\n\n/**\n * Execute a function with a set of temporary WebGL parameter overrides\n * - Saves current \"global\" WebGL context settings\n * - Sets the supplies WebGL context parameters,\n * - Executes supplied function\n * - Restores parameters\n * - Returns the return value of the supplied function\n */\nexport function withDeviceAndGLParameters<T = unknown>(\n  device: Device, \n  parameters: Parameters,\n  glParameters: GLParameters,\n  func: (device?: Device) => T\n): T {\n  if (isObjectEmpty(parameters)) {\n    // Avoid setting state if no parameters provided. Just call and return\n    return func(device);\n  }\n\n  // Wrap in a try-catch to ensure that parameters are restored on exceptions\n  // @ts-expect-error\n  pushContextState(device.gl);\n  try {\n    setDeviceParameters(device, parameters);\n    setGLParameters(device, glParameters);\n    return func(device);\n  } finally {\n    // @ts-expect-error\n    popContextState(device.gl);\n  }\n}\n\n/**\n * Execute a function with a set of temporary WebGL parameter overrides\n * - Saves current \"global\" WebGL context settings\n * - Sets the supplies WebGL context parameters,\n * - Executes supplied function\n * - Restores parameters\n * - Returns the return value of the supplied function\n * @deprecated use withDeviceParameters instead\n */\nexport function withGLParameters<T = unknown>(\n  device: Device,\n  parameters: GLParameters,\n  func: (device?: Device) => T\n): T {\n  if (isObjectEmpty(parameters)) {\n    // Avoid setting state if no parameters provided. Just call and return\n    return func(device);\n  }\n\n  // Wrap in a try-catch to ensure that parameters are restored on exceptions\n  // @ts-expect-error\n  pushContextState(device.gl);\n  try {\n    setGLParameters(device, parameters);\n    return func(device);\n  } finally {\n    // @ts-expect-error\n    popContextState(device.gl);\n  }\n}\n\n/**\n * Execute a function with a set of temporary WebGL parameter overrides\n * - Saves current \"global\" WebGL context settings\n * - Sets the supplies WebGL context parameters,\n * - Executes supplied function\n * - Restores parameters\n * - Returns the return value of the supplied function\n */\nexport function withDeviceParameters<T = unknown>(\n  device: Device,\n  parameters: Parameters,\n  func: (device?: Device) => T\n): T {\n  if (isObjectEmpty(parameters)) {\n    // Avoid setting state if no parameters provided. Just call and return\n    return func(device);\n  }\n\n  // Wrap in a try-catch to ensure that parameters are restored on exceptions\n  // @ts-expect-error\n  pushContextState(device.gl);\n  try {\n    setDeviceParameters(device, parameters);\n    return func(device);\n  } finally {\n    // @ts-expect-error\n    popContextState(device.gl);\n  }\n}\n\n/** Set WebGPU Style Parameters */\nexport function setDeviceParameters(device: Device, parameters: Parameters) {\n  const webglDevice = WebGLDevice.attach(device);\n  const {gl} = webglDevice;\n\n  // RASTERIZATION SETTINGS\n  if (parameters.cullMode) {\n    switch (parameters.cullMode) {\n      case 'none':\n        gl.disable(GL.CULL_FACE);\n        break;\n      case 'front':\n        gl.enable(GL.CULL_FACE);\n        gl.cullFace(GL.FRONT);\n        break;\n      case 'back':\n        gl.enable(GL.CULL_FACE);\n        gl.cullFace(GL.BACK);\n        break;\n    }\n  }\n\n  if (parameters.frontFace) {\n    gl.frontFace(\n      map('frontFace', parameters.frontFace, {\n        ccw: GL.CCW,\n        cw: GL.CW\n      })\n    );\n  }\n\n  if (parameters.depthBias !== undefined) {\n    gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);\n  }\n\n  // depthBiasSlopeScale: {\n  //   // Handled by depthBias\n  // },\n\n  // DEPTH STENCIL\n\n  if (parameters.depthWriteEnabled !== undefined) {\n    gl.depthMask(mapBoolean('depthWriteEnabled', parameters.depthWriteEnabled));\n  }\n\n  if (parameters.depthCompare) {\n    parameters.depthCompare !== 'always' ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST);\n    gl.depthFunc(convertCompareFunction('depthCompare', parameters.depthCompare));\n  }\n\n  if (parameters.stencilWriteMask) {\n    const mask = parameters.stencilWriteMask;\n    gl.stencilMaskSeparate(GL.FRONT, mask);\n    gl.stencilMaskSeparate(GL.BACK, mask);\n  }\n\n  if (parameters.stencilReadMask) {\n    // stencilReadMask is handle inside stencil***Compare.\n    log.warn('stencilReadMask not supported under WebGL');\n  }\n\n  if (parameters.stencilCompare) {\n    const mask = parameters.stencilReadMask || 0xffffffff;\n    const glValue = convertCompareFunction('depthCompare', parameters.stencilCompare);\n    // TODO - ensure back doesn't overwrite\n    parameters.stencilCompare !== 'always'\n      ? gl.enable(GL.STENCIL_TEST)\n      : gl.disable(GL.STENCIL_TEST);\n    gl.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);\n    gl.stencilFuncSeparate(GL.BACK, glValue, 0, mask);\n  }\n\n  if (\n    parameters.stencilPassOperation &&\n    parameters.stencilFailOperation &&\n    parameters.stencilDepthFailOperation\n  ) {\n    const dppass = convertStencilOperation('stencilPassOperation', parameters.stencilPassOperation);\n    const sfail = convertStencilOperation('stencilFailOperation', parameters.stencilFailOperation);\n    const dpfail = convertStencilOperation(\n      'stencilDepthFailOperation',\n      parameters.stencilDepthFailOperation\n    );\n    gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);\n    gl.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);\n  }\n\n  // stencilDepthFailOperation() {\n  //   // handled by stencilPassOperation\n  // },\n\n  // stencilFailOperation() {\n  //   // handled by stencilPassOperation\n  // },\n\n  // COLOR STATE\n\n  if (parameters.blendColorOperation || parameters.blendAlphaOperation) {\n    gl.enable(GL.BLEND);\n\n    const colorEquation = convertBlendOperationToEquation('blendColorOperation', parameters.blendColorOperation || 'add');\n    const alphaEquation = convertBlendOperationToEquation('blendAlphaOperation', parameters.blendAlphaOperation || 'add');\n    gl.blendEquationSeparate(colorEquation, alphaEquation);\n\n    const colorSrcFactor = convertBlendFactorToFunction('blendColorSrcFactor', parameters.blendColorSrcFactor || 'one');\n    const colorDstFactor = convertBlendFactorToFunction('blendColorDstFactor', parameters.blendColorDstFactor || 'zero');\n    const alphaSrcFactor = convertBlendFactorToFunction('blendAlphaSrcFactor', parameters.blendAlphaSrcFactor || 'one');\n    const alphaDstFactor = convertBlendFactorToFunction('blendAlphaDstFactor', parameters.blendAlphaDstFactor || 'zero');\n    gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);\n  }\n}\n\n/*\n      rasterizationState: {\n        cullMode: \"back\",\n      },\n\n      depthStencilState: {\n        depthWriteEnabled: true,\n        depthCompare: \"less\",\n        format: \"depth24plus-stencil8\",\n      },\n\n      colorStates: [\n        {\n          format: \"bgra8unorm\",\n          // colorBlend.srcFactor = wgpu::BlendFactor::SrcAlpha;\n          // colorBlend.dstFactor = wgpu::BlendFactor::OneMinusSrcAlpha;\n          // alphaBlend.srcFactor = wgpu::BlendFactor::SrcAlpha;\n          // alphaBlend.dstFactor = wgpu::BlendFactor::OneMinusSrcAlpha;\n        },\n      ],\n    });\n*/\n\nexport function convertCompareFunction(parameter: string, value: CompareFunction): GL {\n  return map(parameter, value, {\n    never: GL.NEVER,\n    less: GL.LESS,\n    equal: GL.EQUAL,\n    'less-equal': GL.LEQUAL,\n    greater: GL.GREATER,\n    'not-equal': GL.NOTEQUAL,\n    'greater-equal': GL.GEQUAL,\n    always: GL.ALWAYS\n  });\n}\n\nexport function convertToCompareFunction(parameter: string, value: GL): CompareFunction {\n  return map(parameter, value, {\n    [GL.NEVER]: 'never',\n    [GL.LESS]: 'less',\n    [GL.EQUAL]: 'equal',\n    [GL.LEQUAL]: 'less-equal',\n    [GL.GREATER]: 'greater',\n    [GL.NOTEQUAL]: 'not-equal',\n    [GL.GEQUAL]: 'greater-equal',\n    [GL.ALWAYS]: 'always'\n  });\n}\n\nfunction convertStencilOperation(parameter: string, value: StencilOperation): GL {\n  return map(parameter, value, {\n    keep: GL.KEEP,\n    zero: GL.ZERO,\n    replace: GL.REPLACE,\n    invert: GL.INVERT,\n    'increment-clamp': GL.INCR,\n    'decrement-clamp': GL.DECR,\n    'increment-wrap': GL.INCR_WRAP,\n    'decrement-wrap': GL.DECR_WRAP\n  });\n}\n\nfunction convertBlendOperationToEquation(parameter: string, value: BlendOperation): GLBlendEquation {\n  return map(parameter, value, {\n    'add': GL.FUNC_ADD,\n    'subtract': GL.FUNC_SUBTRACT,\n    'reverse-subtract': GL.FUNC_REVERSE_SUBTRACT,\n    // When using a WebGL 2 context, the following values are available additionally:\n    'min': GL.MIN,\n    'max': GL.MAX\n  } as Record<BlendOperation, GLBlendEquation>);\n}\n\nfunction convertBlendFactorToFunction(parameter: string, value: BlendFactor): GLBlendFunction {\n  return map(parameter, value, {\n    'one': GL.ONE,\n    'zero': GL.ZERO,\n    'src-color': GL.SRC_COLOR,\n    'one-minus-src-color': GL.ONE_MINUS_SRC_COLOR,\n    'dst-color': GL.DST_COLOR,\n    'one-minus-dst-color': GL.ONE_MINUS_DST_COLOR,\n    'src-alpha': GL.SRC_ALPHA,\n    'one-minus-src-alpha': GL.ONE_MINUS_SRC_ALPHA,\n    'dst-alpha': GL.DST_ALPHA,\n    'one-minus-dst-alpha': GL.ONE_MINUS_DST_ALPHA,\n  } as Record<BlendFactor, GLBlendFunction>);\n}\n\nfunction message(parameter: string, value: any): string {\n  return `Illegal parameter ${value} for ${parameter}`;\n}\n\nfunction map(parameter: string, value: any, valueMap: Record<string, any>): any {\n  if (!(value in valueMap)) {\n    throw new Error(message(parameter, value));\n  }\n  return valueMap[value];\n}\n\nfunction mapBoolean(parameter: string, value: boolean): boolean {\n  return value;\n}\n"],"mappings":"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"}

package/dist/adapter/converters/sampler-parameters.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sampler-parameters.js","names":["convertCompareFunction","convertSamplerParametersToWebGL","props","params","addressModeU","convertAddressMode","addressModeV","addressModeW","magFilter","convertMaxFilterMode","minFilter","mipmapFilter","convertMinFilterMode","lodMinClamp","undefined","lodMaxClamp","type","compare","maxAnisotropy","updateSamplerParametersForNPOT","parameters","newParameters","addressMode","maxFilter"],"sources":["../../../src/adapter/converters/sampler-parameters.ts"],"sourcesContent":["// luma.gl, MIT license\n// Copyright (c) vis.gl contributors\n\n// SAMPLER FILTERS\nimport {SamplerProps} from '@luma.gl/core';\nimport {GL, GLSamplerParameters} from '@luma.gl/constants';\nimport {convertCompareFunction} from './device-parameters';\n\n/**\n * Convert WebGPU-style sampler props to WebGL\n * @param props\n * @returns\n */\nexport function convertSamplerParametersToWebGL(props: SamplerProps): GLSamplerParameters {\n  const params: GLSamplerParameters = {};\n  if (props.addressModeU) {\n    params[GL.TEXTURE_WRAP_S] = convertAddressMode(props.addressModeU);\n  }\n  if (props.addressModeV) {\n    params[GL.TEXTURE_WRAP_T] = convertAddressMode(props.addressModeV);\n  }\n  if (props.addressModeW) {\n    params[GL.TEXTURE_WRAP_R] = convertAddressMode(props.addressModeW);\n  }\n  if (props.magFilter) {\n    params[GL.TEXTURE_MAG_FILTER] = convertMaxFilterMode(props.magFilter);\n  }\n  if (props.minFilter || props.mipmapFilter) {\n    // TODO - arbitrary choice of linear?\n    params[GL.TEXTURE_MIN_FILTER] = convertMinFilterMode(\n      props.minFilter || 'linear',\n      props.mipmapFilter\n    );\n  }\n  if (props.lodMinClamp !== undefined) {\n    params[GL.TEXTURE_MIN_LOD] = props.lodMinClamp;\n  }\n  if (props.lodMaxClamp !== undefined) {\n    params[GL.TEXTURE_MAX_LOD] = props.lodMaxClamp;\n  }\n  if (props.type === 'comparison-sampler') {\n    // Setting prop.compare turns this into a comparison sampler\n    params[GL.TEXTURE_COMPARE_MODE] = GL.COMPARE_REF_TO_TEXTURE;\n  }\n  if (props.compare) {\n    params[GL.TEXTURE_COMPARE_FUNC] = convertCompareFunction('compare', props.compare);\n  }\n  // Note depends on WebGL extension\n  if (props.maxAnisotropy) {\n    params[GL.TEXTURE_MAX_ANISOTROPY_EXT] = props.maxAnisotropy;\n  }\n  return params;\n}\n\n/**\n * Override sampler settings that are not supported by Non-Power-of-Two textures in WebGL1.\n */\nexport function updateSamplerParametersForNPOT(\n  parameters: GLSamplerParameters\n): GLSamplerParameters {\n  const newParameters = {...parameters};\n  if (parameters[GL.TEXTURE_MIN_FILTER] !== GL.NEAREST) {\n    // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_MIN_FILTER to LINEAR`)();\n    newParameters[GL.TEXTURE_MIN_FILTER] = GL.LINEAR;\n  }\n  // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_WRAP_S to CLAMP_TO_EDGE`)();\n  newParameters[GL.TEXTURE_WRAP_S] = GL.CLAMP_TO_EDGE;\n  newParameters[GL.TEXTURE_WRAP_T] = GL.CLAMP_TO_EDGE;\n  return newParameters;\n}\n\n// HELPERS\n\n/** Convert address more */\nfunction convertAddressMode(addressMode: 'clamp-to-edge' | 'repeat' | 'mirror-repeat'): GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT {\n  switch (addressMode) {\n    case 'clamp-to-edge':\n      return GL.CLAMP_TO_EDGE;\n    case 'repeat':\n      return GL.REPEAT;\n    case 'mirror-repeat':\n      return GL.MIRRORED_REPEAT;\n  }\n}\n\nfunction convertMaxFilterMode(maxFilter: 'nearest' | 'linear'): GL.NEAREST | GL.LINEAR {\n  switch (maxFilter) {\n    case 'nearest':\n      return GL.NEAREST;\n    case 'linear':\n      return GL.LINEAR;\n  }\n}\n\n/**\n * WebGPU has separate min filter and mipmap filter,\n * WebGL is combined and effectively offers 6 options\n */\nfunction convertMinFilterMode(\n  minFilter: 'nearest' | 'linear',\n  mipmapFilter?: 'nearest' | 'linear'\n): GL.NEAREST | GL.LINEAR | GL.NEAREST_MIPMAP_NEAREST | GL.LINEAR_MIPMAP_NEAREST | GL.NEAREST_MIPMAP_LINEAR | GL.LINEAR_MIPMAP_LINEAR {\n  if (!mipmapFilter) {\n    return convertMaxFilterMode(minFilter);\n  }\n  switch (minFilter) {\n    case 'nearest':\n      return mipmapFilter === 'nearest' ? GL.NEAREST_MIPMAP_NEAREST : GL.NEAREST_MIPMAP_LINEAR;\n    case 'linear':\n      return mipmapFilter === 'nearest' ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR_MIPMAP_LINEAR;\n  }\n}\n"],"mappings":"SAMQA,sBAAsB;AAO9B,OAAO,SAASC,+BAA+BA,CAACC,KAAmB,EAAuB;EACxF,MAAMC,MAA2B,GAAG,CAAC,CAAC;EACtC,IAAID,KAAK,CAACE,YAAY,EAAE;IACtBD,MAAM,OAAmB,GAAGE,kBAAkB,CAACH,KAAK,CAACE,YAAY,CAAC;EACpE;EACA,IAAIF,KAAK,CAACI,YAAY,EAAE;IACtBH,MAAM,OAAmB,GAAGE,kBAAkB,CAACH,KAAK,CAACI,YAAY,CAAC;EACpE;EACA,IAAIJ,KAAK,CAACK,YAAY,EAAE;IACtBJ,MAAM,OAAmB,GAAGE,kBAAkB,CAACH,KAAK,CAACK,YAAY,CAAC;EACpE;EACA,IAAIL,KAAK,CAACM,SAAS,EAAE;IACnBL,MAAM,OAAuB,GAAGM,oBAAoB,CAACP,KAAK,CAACM,SAAS,CAAC;EACvE;EACA,IAAIN,KAAK,CAACQ,SAAS,IAAIR,KAAK,CAACS,YAAY,EAAE;IAEzCR,MAAM,OAAuB,GAAGS,oBAAoB,CAClDV,KAAK,CAACQ,SAAS,IAAI,QAAQ,EAC3BR,KAAK,CAACS,YACR,CAAC;EACH;EACA,IAAIT,KAAK,CAACW,WAAW,KAAKC,SAAS,EAAE;IACnCX,MAAM,OAAoB,GAAGD,KAAK,CAACW,WAAW;EAChD;EACA,IAAIX,KAAK,CAACa,WAAW,KAAKD,SAAS,EAAE;IACnCX,MAAM,OAAoB,GAAGD,KAAK,CAACa,WAAW;EAChD;EACA,IAAIb,KAAK,CAACc,IAAI,KAAK,oBAAoB,EAAE;IAEvCb,MAAM,OAAyB,QAA4B;EAC7D;EACA,IAAID,KAAK,CAACe,OAAO,EAAE;IACjBd,MAAM,OAAyB,GAAGH,sBAAsB,CAAC,SAAS,EAAEE,KAAK,CAACe,OAAO,CAAC;EACpF;EAEA,IAAIf,KAAK,CAACgB,aAAa,EAAE;IACvBf,MAAM,OAA+B,GAAGD,KAAK,CAACgB,aAAa;EAC7D;EACA,OAAOf,MAAM;AACf;AAKA,OAAO,SAASgB,8BAA8BA,CAC5CC,UAA+B,EACV;EACrB,MAAMC,aAAa,GAAG;IAAC,GAAGD;EAAU,CAAC;EACrC,IAAIA,UAAU,OAAuB,SAAe,EAAE;IAEpDC,aAAa,OAAuB,OAAY;EAClD;EAEAA,aAAa,OAAmB,QAAmB;EACnDA,aAAa,OAAmB,QAAmB;EACnD,OAAOA,aAAa;AACtB;AAKA,SAAShB,kBAAkBA,CAACiB,WAAyD,EAAqD;EACxI,QAAQA,WAAW;IACjB,KAAK,eAAe;MAClB;IACF,KAAK,QAAQ;MACX;IACF,KAAK,eAAe;MAClB;EACJ;AACF;AAEA,SAASb,oBAAoBA,CAACc,SAA+B,EAA0B;EACrF,QAAQA,SAAS;IACf,KAAK,SAAS;MACZ;IACF,KAAK,QAAQ;MACX;EACJ;AACF;AAMA,SAASX,oBAAoBA,CAC3BF,SAA+B,EAC/BC,YAAmC,EACiG;EACpI,IAAI,CAACA,YAAY,EAAE;IACjB,OAAOF,oBAAoB,CAACC,SAAS,CAAC;EACxC;EACA,QAAQA,SAAS;IACf,KAAK,SAAS;MACZ,OAAOC,YAAY,KAAK,SAAS,cAAuD;IAC1F,KAAK,QAAQ;MACX,OAAOA,YAAY,KAAK,SAAS,cAAqD;EAC1F;AACF"}

package/dist/adapter/converters/shader-formats.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader-formats.js","names":["getShaderAttributeTypeFromGL","type","components","dataType","getShaderDataTypeFromGL","Error","String","getGLFromShaderDataType"],"sources":["../../../src/adapter/converters/shader-formats.ts"],"sourcesContent":["// luma.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport {GL} from '@luma.gl/constants';\nimport {ShaderAttributeType, ShaderDataType} from '@luma.gl/core';\n\n/** Get shader attribute type from GL constants */\nexport function getShaderAttributeTypeFromGL(type: GL, components: 1 | 2 | 3 | 4): ShaderAttributeType {\n  const dataType = getShaderDataTypeFromGL(type);\n  switch (components) {\n    case 1: return dataType;\n    case 2: return `vec2<${dataType}>`;\n    case 3: return `vec2<${dataType}>`;\n    case 4: return `vec2<${dataType}>`;\n    default: throw new Error(String(components));\n  }\n}\n\n/** Get shader data type from GL constants */\nexport function getShaderDataTypeFromGL(type: GL): ShaderDataType {\n  switch (type) {\n    case GL.INT: return 'i32';\n    case GL.UNSIGNED_INT: return 'u32';\n    case GL.SHORT: return 'i32';\n    case GL.UNSIGNED_SHORT: return 'u32';\n    case GL.BYTE: return 'i32';\n    case GL.UNSIGNED_BYTE: return 'u32';\n    case GL.FLOAT: return 'f32';\n    case GL.HALF_FLOAT: return 'f16';\n    default: throw new Error(String(type));\n  }\n}\n\n/** GetGL constant from shader data type */\nexport function getGLFromShaderDataType(type: ShaderDataType): GL.INT | GL.UNSIGNED_INT | GL.FLOAT | GL.HALF_FLOAT {\n  switch (type) {\n    // TODO\n    case 'i32': return GL.INT;\n    case 'u32': return GL.UNSIGNED_INT;\n    case 'f32': return GL.FLOAT;\n    case 'f16': return GL.HALF_FLOAT;\n    default: throw new Error(String(type));\n  }\n}\n"],"mappings":"AAOA,OAAO,SAASA,4BAA4BA,CAACC,IAAQ,EAAEC,UAAyB,EAAuB;EACrG,MAAMC,QAAQ,GAAGC,uBAAuB,CAACH,IAAI,CAAC;EAC9C,QAAQC,UAAU;IAChB,KAAK,CAAC;MAAE,OAAOC,QAAQ;IACvB,KAAK,CAAC;MAAE,OAAQ,QAAOA,QAAS,GAAE;IAClC,KAAK,CAAC;MAAE,OAAQ,QAAOA,QAAS,GAAE;IAClC,KAAK,CAAC;MAAE,OAAQ,QAAOA,QAAS,GAAE;IAClC;MAAS,MAAM,IAAIE,KAAK,CAACC,MAAM,CAACJ,UAAU,CAAC,CAAC;EAC9C;AACF;AAGA,OAAO,SAASE,uBAAuBA,CAACH,IAAQ,EAAkB;EAChE,QAAQA,IAAI;IACV;MAAa,OAAO,KAAK;IACzB;MAAsB,OAAO,KAAK;IAClC;MAAe,OAAO,KAAK;IAC3B;MAAwB,OAAO,KAAK;IACpC;MAAc,OAAO,KAAK;IAC1B;MAAuB,OAAO,KAAK;IACnC;MAAe,OAAO,KAAK;IAC3B;MAAoB,OAAO,KAAK;IAChC;MAAS,MAAM,IAAII,KAAK,CAACC,MAAM,CAACL,IAAI,CAAC,CAAC;EACxC;AACF;AAGA,OAAO,SAASM,uBAAuBA,CAACN,IAAoB,EAAuD;EACjH,QAAQA,IAAI;IAEV,KAAK,KAAK;MAAE;IACZ,KAAK,KAAK;MAAE;IACZ,KAAK,KAAK;MAAE;IACZ,KAAK,KAAK;MAAE;IACZ;MAAS,MAAM,IAAII,KAAK,CAACC,MAAM,CAACL,IAAI,CAAC,CAAC;EACxC;AACF"}