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

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@luma.gl/webgl",
-  "version": "9.0.0-alpha.9",
+  "version": "9.0.0-beta.2",
   "description": "WebGL2 adapter for the luma.gl API",
+  "type": "module",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -16,12 +17,20 @@
     "animation",
     "3d"
   ],
-  "types": "src/index.ts",
-  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.cjs",
   "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
   "files": [
     "src",
     "dist",
+    "dist.min.js",
     "README.md"
   ],
   "sideEffects": false,
@@ -30,14 +39,17 @@
     "gl/wrap": false
   },
   "scripts": {
-    "pre-build": "npm run build-bundle",
-    "build-bundle": "webpack --display=minimal --config ../../scripts/bundle.config.js"
+    "build-bundle": "ocular-bundle ./src/index.ts",
+    "pre-build": "npm run build-bundle && npm run build-bundle -- --env=dev"
   },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "@luma.gl/api": "9.0.0-alpha.9",
-    "@luma.gl/constants": "9.0.0-alpha.9",
-    "@probe.gl/env": "^3.5.0"
+    "@luma.gl/constants": "9.0.0-beta.2",
+    "@luma.gl/core": "9.0.0-beta.2",
+    "@probe.gl/env": "^4.0.2"
+  },
+  "devDependencies": {
+    "@luma.gl/test-utils": "9.0.0-beta.2"
   },
-  "gitHead": "b84aae16edcdee2be84d2861c81cc6584e336b28"
+  "gitHead": "d90ddd6231c3d405d88dfb9e8c232c4dfefcc056"
 }

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, MIT license
+// 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
+  // @ts-expect-error
+  pushContextState(device.gl);
+  try {
+    setDeviceParameters(device, parameters);
+    setGLParameters(device, glParameters);
+    return func(device);
+  } finally {
+    // @ts-expect-error
+    popContextState(device.gl);
+  }
+}
 
 /**
  * Execute a function with a set of temporary WebGL parameter overrides
@@ -14,7 +60,11 @@ 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);
@@ -24,7 +74,7 @@ import WebGLDevice from '../webgl-device';
   // @ts-expect-error
   pushContextState(device.gl);
   try {
-    setParameters(device, parameters);
+    setGLParameters(device, parameters);
     return func(device);
   } finally {
     // @ts-expect-error
@@ -40,7 +90,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 +112,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 {gl} = webglDevice;
 
   // RASTERIZATION SETTINGS
   if (parameters.cullMode) {
@@ -82,10 +135,12 @@ 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.depthBias !== undefined) {
@@ -102,7 +157,7 @@ export function setDeviceParameters(device: Device, parameters: Parameters) {
     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 +177,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 +209,19 @@ export function setDeviceParameters(device: Device, parameters: Parameters) {
 
   // COLOR STATE
 
-  // if (parameters.blend) {
-  //   gl.enable(GL.BLEND);
+  if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
+    gl.enable(GL.BLEND);
 
-  //   const blend = parameters.blend;
+    const colorEquation = convertBlendOperationToEquation('blendColorOperation', parameters.blendColorOperation || 'add');
+    const alphaEquation = convertBlendOperationToEquation('blendAlphaOperation', parameters.blendAlphaOperation || 'add');
+    gl.blendEquationSeparate(colorEquation, alphaEquation);
 
-  //   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);
-  // }
+    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 +249,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 +275,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 +286,30 @@ 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,
+    '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
-  });
+  } 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,18 @@
+// luma.gl, MIT license
+// 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 +27,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 +43,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 +52,61 @@ export function convertSamplerParametersToWebGL(props: SamplerParameters): GLSam
   return params;
 }
 
+/**
+ * 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;
+  }
+  // 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;
+}
+
+// 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];
+    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;
   }
-  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;
-  }
-  // 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,44 @@
+// luma.gl, MIT license
+// 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));
+  }
+}