@luma.gl/webgl 9.0.0-alpha.9 → 9.0.0-beta.10

package/src/adapter/converters/device-parameters.ts

@@ -1,9 +1,55 @@
-import {Device, Parameters, CompareFunction, StencilOperation, log, isObjectEmpty} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import type { GLParameters } from '../../types/webgl';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {
+  Device,
+  Parameters,
+  CompareFunction,
+  StencilOperation,
+  log,
+  isObjectEmpty,
+  BlendOperation,
+  BlendFactor
+} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
+import type {GLBlendEquation, GLBlendFunction, GLParameters} from '@luma.gl/constants';
 import {pushContextState, popContextState} from '../../context/state-tracker/track-context-state';
-import {setParameters} from '../../context/parameters/unified-parameter-api';
-import WebGLDevice from '../webgl-device';
+import {setGLParameters} from '../../context/parameters/unified-parameter-api';
+import {WebGLDevice} from '../webgl-device';
+
+/* eslint-disable no-unused-expressions */ // For expression ? gl.enable() : gl.disable()
+
+/**
+ * Execute a function with a set of temporary WebGL parameter overrides
+ * - Saves current "global" WebGL context settings
+ * - Sets the supplies WebGL context parameters,
+ * - Executes supplied function
+ * - Restores parameters
+ * - Returns the return value of the supplied function
+ */
+export function withDeviceAndGLParameters<T = unknown>(
+  device: Device,
+  parameters: Parameters,
+  glParameters: GLParameters,
+  func: (device?: Device) => T
+): T {
+  if (isObjectEmpty(parameters)) {
+    // Avoid setting state if no parameters provided. Just call and return
+    return func(device);
+  }
+
+  // Wrap in a try-catch to ensure that parameters are restored on exceptions
+  const webglDevice = device as WebGLDevice;
+  pushContextState(webglDevice.gl);
+  try {
+    setDeviceParameters(device, parameters);
+    setGLParameters(webglDevice.gl, glParameters);
+    return func(device);
+  } finally {
+    popContextState(webglDevice.gl);
+  }
+}
 
 /**
  * Execute a function with a set of temporary WebGL parameter overrides
@@ -14,21 +60,24 @@ import WebGLDevice from '../webgl-device';
  * - Returns the return value of the supplied function
  * @deprecated use withDeviceParameters instead
  */
