@luma.gl/webgl 9.0.0-alpha.4 → 9.0.0-alpha.41

package/src/adapter/resources/webgl-render-pipeline.ts

@@ -1,56 +1,59 @@
-import type {
-  RenderPipelineProps,
-  RenderPipelineParameters,
-  RenderPass,
-  Buffer,
-  Binding,
-  ShaderLayout,
-  PrimitiveTopology,
-  BindingLayout,
-  AttributeLayout
-} from '@luma.gl/api';
-import {RenderPipeline, cast, log, decodeVertexFormat} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import {getWebGLDataType} from '../converters/texture-formats';
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {UniformValue, RenderPipelineProps, Binding} from '@luma.gl/core';
+import type {ShaderLayout, PrimitiveTopology} from '@luma.gl/core';
+import type {RenderPass, VertexArray} from '@luma.gl/core';
+import {RenderPipeline, cast, log} from '@luma.gl/core';
+import {mergeShaderLayout} from '@luma.gl/core';
+// import {mergeShaderLayout, getAttributeInfosFromLayouts} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
+
 import {getShaderLayout} from '../helpers/get-shader-layout';
-import {withDeviceParameters} from '../converters/device-parameters';
+import {withDeviceAndGLParameters} from '../converters/device-parameters';
 import {setUniform} from '../helpers/set-uniform';
 // import {copyUniform, checkUniformValues} from '../../classes/uniforms';
 
-import WebGLDevice from '../webgl-device';
-import WEBGLBuffer from './webgl-buffer';
-import WEBGLShader from './webgl-shader';
-import WEBGLTexture from './webgl-texture';
-import WEBGLVertexArrayObject from '../objects/webgl-vertex-array-object';
+import {WebGLDevice} from '../webgl-device';
+import {WEBGLBuffer} from './webgl-buffer';
+import {WEBGLShader} from './webgl-shader';
+import {WEBGLFramebuffer} from './webgl-framebuffer';
+import {WEBGLTexture} from './webgl-texture';
+// import {WEBGLVertexArray} from './webgl-vertex-array';
+import {WEBGLRenderPass} from './webgl-render-pass';
 
 const LOG_PROGRAM_PERF_PRIORITY = 4;
 
 /** Creates a new render pipeline */
