@luma.gl/webgl 9.0.0-alpha.35 → 9.0.0-alpha.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/webgl",
-  "version": "9.0.0-alpha.35",
+  "version": "9.0.0-alpha.37",
   "description": "WebGL2 adapter for the luma.gl API",
   "type": "module",
   "license": "MIT",
@@ -44,12 +44,12 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "@luma.gl/constants": "9.0.0-alpha.35",
-    "@luma.gl/core": "9.0.0-alpha.35",
+    "@luma.gl/constants": "9.0.0-alpha.37",
+    "@luma.gl/core": "9.0.0-alpha.37",
     "@probe.gl/env": "^4.0.2"
   },
   "devDependencies": {
-    "@luma.gl/test-utils": "9.0.0-alpha.35"
+    "@luma.gl/test-utils": "9.0.0-alpha.37"
   },
-  "gitHead": "5b93557731aaf1b9fd0fc1d84b5a3c7c0717298a"
+  "gitHead": "705108c07db777553714bfdf5af77f75e5c54c35"
 }

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

@@ -9,11 +9,43 @@ import {
 import {GL} from '@luma.gl/constants';
 import type {GLParameters} from '@luma.gl/constants';
 import {pushContextState, popContextState} from '../../context/state-tracker/track-context-state';
-import {setParameters} from '../../context/parameters/unified-parameter-api';
+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
  * - Saves current "global" WebGL context settings
@@ -37,7 +69,7 @@ export function withGLParameters<T = unknown>(
   // @ts-expect-error
   pushContextState(device.gl);
   try {
-    setParameters(device, parameters);
+    setGLParameters(device, parameters);
     return func(device);
   } finally {
     // @ts-expect-error

package/src/adapter/resources/webgl-command-buffer.ts

@@ -333,8 +333,8 @@ function _copyTextureToTexture(device: WebGLDevice, options: CopyTextureToTextur
   if (texture) {
     texture.unbind();
   }
-  // @ts-expect-error
-  device.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+  // ts-expect-error
+  // device.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
   if (destroyFramebuffer) {
     framebuffer.destroy();
   }

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

@@ -1,10 +1,10 @@
-import {RenderPass, RenderPassProps, NumericArray, RenderPassParameters} from '@luma.gl/core';
+import {RenderPass, RenderPassProps, NumberArray, RenderPassParameters} from '@luma.gl/core';
 import {WebGLDevice} from '../webgl-device';
 import {GL, GLParameters} from '@luma.gl/constants';
-import {withParameters} from '../../context/state-tracker/with-parameters';
+import {withGLParameters} from '../../context/state-tracker/with-parameters';
+import {setGLParameters} from '../../context/parameters/unified-parameter-api';
 
 // Should collapse during minification
-
 const GL_DEPTH_BUFFER_BIT = 0x00000100;
 const GL_STENCIL_BUFFER_BIT = 0x00000400;
 const GL_COLOR_BUFFER_BIT = 0x00004000;
@@ -89,6 +89,8 @@ export class WEBGLRenderPass extends RenderPass {
     }
 
     this.glParameters = glParameters;
+
+    setGLParameters(this.device, glParameters);
   }
 
   // Internal
@@ -116,7 +118,7 @@ export class WEBGLRenderPass extends RenderPass {
 
     if (clearMask !== 0) {
       // Temporarily set any clear "colors" and call clear
-      withParameters(this.device, glParameters, () => {
+      withGLParameters(this.device, glParameters, () => {
         this.device.gl.clear(clearMask);
       });
 
@@ -130,8 +132,8 @@ export class WEBGLRenderPass extends RenderPass {
   /** 
    * WebGL2 - clear a specific color buffer 
    */
-  protected clearColorBuffer(drawBuffer: number = 0, value: NumericArray = [0, 0, 0, 0]) {
-    withParameters(this.device.gl2, {framebuffer: this.props.framebuffer}, () => {
+  protected clearColorBuffer(drawBuffer: number = 0, value: NumberArray = [0, 0, 0, 0]) {
+    withGLParameters(this.device.gl2, {framebuffer: this.props.framebuffer}, () => {
       // Method selection per OpenGL ES 3 docs
       switch (value.constructor) {
         case Int32Array:

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

@@ -1,21 +1,14 @@
 // luma.gl, MIT license
-import type {
-  TypedArray,
-  UniformValue,
-  RenderPipelineProps,
-  Binding,
-  ShaderLayout,
-  BufferLayout,
-  PrimitiveTopology
-} from '@luma.gl/core';
-import type {RenderPass, Buffer} from '@luma.gl/core';
+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, getAttributeInfosFromLayouts} from '@luma.gl/core';
+import {mergeShaderLayout} from '@luma.gl/core';
+// import {mergeShaderLayout, getAttributeInfosFromLayouts} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
 
-import {getGLFromVertexType} from '../converters/vertex-formats';
 import {getShaderLayout} from '../helpers/get-shader-layout';
-import {withDeviceParameters, withGLParameters} from '../converters/device-parameters';
+import {withDeviceAndGLParameters} from '../converters/device-parameters';
 import {setUniform} from '../helpers/set-uniform';
 // import {copyUniform, checkUniformValues} from '../../classes/uniforms';
 
@@ -23,7 +16,7 @@ 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 {WEBGLVertexArray} from './webgl-vertex-array';
 import {WEBGLRenderPass} from './webgl-render-pass';
 
 const LOG_PROGRAM_PERF_PRIORITY = 4;
@@ -40,25 +33,14 @@ export class WEBGLRenderPipeline extends RenderPipeline {
   fs: WEBGLShader;
   /** The layout extracted from shader by WebGL introspection APIs */
   introspectedLayout: ShaderLayout;
-  /** The merged layout */
-  shaderLayout: ShaderLayout;
-  /** Buffer map describing buffer interleaving etc */
-  bufferLayout: BufferLayout[];
 
   /** Uniforms set on this model */
-  uniforms: Record<string, any> = {};
+  uniforms: Record<string, UniformValue> = {};
   /** Bindings set on this model */
-  bindings: Record<string, any> = {};
-  /** Any constant attributes */
-  constantAttributes: Record<string, TypedArray> = {};
-  /** Index buffer is stored separately */
-  _indexBuffer?: WEBGLBuffer;
+  bindings: Record<string, Binding> = {};
   /** WebGL varyings */
   varyings: string[] | null = null;
 
-  /** Stores attribute bindings */
-  vertexArrayObject: WEBGLVertexArrayObject;
-
   _textureUniforms: Record<string, any> = {};
   _textureIndexCounter: number = 0;
   _uniformCount: number = 0;
@@ -91,9 +73,8 @@ export class WEBGLRenderPipeline extends RenderPipeline {
     // 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.bufferLayout = props.bufferLayout || [];
     // this.shaderLayout = mergeBufferMap(this.shaderLayout, this.bufferLayout);
-    this.vertexArrayObject = new WEBGLVertexArrayObject(this.device);
   }
 
   override destroy(): void {
@@ -104,86 +85,38 @@ export class WEBGLRenderPipeline extends RenderPipeline {
     }
   }
 
-  setIndexBuffer(indexBuffer: Buffer): void {
-    const webglBuffer = cast<WEBGLBuffer>(indexBuffer);
-    this.vertexArrayObject.setElementBuffer(webglBuffer);
-    this._indexBuffer = webglBuffer;
-  }
-
-  /** @todo needed for portable model */
-  setAttributes(buffers: Record<string, Buffer>): void {
-    const attributeInfos = getAttributeInfosFromLayouts(this.shaderLayout, this.bufferLayout);
-
-    for (const [bufferName, buffer] of Object.entries(buffers)) {
-      let set = false;
-      for (const attributeInfo of Object.values(attributeInfos)) {
-        if (attributeInfo.bufferName !== bufferName) {
-          continue; // eslint-disable-line no-continue
-        }
-        const webglBuffer = cast<WEBGLBuffer>(buffer);
-
-        const glType = getGLFromVertexType(attributeInfo.bufferDataType);
-        // TODO remove when we have more confidence
-        log.log(2, {
-          setAttribute: attributeInfo.attributeName,
-          toBuffer: bufferName,
-          size: attributeInfo.bufferComponents,
-          type: glType,
-          stride: attributeInfo.byteStride,
-          offset: attributeInfo.byteOffset,
-          normalized: attributeInfo.normalized,
-          // it is the shader attribute declaration, not the vertex memory format,
-          // that determines if the data in the buffer will be treated as integers.
-          // /
-          // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
-          // but as far as we can tell, WebGPU does not.
-          integer: attributeInfo.integer,
-          divisor: attributeInfo.stepMode === 'instance' ? 1 : 0
-        })();
-        this.vertexArrayObject.setBuffer(attributeInfo.location, webglBuffer, {
-          size: attributeInfo.bufferComponents,
-          type: glType,
-          stride: attributeInfo.byteStride,
-          offset: attributeInfo.byteOffset,
-          normalized: attributeInfo.normalized,
-          // it is the shader attribute declaration, not the vertex memory format,
-          // that determines if the data in the buffer will be treated as integers.
-          // /
-          // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
-          // but as far as we can tell, WebGPU does not.
-          integer: attributeInfo.integer,
-          divisor: attributeInfo.stepMode === 'instance' ? 1 : 0
-        });
-        set = true;
-      }
-      if (!set) {
-        log.warn(
-          `setAttributes(): Ignoring (buffer "${buffer.id}" for unknown attribute "${name}" in pipeline "${this.id}"`
-        )();
-      }
-    }
-  }
-
-  /**
-   * Constant attributes are only supported in WebGL, not in WebGPU
-   * Any attribute that is disabled in the current vertex array object
-   * is read from the context's global constant value for that attribute location.
-   * @param attributes
-   */
-  setConstantAttributes(attributes: Record<string, TypedArray>): void {
-    // TODO - there should be no advantage to setting these here vs in _applyConstantAttributes
-    // for (const [name, value] of Object.entries(attributes)) {
-    //   const attributeInfo = getAttributeInfosFromLayouts(this.shaderLayout, this.bufferLayout, name);
-    //   if (!attributeInfo) {
-    //     log.warn(
-    //       `Ignoring constant value supplied for unknown attribute "${name}" in pipeline "${this.id}"`
-    //     )();
-    //     continue; // eslint-disable-line no-continue
-    //   }
-    //   this.vertexArrayObject.setConstant(attributeInfo.location, value);
-    // }
-    Object.assign(this.constantAttributes, attributes);
-  }
+  // 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
+  //     });
+  //   }
+  // }
 
   /**
    * Bindings include: textures, samplers and uniform buffers
@@ -237,6 +170,8 @@ export class WEBGLRenderPipeline extends RenderPipeline {
    */
   draw(options: {
     renderPass: RenderPass;
+    /** vertex attributes */
+    vertexArray: VertexArray;
     vertexCount?: number;
     indexCount?: number;
     instanceCount?: number;
@@ -247,6 +182,7 @@ export class WEBGLRenderPipeline extends RenderPipeline {
   }): boolean {
     const {
       renderPass,
+      vertexArray,
       vertexCount,
       // indexCount,
       instanceCount,
@@ -256,71 +192,94 @@ export class WEBGLRenderPipeline extends RenderPipeline {
       // baseVertex
     } = options;
 
-    const drawMode = getGLDrawMode(this.props.topology);
-    const isIndexed: boolean = Boolean(this._indexBuffer);
-    const indexType = this._indexBuffer?.glIndexType;
-    const isInstanced: boolean = Number(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 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();
-      this._applyConstantAttributes();
-
-      const webglRenderPass = renderPass as WEBGLRenderPass;
-
-      // TODO - double context push/pop
-      withDeviceParameters(this.device, this.props.parameters, () => {
-        withGLParameters(this.device, webglRenderPass.glParameters, () => {
-          // 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);
-          }
-        });
+    const primitiveMode = getGLPrimitive(this.props.topology);
+    const transformFeedback: any = null;
+    if (transformFeedback) {
+      transformFeedback.begin(primitiveMode);
+    }
+
+    // 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(
+          glDrawMode,
+          vertexCount || 0, // indexCount?
+          glIndexType,
+          firstVertex,
+          instanceCount || 0
+        );
+        // } else if (isIndexed && this.device.isWebGL2 && !isNaN(start) && !isNaN(end)) {
+        //   this.device.gl2.drawRangeElements(glDrawMode, start, end, vertexCount, glIndexType, offset);
+      } else if (isIndexed) {
+        this.device.gl.drawElements(glDrawMode, vertexCount || 0, glIndexType, firstVertex); // indexCount?
+      } else if (isInstanced) {
+        this.device.gl2?.drawArraysInstanced(
+          glDrawMode,
+          firstVertex,
+          vertexCount || 0,
+          instanceCount || 0
+        );
+      } else {
+        this.device.gl.drawArrays(glDrawMode, firstVertex, vertexCount || 0);
+      }
 
-        if (transformFeedback) {
-          transformFeedback.end();
-        }
-      });
+      if (transformFeedback) {
+        transformFeedback.end();
+      }
     });
 
+    vertexArray.unbindAfterRender(renderPass);
+
     return true;
   }
 
@@ -337,17 +296,19 @@ export 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)}`);
     }
   }
 
@@ -368,7 +329,9 @@ export class WEBGLRenderPipeline extends RenderPipeline {
 
     for (const [, texture] of Object.entries(this.bindings)) {
       // texture.update();
+      // @ts-expect-error
       if (texture.loaded !== undefined) {
+        // @ts-expect-error
         texturesRenderable = texturesRenderable && texture.loaded;
       }
     }
@@ -381,10 +344,10 @@ export class WEBGLRenderPipeline extends RenderPipeline {
    * 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(): void {
+   *
+  _applyConstantAttributes(vertexArray: WEBGLVertexArray): void {
     const attributeInfos = getAttributeInfosFromLayouts(this.shaderLayout, this.bufferLayout);
-    for (const [name, value] of Object.entries(this.constantAttributes)) {
+    for (const [name, value] of Object.entries(this.)) {
       const attributeInfo = attributeInfos[name];
       if (!attributeInfo) {
         log.warn(
@@ -392,10 +355,11 @@ export class WEBGLRenderPipeline extends RenderPipeline {
         )();
         continue; // eslint-disable-line no-continue
       }
-      this.vertexArrayObject.setConstant(attributeInfo.location, value);
-      this.vertexArrayObject.enable(attributeInfo.location, false);
+      vertexArray.setConstant(attributeInfo.location, value);
+      vertexArray.enable(attributeInfo.location, false);
     }
   }
+  */
 
   /** Apply any bindings (before each draw call) */
   _applyBindings() {
@@ -429,8 +393,11 @@ export 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
             );
           }

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

@@ -30,7 +30,7 @@ export class WEBGLSampler extends Sampler {
   override destroy(): void {
     if (this.handle) {
       this.device.gl2.deleteSampler(this.handle);
-      // @ts-expect-error
+      // @ts-expect-error read-only/undefined
       this.handle = undefined;
     }
   }

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

@@ -60,7 +60,7 @@ export class WEBGLShader extends Shader {
       const shaderLog = gl.getShaderInfoLog(this.handle);
       const parsedLog = shaderLog ? parseShaderCompilerLog(shaderLog) : [];
       const messages = parsedLog.filter(message => message.type === 'error');
-      const formattedLog = formatCompilerLog(messages, source);
+      const formattedLog = formatCompilerLog(messages, source, {showSourceCode: true});
       const shaderName: string = getShaderInfo(source).name;
       const shaderDescription = `${this.stage} shader ${shaderName}`;
       log.error(`GLSL compilation errors in ${shaderDescription}\n${formattedLog}`)();

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

@@ -15,7 +15,7 @@ import {
 } from '@luma.gl/core';
 import {Texture, cast, log, assert, isPowerOfTwo, loadImage} from '@luma.gl/core';
 import {GL, GLSamplerParameters} from '@luma.gl/constants';
-import {withParameters} from '../../context/state-tracker/with-parameters';
+import {withGLParameters} from '../../context/state-tracker/with-parameters';
 import {
   convertTextureFormatToGL,
   getWebGLTextureParameters,
@@ -428,7 +428,7 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
     this.mipmaps = true;
 
     this.gl.bindTexture(this.target, this.handle);
-    withParameters(this.gl, params, () => {
+    withGLParameters(this.gl, params, () => {
       this.gl.generateMipmap(this.target);
     });
     this.gl.bindTexture(this.target, null);
@@ -504,7 +504,7 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
 
     let gl2;
 
-    withParameters(this.gl, parameters, () => {
+    withGLParameters(this.gl, parameters, () => {
       switch (dataType) {
         case 'null':
           gl.texImage2D(target, level, glFormat, width, height, 0 /* border*/, dataFormat, type, data);
@@ -644,7 +644,7 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
 
     this.gl.bindTexture(this.target, this.handle);
 
-    withParameters(this.gl, parameters, () => {
+    withGLParameters(this.gl, parameters, () => {
       // TODO - x,y parameters
       if (compressed) {
         this.gl.compressedTexSubImage2D(target, level, x, y, width, height, glFormat, data);
@@ -904,7 +904,7 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
 
     const webglTextureFormat = getWebGLTextureParameters(format, this.device.isWebGL2);
 
-    withParameters(this.gl, parameters, () => {
+    withGLParameters(this.gl, parameters, () => {
       if (ArrayBuffer.isView(data)) {
         // @ts-expect-error
         this.gl.texImage3D(