- export function withGLParameters<T = unknown>(device: Device, parameters: GLParameters, func: (device?: Device) => T): T {
+export function withGLParameters<T = unknown>(
+  device: Device,
+  parameters: GLParameters,
+  func: (device?: Device) => T
+): T {
   if (isObjectEmpty(parameters)) {
     // Avoid setting state if no parameters provided. Just call and return
     return func(device);
   }
 
   // Wrap in a try-catch to ensure that parameters are restored on exceptions
-  // @ts-expect-error
-  pushContextState(device.gl);
+  const webglDevice = device as WebGLDevice;
+  pushContextState(webglDevice.gl);
   try {
-    setParameters(device, parameters);
+    setGLParameters(webglDevice.gl, parameters);
     return func(device);
   } finally {
-    // @ts-expect-error
-    popContextState(device.gl);
+    popContextState(webglDevice.gl);
   }
 }
 
@@ -40,7 +89,11 @@ import WebGLDevice from '../webgl-device';
  * - Restores parameters
  * - Returns the return value of the supplied function
  */
-export function withDeviceParameters<T = unknown>(device: Device, parameters: Parameters, func: (device?: Device) => T): T {
+export function withDeviceParameters<T = unknown>(
+  device: Device,
+  parameters: Parameters,
+  func: (device?: Device) => T
+): T {
   if (isObjectEmpty(parameters)) {
     // Avoid setting state if no parameters provided. Just call and return
     return func(device);
@@ -58,11 +111,10 @@ export function withDeviceParameters<T = unknown>(device: Device, parameters: Pa
   }
 }
 
-
 /** Set WebGPU Style Parameters */
 export function setDeviceParameters(device: Device, parameters: Parameters) {
-  const webglDevice = WebGLDevice.attach(device);
-  const {gl, gl2} = webglDevice;
+  const webglDevice = device as WebGLDevice;
+  const {gl} = webglDevice;
 
   // RASTERIZATION SETTINGS
   if (parameters.cullMode) {
@@ -82,10 +134,19 @@ export function setDeviceParameters(device: Device, parameters: Parameters) {
   }
 
   if (parameters.frontFace) {
-    gl.frontFace(map('frontFace', parameters.frontFace, {
-      ccw: GL.CCW,
-      cw: GL.CW
-    }));
+    gl.frontFace(
+      map('frontFace', parameters.frontFace, {
+        ccw: GL.CCW,
+        cw: GL.CW
+      })
+    );
+  }
+
+  if (parameters.unclippedDepth) {
+    if (device.features.has('depth-clip-control')) {
+      // EXT_depth_clamp
+      gl.enable(GL.DEPTH_CLAMP_EXT);
+    }
   }
 
   if (parameters.depthBias !== undefined) {
@@ -96,13 +157,73 @@ export function setDeviceParameters(device: Device, parameters: Parameters) {
   //   // Handled by depthBias
   // },
 
+  // WEBGL EXTENSIONS
+
+  if (device.features.has('provoking-vertex-webgl')) {
+    const extensions = webglDevice.getExtension('WEBGL_provoking_vertex');
+    const ext = extensions.WEBGL_provoking_vertex;
+
+    if (parameters.provokingVertex) {
+      const vertex = map('provokingVertex', parameters.provokingVertex, {
+        first: GL.FIRST_VERTEX_CONVENTION_WEBGL,
+        last: GL.LAST_VERTEX_CONVENTION_WEBGL
+      });
+      ext?.provokingVertexWEBGL(vertex);
+    }
+  }
+
+  if (device.features.has('polygon-mode-webgl')) {
+    const extensions = webglDevice.getExtension('WEBGL_polygon_mode');
+    const ext = extensions.WEBGL_polygon_mode;
+
+    if (parameters.polygonMode) {
+      const mode = map('polygonMode', parameters.provokingVertex, {
+        fill: GL.FILL_WEBGL,
+        lint: GL.LINE_WEBGL
+      });
+      ext?.polygonModeWEBGL(GL.FRONT, mode);
+      ext?.polygonModeWEBGL(GL.BACK, mode);
+    }
+
+    if (parameters.polygonOffsetLine) {
+      gl.enable(GL.POLYGON_OFFSET_LINE_WEBGL);
+    }
+  }
+
+  if (device.features.has('shader-clip-cull-distance-webgl')) {
+    if (parameters.clipDistance0) {
+      gl.enable(GL.CLIP_DISTANCE0_WEBGL);
+    }
+    if (parameters.clipDistance1) {
+      gl.enable(GL.CLIP_DISTANCE1_WEBGL);
+    }
+    if (parameters.clipDistance2) {
+      gl.enable(GL.CLIP_DISTANCE2_WEBGL);
+    }
+    if (parameters.clipDistance3) {
+      gl.enable(GL.CLIP_DISTANCE3_WEBGL);
+    }
+    if (parameters.clipDistance4) {
+      gl.enable(GL.CLIP_DISTANCE4_WEBGL);
+    }
+    if (parameters.clipDistance5) {
+      gl.enable(GL.CLIP_DISTANCE5_WEBGL);
+    }
+    if (parameters.clipDistance6) {
+      gl.enable(GL.CLIP_DISTANCE6_WEBGL);
+    }
+    if (parameters.clipDistance7) {
+      gl.enable(GL.CLIP_DISTANCE7_WEBGL);
+    }
+  }
+
   // DEPTH STENCIL
 
   if (parameters.depthWriteEnabled !== undefined) {
     gl.depthMask(mapBoolean('depthWriteEnabled', parameters.depthWriteEnabled));
   }
 
- if (parameters.depthCompare) {
+  if (parameters.depthCompare) {
     parameters.depthCompare !== 'always' ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST);
     gl.depthFunc(convertCompareFunction('depthCompare', parameters.depthCompare));
   }
@@ -122,15 +243,24 @@ export function setDeviceParameters(device: Device, parameters: Parameters) {
     const mask = parameters.stencilReadMask || 0xffffffff;
     const glValue = convertCompareFunction('depthCompare', parameters.stencilCompare);
     // TODO - ensure back doesn't overwrite
-    parameters.stencilCompare !== 'always' ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST);
+    parameters.stencilCompare !== 'always'
+      ? gl.enable(GL.STENCIL_TEST)
+      : gl.disable(GL.STENCIL_TEST);
     gl.stencilFuncSeparate(GL.FRONT, glValue, 0, mask);
     gl.stencilFuncSeparate(GL.BACK, glValue, 0, mask);
   }
 
-  if (parameters.stencilPassOperation && parameters.stencilFailOperation && parameters.stencilDepthFailOperation) {
+  if (
+    parameters.stencilPassOperation &&
+    parameters.stencilFailOperation &&
+    parameters.stencilDepthFailOperation
+  ) {
     const dppass = convertStencilOperation('stencilPassOperation', parameters.stencilPassOperation);
     const sfail = convertStencilOperation('stencilFailOperation', parameters.stencilFailOperation);
-    const dpfail = convertStencilOperation('stencilDepthFailOperation', parameters.stencilDepthFailOperation);
+    const dpfail = convertStencilOperation(
+      'stencilDepthFailOperation',
+      parameters.stencilDepthFailOperation
+    );
     gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
     gl.stencilOpSeparate(GL.BACK, sfail, dpfail, dppass);
   }
@@ -145,21 +275,37 @@ export function setDeviceParameters(device: Device, parameters: Parameters) {
 
   // COLOR STATE
 
-  // if (parameters.blend) {
-  //   gl.enable(GL.BLEND);
-
-  //   const blend = parameters.blend;
-
-  //   let colorEquation = (blend && blend.color && blend.color.operation) || 'add';
-  //   let alphaEquation = (blend && blend.alpha && blend.alpha.operation) || 'add';
-  //   gl.blendEquationSeparate(colorEquation, alphaEquation);
-
-  //   let colorSrcFactor = (blend && blend.color && blend.color.srcFactor) || 'one';
-  //   let colorDstFactor = (blend && blend.color && blend.color.dstFactor) || 'zero';
-  //   let alphaSrcFactor = (blend && blend.alpha && blend.alpha.srcFactor) || 'one';
-  //   let alphaDstFactor = (blend && blend.alpha && blend.alpha.dstFactor) || 'zero';
-  //   gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);
-  // }
+  if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
+    gl.enable(GL.BLEND);
+
+    const colorEquation = convertBlendOperationToEquation(
+      'blendColorOperation',
+      parameters.blendColorOperation || 'add'
+    );
+    const alphaEquation = convertBlendOperationToEquation(
+      'blendAlphaOperation',
+      parameters.blendAlphaOperation || 'add'
+    );
+    gl.blendEquationSeparate(colorEquation, alphaEquation);
+
+    const colorSrcFactor = convertBlendFactorToFunction(
+      'blendColorSrcFactor',
+      parameters.blendColorSrcFactor || 'one'
+    );
+    const colorDstFactor = convertBlendFactorToFunction(
+      'blendColorDstFactor',
+      parameters.blendColorDstFactor || 'zero'
+    );
+    const alphaSrcFactor = convertBlendFactorToFunction(
+      'blendAlphaSrcFactor',
+      parameters.blendAlphaSrcFactor || 'one'
+    );
+    const alphaDstFactor = convertBlendFactorToFunction(
+      'blendAlphaDstFactor',
+      parameters.blendAlphaDstFactor || 'zero'
+    );
+    gl.blendFuncSeparate(colorSrcFactor, colorDstFactor, alphaSrcFactor, alphaDstFactor);
+  }
 }
 
 /*
@@ -187,14 +333,14 @@ export function setDeviceParameters(device: Device, parameters: Parameters) {
 
 export function convertCompareFunction(parameter: string, value: CompareFunction): GL {
   return map(parameter, value, {
-    'never': GL.NEVER,
-    'less': GL.LESS,
-    'equal': GL.EQUAL,
+    never: GL.NEVER,
+    less: GL.LESS,
+    equal: GL.EQUAL,
     'less-equal': GL.LEQUAL,
-    'greater': GL.GREATER,
+    greater: GL.GREATER,
     'not-equal': GL.NOTEQUAL,
     'greater-equal': GL.GEQUAL,
-    'always': GL.ALWAYS
+    always: GL.ALWAYS
   });
 }
 
@@ -213,10 +359,10 @@ export function convertToCompareFunction(parameter: string, value: GL): CompareF
 
 function convertStencilOperation(parameter: string, value: StencilOperation): GL {
   return map(parameter, value, {
-    'keep': GL.KEEP,
-    'zero': GL.ZERO,
-    'replace': GL.REPLACE,
-    'invert': GL.INVERT,
+    keep: GL.KEEP,
+    zero: GL.ZERO,
+    replace: GL.REPLACE,
+    invert: GL.INVERT,
     'increment-clamp': GL.INCR,
     'decrement-clamp': GL.DECR,
     'increment-wrap': GL.INCR_WRAP,
@@ -224,15 +370,32 @@ function convertStencilOperation(parameter: string, value: StencilOperation): GL
   });
 }
 
-function convertBlendOperationToEquation(parameter: string, value: string): number {
+function convertBlendOperationToEquation(
+  parameter: string,
+  value: BlendOperation
+): GLBlendEquation {
   return map(parameter, value, {
-    'add': GL.FUNC_ADD,
-    'sub': GL.FUNC_SUBTRACT,
+    add: GL.FUNC_ADD,
+    subtract: GL.FUNC_SUBTRACT,
     'reverse-subtract': GL.FUNC_REVERSE_SUBTRACT,
-    // When using a WebGL 2 context, the following values are available additionally:
-    'min': GL.MIN,
-    'max': GL.MAX
-  });
+    min: GL.MIN,
+    max: GL.MAX
+  } as Record<BlendOperation, GLBlendEquation>);
+}
+
+function convertBlendFactorToFunction(parameter: string, value: BlendFactor): GLBlendFunction {
+  return map(parameter, value, {
+    one: GL.ONE,
+    zero: GL.ZERO,
+    'src-color': GL.SRC_COLOR,
+    'one-minus-src-color': GL.ONE_MINUS_SRC_COLOR,
+    'dst-color': GL.DST_COLOR,
+    'one-minus-dst-color': GL.ONE_MINUS_DST_COLOR,
+    'src-alpha': GL.SRC_ALPHA,
+    'one-minus-src-alpha': GL.ONE_MINUS_SRC_ALPHA,
+    'dst-alpha': GL.DST_ALPHA,
+    'one-minus-dst-alpha': GL.ONE_MINUS_DST_ALPHA
+  } as Record<BlendFactor, GLBlendFunction>);
 }
 
 function message(parameter: string, value: any): string {

package/src/adapter/converters/sampler-parameters.ts

@@ -1,16 +1,19 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // SAMPLER FILTERS
-import {SamplerParameters} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import {GLSamplerParameters} from '../../types/webgl';
-import {convertCompareFunction, convertToCompareFunction} from './device-parameters';
+import {SamplerProps} from '@luma.gl/core';
+import {GL, GLSamplerParameters} from '@luma.gl/constants';
+import {convertCompareFunction} from './device-parameters';
 
 /**
  * Convert WebGPU-style sampler props to WebGL
  * @param props
  * @returns
  */
-export function convertSamplerParametersToWebGL(props: SamplerParameters): GLSamplerParameters {
-  const params: Record<number, number> = {};
+export function convertSamplerParametersToWebGL(props: SamplerProps): GLSamplerParameters {
+  const params: GLSamplerParameters = {};
   if (props.addressModeU) {
     params[GL.TEXTURE_WRAP_S] = convertAddressMode(props.addressModeU);
   }
@@ -25,7 +28,10 @@ export function convertSamplerParametersToWebGL(props: SamplerParameters): GLSam
   }
   if (props.minFilter || props.mipmapFilter) {
     // TODO - arbitrary choice of linear?
-    params[GL.TEXTURE_MIN_FILTER] = convertMinFilterMode(props.minFilter || 'linear', props.mipmapFilter);
+    params[GL.TEXTURE_MIN_FILTER] = convertMinFilterMode(
+      props.minFilter || 'linear',
+      props.mipmapFilter
+    );
   }
   if (props.lodMinClamp !== undefined) {
     params[GL.TEXTURE_MIN_LOD] = props.lodMinClamp;
@@ -38,7 +44,7 @@ export function convertSamplerParametersToWebGL(props: SamplerParameters): GLSam
     params[GL.TEXTURE_COMPARE_MODE] = GL.COMPARE_REF_TO_TEXTURE;
   }
   if (props.compare) {
-      params[GL.TEXTURE_COMPARE_FUNC] = convertCompareFunction('compare', props.compare);
+    params[GL.TEXTURE_COMPARE_FUNC] = convertCompareFunction('compare', props.compare);
   }
   // Note depends on WebGL extension
   if (props.maxAnisotropy) {
@@ -47,138 +53,52 @@ export function convertSamplerParametersToWebGL(props: SamplerParameters): GLSam
   return params;
 }
 
+// HELPERS
+
 /** Convert address more */
-function convertAddressMode(addressMode: 'clamp-to-edge' | 'repeat' | 'mirror-repeat'): GL {
+function convertAddressMode(
+  addressMode: 'clamp-to-edge' | 'repeat' | 'mirror-repeat'
+): GL.CLAMP_TO_EDGE | GL.REPEAT | GL.MIRRORED_REPEAT {
   switch (addressMode) {
-    case 'clamp-to-edge': return GL.CLAMP_TO_EDGE;
-    case 'repeat': return GL.REPEAT;
-    case 'mirror-repeat': return GL.MIRRORED_REPEAT;
+    case 'clamp-to-edge':
+      return GL.CLAMP_TO_EDGE;
+    case 'repeat':
+      return GL.REPEAT;
+    case 'mirror-repeat':
+      return GL.MIRRORED_REPEAT;
   }
 }
 
-function convertMaxFilterMode(maxFilter: 'nearest' | 'linear'): GL {
+function convertMaxFilterMode(maxFilter: 'nearest' | 'linear'): GL.NEAREST | GL.LINEAR {
   switch (maxFilter) {
-    case 'nearest': return GL.NEAREST;
-    case 'linear': return GL.LINEAR;
+    case 'nearest':
+      return GL.NEAREST;
+    case 'linear':
+      return GL.LINEAR;
   }
 }
 
-/** 
- * WebGPU has separate min filter and mipmap filter, 
+/**
+ * WebGPU has separate min filter and mipmap filter,
  * WebGL is combined and effectively offers 6 options
  */
-function convertMinFilterMode(minFilter: 'nearest' | 'linear', mipmapFilter?: 'nearest' | 'linear'): GL {
+function convertMinFilterMode(
+  minFilter: 'nearest' | 'linear',
+  mipmapFilter?: 'nearest' | 'linear'
+):
+  | GL.NEAREST
+  | GL.LINEAR
+  | GL.NEAREST_MIPMAP_NEAREST
+  | GL.LINEAR_MIPMAP_NEAREST
+  | GL.NEAREST_MIPMAP_LINEAR
+  | GL.LINEAR_MIPMAP_LINEAR {
   if (!mipmapFilter) {
     return convertMaxFilterMode(minFilter);
   }
   switch (minFilter) {
-    case 'nearest': return mipmapFilter === 'nearest' ? GL.NEAREST_MIPMAP_NEAREST : GL.NEAREST_MIPMAP_LINEAR;
-    case 'linear': return mipmapFilter === 'nearest' ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR_MIPMAP_LINEAR;
-  }
-}
-
-// Convert from WebGL to WebGPU
-
-/**
- * Convert WebGL-style sampler props to WebGPU
- * @param props
- * @returns
- */
- export function convertToSamplerParameters(params: GLSamplerParameters): SamplerParameters {
-  const props: SamplerParameters = {};
-  if (params[GL.TEXTURE_WRAP_S]) {
-    props.addressModeU = convertToAddressMode(params[GL.TEXTURE_WRAP_S]);
-  }
-  if (params[GL.TEXTURE_WRAP_T]) {
-    props.addressModeV = convertToAddressMode(params[GL.TEXTURE_WRAP_T]);
-  }
-  if (params[GL.TEXTURE_WRAP_R]) {
-    props.addressModeW = convertToAddressMode(params[GL.TEXTURE_WRAP_R]);
-  }
-  if (params[GL.TEXTURE_MAG_FILTER]) {
-    props.magFilter = convertToMaxFilterMode(params[GL.TEXTURE_MAG_FILTER]);
-  }
-  if (params[GL.TEXTURE_MIN_FILTER]) {
-    props.minFilter = convertToMinFilterMode(params[GL.TEXTURE_MIN_FILTER]);
-  }
-  if (params[GL.TEXTURE_MIN_FILTER]) {
-    props.mipmapFilter = convertToMipmapFilterMode(params[GL.TEXTURE_MIN_FILTER]);
-  }
-  if (params[GL.TEXTURE_MIN_LOD]) {
-    props.lodMinClamp = params[GL.TEXTURE_MIN_LOD];
-  }
-  if (params[GL.TEXTURE_MAX_LOD]) {
-    props.lodMaxClamp = params[GL.TEXTURE_MAX_LOD];
-  }
-  if (params[GL.TEXTURE_COMPARE_MODE]) {
-    props.type = params[GL.TEXTURE_COMPARE_MODE]  === GL.COMPARE_REF_TO_TEXTURE ? 'comparison-sampler' : 'color-sampler';
-  }
-  if (params[GL.TEXTURE_COMPARE_FUNC]) {
-    props.compare = convertToCompareFunction('compare', params[GL.TEXTURE_COMPARE_FUNC]);
-  }
-  // NOTE depends on extension (very common)
-  if (params[GL.TEXTURE_MAX_ANISOTROPY_EXT]) {
-    props.maxAnisotropy = params[GL.TEXTURE_MAX_ANISOTROPY_EXT];
-  }
-  return props;
-}
-
-/** Convert address more */
-function convertToAddressMode(addressMode: number): 'clamp-to-edge' | 'repeat' | 'mirror-repeat' {
-  switch (addressMode) {
-    case GL.CLAMP_TO_EDGE: return 'clamp-to-edge';
-    case GL.REPEAT: return 'repeat';
-    case GL.MIRRORED_REPEAT: return 'mirror-repeat';
-    default: throw new Error('address');
-  }
-}
-
-function convertToMaxFilterMode(filterMode: number): 'nearest' | 'linear' {
-  switch (filterMode) {
-    case GL.NEAREST: return 'nearest';
-    case GL.LINEAR: return 'linear';
-    default: throw new Error('maxfilter');
-  }
-}
-
-/** WebGPU has separate min filter and mipmap filter, WebGL is combined */
-function convertToMinFilterMode(filterMode: number): 'nearest' | 'linear' {
-  switch (filterMode) {
-    // TODO is this correct?
-    case GL.NEAREST: return 'nearest';
-    case GL.LINEAR: return 'linear';
-    case GL.NEAREST_MIPMAP_NEAREST: return 'nearest';
-    case GL.LINEAR_MIPMAP_NEAREST: return 'linear';
-    case GL.NEAREST_MIPMAP_LINEAR: return 'nearest';
-    case GL.LINEAR_MIPMAP_LINEAR: return 'linear';
-    default: throw new Error('minfilter');
-  }
-}
-
-function convertToMipmapFilterMode(filterMode: number): 'nearest' | 'linear' {
-  switch (filterMode) {
-    // TODO is this correct?
-    case GL.NEAREST: return 'nearest';
-    case GL.LINEAR: return 'linear';
-    case GL.NEAREST_MIPMAP_NEAREST: return 'nearest';
-    case GL.LINEAR_MIPMAP_NEAREST: return 'nearest';
-    case GL.NEAREST_MIPMAP_LINEAR: return 'linear';
-    case GL.LINEAR_MIPMAP_LINEAR: return 'linear';
-    default: throw new Error('mipmap');
-  }
-}
-
-/**
- * Override sampler settings that are not supported by Non-Power-of-Two textures in WebGL1.
-*/
-export function updateSamplerParametersForNPOT(parameters: GLSamplerParameters): GLSamplerParameters {
-  const newParameters = {...parameters};
-  if (parameters[GL.TEXTURE_MIN_FILTER] !== GL.NEAREST) {
-    // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_MIN_FILTER to LINEAR`)();
-    newParameters[GL.TEXTURE_MIN_FILTER] = GL.LINEAR;
+    case 'nearest':
+      return mipmapFilter === 'nearest' ? GL.NEAREST_MIPMAP_NEAREST : GL.NEAREST_MIPMAP_LINEAR;
+    case 'linear':
+      return mipmapFilter === 'nearest' ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR_MIPMAP_LINEAR;
   }
-  // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_WRAP_S to CLAMP_TO_EDGE`)();
-  newParameters[GL.TEXTURE_WRAP_S] = GL.CLAMP_TO_EDGE;
-  newParameters[GL.TEXTURE_WRAP_T] = GL.CLAMP_TO_EDGE;
-  return newParameters;
 }

package/src/adapter/converters/shader-formats.ts

@@ -0,0 +1,69 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {GL} from '@luma.gl/constants';
+import {ShaderAttributeType, ShaderDataType} from '@luma.gl/core';
+
+/** Get shader attribute type from GL constants */
+export function getShaderAttributeTypeFromGL(
+  type: GL,
+  components: 1 | 2 | 3 | 4
+): ShaderAttributeType {
+  const dataType = getShaderDataTypeFromGL(type);
+  switch (components) {
+    case 1:
+      return dataType;
+    case 2:
+      return `vec2<${dataType}>`;
+    case 3:
+      return `vec2<${dataType}>`;
+    case 4:
+      return `vec2<${dataType}>`;
+    default:
+      throw new Error(String(components));
+  }
+}
+
+/** Get shader data type from GL constants */
+export function getShaderDataTypeFromGL(type: GL): ShaderDataType {
+  switch (type) {
+    case GL.INT:
+      return 'i32';
+    case GL.UNSIGNED_INT:
+      return 'u32';
+    case GL.SHORT:
+      return 'i32';
+    case GL.UNSIGNED_SHORT:
+      return 'u32';
+    case GL.BYTE:
+      return 'i32';
+    case GL.UNSIGNED_BYTE:
+      return 'u32';
+    case GL.FLOAT:
+      return 'f32';
+    case GL.HALF_FLOAT:
+      return 'f16';
+    default:
+      throw new Error(String(type));
+  }
+}
+
+/** GetGL constant from shader data type */
+export function getGLFromShaderDataType(
+  type: ShaderDataType
+): GL.INT | GL.UNSIGNED_INT | GL.FLOAT | GL.HALF_FLOAT {
+  switch (type) {
+    // TODO
+    case 'i32':
+      return GL.INT;
+    case 'u32':
+      return GL.UNSIGNED_INT;
+    case 'f32':
+      return GL.FLOAT;
+    case 'f16':
+      return GL.HALF_FLOAT;
+    default:
+      throw new Error(String(type));
+  }
+}