-export default class WEBGLRenderPipeline extends RenderPipeline {
+export class WEBGLRenderPipeline extends RenderPipeline {
+  /** The WebGL device that created this render pipeline */
   device: WebGLDevice;
+  /** Handle to underlying WebGL program */
   handle: WebGLProgram;
+  /** vertex shader */
   vs: WEBGLShader;
+  /** fragment shader */
   fs: WEBGLShader;
-  layout: ShaderLayout;
-
-  // configuration: ProgramConfiguration;
-  // Experimental flag to avoid deleting Program object while it is cached
-  varyings: string[];
-  vertexArrayObject: WEBGLVertexArrayObject;
-  _indexBuffer?: Buffer;
-  uniforms: Record<string, any> = {};
-  bindings: Record<string, any> = {};
+  /** The layout extracted from shader by WebGL introspection APIs */
+  introspectedLayout: ShaderLayout;
+
+  /** Uniforms set on this model */
+  uniforms: Record<string, UniformValue> = {};
+  /** Bindings set on this model */
+  bindings: Record<string, Binding> = {};
+  /** WebGL varyings */
+  varyings: string[] | null = null;
+
   _textureUniforms: Record<string, any> = {};
   _textureIndexCounter: number = 0;
   _uniformCount: number = 0;
-  _uniformSetters: Record<string, Function>;
+  _uniformSetters: Record<string, Function> = {}; // TODO are these used?
 
   constructor(device: WebGLDevice, props: RenderPipelineProps) {
     super(device, props);
     this.device = device;
     this.handle = this.props.handle || this.device.gl.createProgram();
-    // @ts-expect-error
-    this.handle.__SPECTOR_Metadata = {id: this.props.id};
+    this.device.setSpectorMetadata(this.handle, {id: this.props.id});
 
     // Create shaders if needed
     this.vs = cast<WEBGLShader>(props.vs);
@@ -64,66 +67,82 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
     if (varyings && varyings.length > 0) {
       this.device.assertWebGL2();
       this.varyings = varyings;
-      this.device.gl2.transformFeedbackVaryings(this.handle, varyings, bufferMode);
+      this.device.gl2?.transformFeedbackVaryings(this.handle, varyings, bufferMode);
     }
 
     this._compileAndLink();
 
-    this.layout = props.layout || getShaderLayout(this.device.gl, this.handle);
-    this.vertexArrayObject = new WEBGLVertexArrayObject(this.device);
+    this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
+    // Merge provided layout with introspected layout
+    this.shaderLayout = mergeShaderLayout(this.introspectedLayout, props.shaderLayout);
+    // Merge layout with any buffer map overrides
+    // this.bufferLayout = props.bufferLayout || [];
+    // this.shaderLayout = mergeBufferMap(this.shaderLayout, this.bufferLayout);
   }
 
-  destroy(): void {
+  override destroy(): void {
     if (this.handle) {
       this.device.gl.deleteProgram(this.handle);
-      this.handle = null;
+      // this.handle = null;
+      this.destroyed = true;
     }
   }
 
-  setIndexBuffer(indexBuffer: Buffer): void {
-    const webglBuffer = cast<WEBGLBuffer>(indexBuffer);
-    this.vertexArrayObject.setElementBuffer(webglBuffer);
-    this._indexBuffer = indexBuffer;
-  }
+  // setIndexBuffer(indexBuffer: Buffer): void {
+  //   const webglBuffer = cast<WEBGLBuffer>(indexBuffer);
+  //   this.vertexArrayObject.setElementBuffer(webglBuffer);
+  //   this._indexBuffer = indexBuffer;
+  // }
+
+  // /** @todo needed for portable model */
+  // setAttributes(attributes: Record<string, Buffer>): void {
+  //   for (const [name, buffer] of Object.entries(attributes)) {
+  //     const webglBuffer = cast<WEBGLBuffer>(buffer);
+  //     const attribute = getAttributeLayout(this.layout, name);
+  //     if (!attribute) {
+  //       log.warn(
+  //         `Ignoring buffer supplied for unknown attribute "${name}" in pipeline "${this.id}" (buffer "${buffer.id}")`
+  //       )();
+  //       continue;
+  //     }
+  //     const decoded = decodeVertexFormat(attribute.format);
+  //     const {type: typeString, components: size, byteLength: stride, normalized, integer} = decoded;
+  //     const divisor = attribute.stepMode === 'instance' ? 1 : 0;
+  //     const type = getWebGLDataType(typeString);
+  //     this.vertexArrayObject.setBuffer(attribute.location, webglBuffer, {
+  //       size,
+  //       type,
+  //       stride,
+  //       offset: 0,
+  //       normalized,
+  //       integer,
+  //       divisor
+  //     });
+  //   }
+  // }
 
-  /** @todo needed for portable model */
-  setAttributes(attributes: Record<string, Buffer>): void {
-    for (const [name, buffer] of Object.entries(attributes)) {
-      const webglBuffer = cast<WEBGLBuffer>(buffer);
-      const attribute = getAttributeLayout(this.layout, name);
-      if (!attribute) {
-        log.warn(`Ignoring buffer supplied for unknown attribute "${name}" in pipeline "${this.id}" (buffer "${buffer.id}")`)();
-        continue;
-      }
-      const decoded = decodeVertexFormat(attribute.format);
-      const {type: typeString, components: size, byteLength: stride, normalized, integer} = decoded;
-      const divisor = attribute.stepMode === 'instance' ? 1 : 0;
-      const type = getWebGLDataType(typeString);
-      this.vertexArrayObject.setBuffer(attribute.location, webglBuffer, {
-        size,
-        type,
-        stride,
-        offset: 0,
-        normalized,
-        integer,
-        divisor: attribute.stepMode === 'instance' ? 1 : 0
-      });
-    }
-  }
-
-  /** @todo needed for portable model */
+  /**
+   * Bindings include: textures, samplers and uniform buffers
+   * @todo needed for portable model
+   */
   setBindings(bindings: Record<string, Binding>): void {
     // if (log.priority >= 2) {
     //   checkUniformValues(uniforms, this.id, this._uniformSetters);
     // }
 
     for (const [name, value] of Object.entries(bindings)) {
-      const binding = this.layout.bindings.find((binding) => binding.name === name);
+      const binding = this.shaderLayout.bindings.find(binding => binding.name === name);
       if (!binding) {
-        log.warn(`Unknown binding ${name} in render pipeline ${this.id}`)();
+        const validBindings = this.shaderLayout.bindings
+          .map(binding => `"${binding.name}"`)
+          .join(', ');
+        log.warn(
+          `Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`
+        )();
+        continue; // eslint-disable-line no-continue
       }
       if (!value) {
-        log.warn(`Unsetting binding ${name} in render pipeline ${this.id}`)();
+        log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
       }
       switch (binding.type) {
         case 'uniform':
@@ -133,7 +152,7 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
           }
           break;
         case 'texture':
-          if (!(value instanceof WEBGLTexture)) {
+          if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
             throw new Error('texture value');
           }
           break;
@@ -148,7 +167,7 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
     }
   }
 
-  setUniforms(uniforms: Record<string, any>) {
+  setUniforms(uniforms: Record<string, UniformValue>) {
     // TODO - check against layout
     Object.assign(this.uniforms, uniforms);
   }
@@ -158,7 +177,9 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
    * This function unifies those ways into a single call using common parameters with sane defaults
    */
   draw(options: {
-    renderPass?: RenderPass;
+    renderPass: RenderPass;
+    /** vertex attributes */
+    vertexArray: VertexArray;
     vertexCount?: number;
     indexCount?: number;
     instanceCount?: number;
@@ -168,72 +189,109 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
     baseVertex?: number;
   }): boolean {
     const {
-      renderPass = this.device.getDefaultRenderPass(),
+      renderPass,
+      vertexArray,
       vertexCount,
-      indexCount,
+      // indexCount,
       instanceCount,
-      firstVertex = 0,
-      firstIndex,
-      firstInstance,
-      baseVertex
+      firstVertex = 0
+      // firstIndex,
+      // firstInstance,
+      // baseVertex
     } = options;
 
-    const drawMode = getDrawMode(this.props.topology);
-    const isIndexed: boolean = Boolean(this._indexBuffer);
-    const indexType = this._indexBuffer?.props.indexType === 'uint16' ? GL.UNSIGNED_SHORT : GL.UNSIGNED_INT;
-    const isInstanced: boolean = options.instanceCount > 0;
+    const glDrawMode = getGLDrawMode(this.props.topology);
+    const isIndexed: boolean = Boolean(vertexArray.indexBuffer);
+    const glIndexType = (vertexArray.indexBuffer as WEBGLBuffer)?.glIndexType;
+    const isInstanced: boolean = Number(instanceCount) > 0;
 
     // Avoid WebGL draw call when not rendering any data or values are incomplete
     // Note: async textures set as uniforms might still be loading.
     // Now that all uniforms have been updated, check if any texture
     // in the uniforms is not yet initialized, then we don't draw
-    if (!this._areTexturesRenderable() || options.vertexCount === 0) {
+    if (!this._areTexturesRenderable() || vertexCount === 0) {
       // (isInstanced && instanceCount === 0)
       return false;
     }
 
     this.device.gl.useProgram(this.handle);
 
-    this.vertexArrayObject.bind(() => {
-      const parameters = {...this.props.parameters, framebuffer: renderPass.props.framebuffer};
-
-      const primitiveMode = getGLPrimitive(this.props.topology);
-      const transformFeedback: any = null;
-      if (transformFeedback) {
-        transformFeedback.begin(primitiveMode);
-      }
+    // Note: Rebinds constant attributes before each draw call
+    vertexArray.bindBeforeRender(renderPass);
 
-      // We have to apply bindings before every draw call since other draw calls will overwrite
-      this._applyBindings();
-      this._applyUniforms();
+    const primitiveMode = getGLPrimitive(this.props.topology);
+    const transformFeedback: any = null;
+    if (transformFeedback) {
+      transformFeedback.begin(primitiveMode);
+    }
 
-      // TODO - double context push/pop
-      withDeviceParameters(this.device, parameters, () => {
-        // TODO - Use polyfilled WebGL2RenderingContext instead of ANGLE extension
+    // We have to apply bindings before every draw call since other draw calls will overwrite
+    this._applyBindings();
+    this._applyUniforms();
+
+    const webglRenderPass = renderPass as WEBGLRenderPass;
+    //     // TODO - Use polyfilled WebGL2RenderingContext instead of ANGLE extension
+    //     if (isIndexed && isInstanced) {
+    //       // ANGLE_instanced_arrays extension
+    //       this.device.gl2?.drawElementsInstanced(
+    //         drawMode,
+    //         vertexCount || 0, // indexCount?
+    //         indexType,
+    //         firstVertex,
+    //         instanceCount || 0
+    //       );
+    //       // } else if (isIndexed && this.device.isWebGL2 && !isNaN(start) && !isNaN(end)) {
+    //       //   this.device.gl2.drawRangeElements(drawMode, start, end, vertexCount, indexType, offset);
+    //     } else if (isIndexed) {
+    //       this.device.gl.drawElements(drawMode, vertexCount || 0, indexType, firstVertex); // indexCount?
+    //     } else if (isInstanced) {
+    //       this.device.gl2?.drawArraysInstanced(
+    //         drawMode,
+    //         firstVertex,
+    //         vertexCount || 0,
+    //         instanceCount || 0
+    //       );
+    //     } else {
+    //       this.device.gl.drawArrays(drawMode, firstVertex, vertexCount || 0);
+    //     }
+    //   });
+
+    withDeviceAndGLParameters(
+      this.device,
+      this.props.parameters,
+      webglRenderPass.glParameters,
+      () => {
         if (isIndexed && isInstanced) {
           // ANGLE_instanced_arrays extension
-          this.device.gl2.drawElementsInstanced(
-            drawMode,
-            vertexCount,
-            indexType,
+          this.device.gl2?.drawElementsInstanced(
+            glDrawMode,
+            vertexCount || 0, // indexCount?
+            glIndexType,
             firstVertex,
-            instanceCount
+            instanceCount || 0
           );
           // } else if (isIndexed && this.device.isWebGL2 && !isNaN(start) && !isNaN(end)) {
-          //   this.device.gl2.drawRangeElements(drawMode, start, end, vertexCount, indexType, offset);
+          //   this.device.gl2.drawRangeElements(glDrawMode, start, end, vertexCount, glIndexType, offset);
         } else if (isIndexed) {
-          this.device.gl.drawElements(drawMode, vertexCount, indexType, firstVertex);
+          this.device.gl.drawElements(glDrawMode, vertexCount || 0, glIndexType, firstVertex); // indexCount?
         } else if (isInstanced) {
-          this.device.gl2.drawArraysInstanced(drawMode, firstVertex, vertexCount, instanceCount);
+          this.device.gl2?.drawArraysInstanced(
+            glDrawMode,
+            firstVertex,
+            vertexCount || 0,
+            instanceCount || 0
+          );
         } else {
-          this.device.gl.drawArrays(drawMode, firstVertex, vertexCount);
+          this.device.gl.drawArrays(glDrawMode, firstVertex, vertexCount || 0);
         }
-      });
 
-      if (transformFeedback) {
-        transformFeedback.end();
+        if (transformFeedback) {
+          transformFeedback.end();
+        }
       }
-    });
+    );
+
+    vertexArray.unbindAfterRender(renderPass);
 
     return true;
   }
@@ -251,17 +309,19 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
 
     // Avoid checking program linking error in production
     // @ts-expect-error
-    if (gl.debug || log.level > 0) {
-      const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
-      if (!linked) {
-        throw new Error(`Error linking: ${gl.getProgramInfoLog(this.handle)}`);
-      }
+    if (!gl.debug && log.level === 0) {
+      // return;
+    }
 
-      gl.validateProgram(this.handle);
-      const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
-      if (!validated) {
-        throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);
-      }
+    const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
+    if (!linked) {
+      throw new Error(`Error linking: ${gl.getProgramInfoLog(this.handle)}`);
+    }
+
+    gl.validateProgram(this.handle);
+    const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
+    if (!validated) {
+      throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);
     }
   }
 
@@ -275,14 +335,16 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
   _areTexturesRenderable() {
     let texturesRenderable = true;
 
-    for (const [name, texture] of Object.entries(this._textureUniforms)) {
+    for (const [, texture] of Object.entries(this._textureUniforms)) {
       texture.update();
       texturesRenderable = texturesRenderable && texture.loaded;
     }
 
-    for (const [name, texture] of Object.entries(this.bindings)) {
+    for (const [, texture] of Object.entries(this.bindings)) {
       // texture.update();
+      // @ts-expect-error
       if (texture.loaded !== undefined) {
+        // @ts-expect-error
         texturesRenderable = texturesRenderable && texture.loaded;
       }
     }
@@ -290,15 +352,40 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
     return texturesRenderable;
   }
 
-  /** Apply any bindings */
+  /**
+   * Constant attributes need to be reset before every draw call
+   * Any attribute that is disabled in the current vertex array object
+   * is read from the context's global constant value for that attribute location.
+   * @note Constant attributes are only supported in WebGL, not in WebGPU
+   *
+  _applyConstantAttributes(vertexArray: WEBGLVertexArray): void {
+    const attributeInfos = getAttributeInfosFromLayouts(this.shaderLayout, this.bufferLayout);
+    for (const [name, value] of Object.entries(this.)) {
+      const attributeInfo = attributeInfos[name];
+      if (!attributeInfo) {
+        log.warn(
+          `Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`
+        )();
+        continue; // eslint-disable-line no-continue
+      }
+      vertexArray.setConstant(attributeInfo.location, value);
+      vertexArray.enable(attributeInfo.location, false);
+    }
+  }
+  */
+
+  /** Apply any bindings (before each draw call) */
   _applyBindings() {
     this.device.gl.useProgram(this.handle);
 
     const {gl2} = this.device;
+    if (!gl2) {
+      throw new Error('bindings');
+    }
 
     let textureUnit = 0;
     let uniformBufferIndex = 0;
-    for (const binding of this.layout.bindings) {
+    for (const binding of this.shaderLayout.bindings) {
       const value = this.bindings[binding.name];
       if (!value) {
         throw new Error(`No value for binding ${binding.name} in ${this.id}`);
@@ -319,8 +406,11 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
             gl2.bindBufferRange(
               GL.UNIFORM_BUFFER,
               uniformBufferIndex,
+              // @ts-expect-error
               value.buffer.handle,
+              // @ts-expect-error
               value.offset || 0,
+              // @ts-expect-error
               value.size || value.buffer.byteLength - value.offset
             );
           }
@@ -328,10 +418,24 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
           break;
 
         case 'texture':
-          if (!(value instanceof WEBGLTexture)) {
+          if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
             throw new Error('texture');
           }
-          const texture: WEBGLTexture = value;
+          let texture: WEBGLTexture;
+          if (value instanceof WEBGLTexture) {
+            texture = value;
+          } else if (
+            value instanceof WEBGLFramebuffer &&
+            value.colorAttachments[0] instanceof WEBGLTexture
+          ) {
+            log.warn(
+              'Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead'
+            )();
+            texture = value.colorAttachments[0];
+          } else {
+            throw new Error('No texture');
+          }
+
           gl2.activeTexture(GL.TEXTURE0 + textureUnit);
           gl2.bindTexture(texture.target, texture.handle);
           // gl2.bindSampler(textureUnit, sampler.handle);
@@ -349,10 +453,14 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
     }
   }
 
+  /**
+   * Due to program sharing, uniforms need to be reset before every draw call
+   * (though caching will avoid redundant WebGL calls)
+   */
   _applyUniforms() {
-    for (const uniformLayout of this.layout.uniforms || []) {
+    for (const uniformLayout of this.shaderLayout.uniforms || []) {
       const {name, location, type, textureUnit} = uniformLayout;
-      const value = this.uniforms[name] || textureUnit;
+      const value = this.uniforms[name] ?? textureUnit;
       if (value !== undefined) {
         setUniform(this.device.gl, location, type, value);
       }
@@ -360,18 +468,27 @@ export default class WEBGLRenderPipeline extends RenderPipeline {
   }
 }
 
-/** Get the primitive type for transform feedback */
-function getDrawMode(
+/** Get the primitive type for draw */
+function getGLDrawMode(
   topology: PrimitiveTopology
-): GL.POINTS | GL.LINES | GL.LINE_STRIP | GL.TRIANGLES | GL.TRIANGLE_STRIP {
+):
+  | GL.POINTS
+  | GL.LINES
+  | GL.LINE_STRIP
+  | GL.LINE_LOOP
+  | GL.TRIANGLES
+  | GL.TRIANGLE_STRIP
+  | GL.TRIANGLE_FAN {
   // prettier-ignore
   switch (topology) {
-  case 'point-list': return GL.POINTS;
-  case 'line-list': return GL.LINES;
-  case 'line-strip': return GL.LINE_STRIP;
-  case 'triangle-list': return GL.TRIANGLES;
-  case 'triangle-strip': return GL.TRIANGLE_STRIP;
-  default: throw new Error(topology);
+    case 'point-list': return GL.POINTS;
+    case 'line-list': return GL.LINES;
+    case 'line-strip': return GL.LINE_STRIP;
+    case 'line-loop-webgl': return GL.LINE_LOOP;
+    case 'triangle-list': return GL.TRIANGLES;
+    case 'triangle-strip': return GL.TRIANGLE_STRIP;
+    case 'triangle-fan-webgl': return GL.TRIANGLE_FAN;
+    default: throw new Error(topology);
   }
 }
 
@@ -379,35 +496,13 @@ function getDrawMode(
 function getGLPrimitive(topology: PrimitiveTopology): GL.POINTS | GL.LINES | GL.TRIANGLES {
   // prettier-ignore
   switch (topology) {
-  case 'point-list': return GL.POINTS;
-  case 'line-list': return GL.LINES;
-  case 'line-strip': return GL.LINES;
-  case 'triangle-list': return GL.TRIANGLES;
-  case 'triangle-strip': return GL.TRIANGLES;
-  default: throw new Error(topology);
-  }
-}
-
-function getAttributesByLocation(
-  attributes: Record<string, Buffer>,
-  layout: ShaderLayout
-): Record<number, Buffer> {
-  const byLocation: Record<number, Buffer> = {};
-  for (const [name, buffer] of Object.entries(attributes)) {
-    const attribute = getAttributeLayout(layout, name);
-    byLocation[attribute.location] = buffer;
-  }
-  return byLocation;
-}
-
-function getAttributeLayout(layout: ShaderLayout, name: string): AttributeLayout | undefined {
-  return layout.attributes.find((binding) => binding.name === name);
-}
-
-function getBindingLayout(layout: ShaderLayout, name: string): BindingLayout {
-  const binding = layout.bindings.find((binding) => binding.name === name);
-  if (!binding) {
-    throw new Error(`Unknown binding ${name}`);
+    case 'point-list': return GL.POINTS;
+    case 'line-list': return GL.LINES;
+    case 'line-strip': return GL.LINES;
+    case 'line-loop-webgl': return GL.LINES;
+    case 'triangle-list': return GL.TRIANGLES;
+    case 'triangle-strip': return GL.TRIANGLES;
+    case 'triangle-fan-webgl': return GL.TRIANGLES;
+    default: throw new Error(topology);
   }
-  return binding;
 }

package/src/adapter/resources/webgl-sampler.ts

@@ -1,8 +1,10 @@
-import {Sampler, SamplerProps} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import type {WebGLSamplerParameters} from '../../types/webgl';
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import {Sampler, SamplerProps} from '@luma.gl/core';
+import {GL, GLSamplerParameters} from '@luma.gl/constants';
 import {convertSamplerParametersToWebGL} from '../converters/sampler-parameters';
-import type WebGLDevice from '../webgl-device';
+import type {WebGLDevice} from '../webgl-device';
 
 /**
  * Sampler object -
@@ -11,10 +13,10 @@ import type WebGLDevice from '../webgl-device';
  * so that they can be set directly on the texture
  * https://github.com/WebGLSamples/WebGL2Samples/blob/master/samples/sampler_object.html
  */
-export default class WEBGLSampler extends Sampler {
+export class WEBGLSampler extends Sampler {
   readonly device: WebGLDevice;
   readonly handle: WebGLSampler;
-  readonly parameters: WebGLSamplerParameters;
+  readonly parameters: GLSamplerParameters;
 
   constructor(device: WebGLDevice, props: SamplerProps) {
     super(device, props);
@@ -26,16 +28,20 @@ export default class WEBGLSampler extends Sampler {
     }
   }
 
-  destroy(): void {
+  override destroy(): void {
     if (this.handle) {
       this.device.gl2.deleteSampler(this.handle);
-      // @ts-expect-error
+      // @ts-expect-error read-only/undefined
       this.handle = undefined;
     }
   }
 
+  override toString(): string {
+    return `Sampler(${this.id},${JSON.stringify(this.props)})`;
+  }
+
   /** Set sampler parameters on the sampler */
-  private _setSamplerParameters(parameters: WebGLSamplerParameters): void {
+  private _setSamplerParameters(parameters: GLSamplerParameters): void {
     for (const [pname, value] of Object.entries(parameters)) {
       // Apparently there are integer/float conversion issues requires two parameter setting functions in JavaScript.
       // For now, pick the float version for parameters specified as GLfloat.