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

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

@@ -1,19 +1,18 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
-import {Sampler, SamplerProps} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import type {GLSamplerParameters} from '../../types/webgl';
+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 -
- * Under WebGL2 we create an actual WebGL sampler
- * Under WebGL1, we just store the sampler parameters
  * 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: GLSamplerParameters;
@@ -22,33 +21,35 @@ export default class WEBGLSampler extends Sampler {
     super(device, props);
     this.device = device;
     this.parameters = convertSamplerParametersToWebGL(props);
-    if (this.device.isWebGL2) {
-      this.handle = this.handle || this.device.gl2.createSampler();
-      this._setSamplerParameters(this.parameters);
-    }
+    this.handle = this.handle || this.device.gl.createSampler();
+    this._setSamplerParameters(this.parameters);
   }
 
-  destroy(): void {
+  override destroy(): void {
     if (this.handle) {
-      this.device.gl2.deleteSampler(this.handle);
-      // @ts-expect-error
+      this.device.gl.deleteSampler(this.handle);
+      // @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: 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.
-      const param = Number(pname);
+      const param = Number(pname) as GL.TEXTURE_MIN_LOD | GL.TEXTURE_MAX_LOD;
       switch (param) {
         case GL.TEXTURE_MIN_LOD:
         case GL.TEXTURE_MAX_LOD:
-          this.device.gl2.samplerParameterf(this.handle, param, value);
+          this.device.gl.samplerParameterf(this.handle, param, value);
           break;
         default:
-          this.device.gl2.samplerParameteri(this.handle, param, value);
+          this.device.gl.samplerParameteri(this.handle, param, value);
           break;
       }
     }

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

@@ -1,19 +1,21 @@
-// luma.gl, MIT license
-import {log, uid, Shader, ShaderProps} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import {getShaderInfo, CompilerMessage, formatCompilerLog} from '@luma.gl/shadertools';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Shader, ShaderProps, CompilerMessage, log} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
 import {parseShaderCompilerLog} from '../helpers/parse-shader-compiler-log';
-import WebGLDevice from '../webgl-device';
+import {WebGLDevice} from '../webgl-device';
 
 /**
  * An immutable compiled shader program that execute portions of the GPU Pipeline
  */
- export default class WEBGLShader extends Shader {
+export class WEBGLShader extends Shader {
   readonly device: WebGLDevice;
   readonly handle: WebGLShader;
 
   constructor(device: WebGLDevice, props: ShaderProps) {
-    super(device, {id: getShaderIdFromProps(props), ...props});
+    super(device, props);
     this.device = device;
     switch (this.props.stage) {
       case 'vertex':
@@ -28,7 +30,7 @@ import WebGLDevice from '../webgl-device';
     this._compile(this.source);
   }
 
-  destroy(): void {
+  override destroy(): void {
     if (this.handle) {
       this.removeStats();
       this.device.gl.deleteShader(this.handle);
@@ -37,43 +39,100 @@ import WebGLDevice from '../webgl-device';
     }
   }
 
-  async compilationInfo(): Promise<readonly CompilerMessage[]> {
+  override async getCompilationInfo(): Promise<readonly CompilerMessage[]> {
+    await this._waitForCompilationComplete();
+    return this.getCompilationInfoSync();
+  }
+
+  override getCompilationInfoSync() {
     const log = this.device.gl.getShaderInfoLog(this.handle);
-    return log ? parseShaderCompilerLog(log) : [];
+    return parseShaderCompilerLog(log);
+  }
+
+  override getTranslatedSource(): string | null {
+    const extensions = this.device.getExtension('WEBGL_debug_shaders');
+    const ext = extensions.WEBGL_debug_shaders;
+    return ext?.getTranslatedShaderSource(this.handle);
   }
 
   // PRIVATE METHODS
 
-  _compile(source: string): void {
-    const addGLSLVersion = (source: string) => source.startsWith('#version ') ? source : `#version 100\n${source}`;
+  /** Compile a shader and get compilation status */
+  protected async _compile(source: string): Promise<void> {
+    const addGLSLVersion = (source: string) =>
+      source.startsWith('#version ') ? source : `#version 100\n${source}`;
     source = addGLSLVersion(source);
 
     const {gl} = this.device;
     gl.shaderSource(this.handle, source);
     gl.compileShader(this.handle);
 
-    // TODO - For performance reasons, avoid checking shader compilation errors on production?
-    // TODO - Load log even when no error reported, to catch warnings?
-    // https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings
-    const compileStatus = gl.getShaderParameter(this.handle, GL.COMPILE_STATUS);
-    if (!compileStatus) {
-      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 shaderName: string = getShaderInfo(source).name;
-      const shaderDescription = `${this.stage} shader ${shaderName}`;
-      log.error(`GLSL compilation errors in ${shaderDescription}\n${formattedLog}`)();
-      throw new Error(`GLSL compilation errors in ${shaderName}`);
+    // For performance reasons, avoid checking shader compilation errors on production
+    if (log.level === 0) {
+      this.compilationStatus = 'pending';
+      return;
     }
+
+    // Sync case - slower, but advantage is that it throws in the constructor, making break on error more useful
+    if (!this.device.features.has('compilation-status-async-webgl')) {
+      this._getCompilationStatus();
+      if (this.compilationStatus === 'error') {
+        throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`);
+      }
+      // The `Shader` base class will determine if debug window should be opened based on this.compilationStatus
+      this.debugShader();
+      return;
+    }
+
+    // async case
+    log.once(1, 'Shader compilation is asynchronous')();
+    await this._waitForCompilationComplete();
+    log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
+    this._getCompilationStatus();
+
+    // The `Shader` base class will determine if debug window should be opened based on this.compilationStatus
+    this.debugShader();
   }
-}
 
-// HELPERS
+  /** Use KHR_parallel_shader_compile extension if available */
+  protected async _waitForCompilationComplete(): Promise<void> {
+    const waitMs = async (ms: number) => await new Promise(resolve => setTimeout(resolve, ms));
+    const DELAY_MS = 10; // Shader compilation is typically quite fast (with some exceptions)
+
+    // If status polling is not available, we can't wait for completion. Just wait a little to minimize blocking
+    if (!this.device.features.has('compilation-status-async-webgl')) {
+      await waitMs(DELAY_MS);
+      return;
+    }
 
-/** Deduce an id, from shader source, or supplied id, or shader type */
-function getShaderIdFromProps(props: ShaderProps): string {
-  return getShaderInfo(props.source).name ||
-    props.id ||
-    uid(`unnamed ${props.stage}-shader`);
+    const {gl} = this.device;
+    for (;;) {
+      const complete = gl.getShaderParameter(this.handle, GL.COMPLETION_STATUS_KHR);
+      if (complete) {
+        return;
+      }
+      await waitMs(DELAY_MS);
+    }
+  }
+
+  /**
+   * Get the shader compilation status
+   * TODO - Load log even when no error reported, to catch warnings?
+   * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings
+   */
+  protected _getCompilationStatus() {
+    this.compilationStatus = this.device.gl.getShaderParameter(this.handle, GL.COMPILE_STATUS)
+      ? 'success'
+      : 'error';
+  }
 }
+
+// TODO - Original code from luma.gl v8 - keep until new debug functionality has matured
+// if (!compilationSuccess) {
+//   const parsedLog = shaderLog ? parseShaderCompilerLog(shaderLog) : [];
+//   const messages = parsedLog.filter(message => message.type === 'error');
+//   const formattedLog = formatCompilerLog(messages, source, {showSourceCode: 'all', html: true});
+//   const shaderDescription = `${this.stage} shader ${shaderName}`;
+//   log.error(`GLSL compilation errors in ${shaderDescription}\n${formattedLog}`)();
+//   displayShaderLog(parsedLog, source, shaderName);
+// }

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

@@ -0,0 +1,28 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Device, TextureViewProps} from '@luma.gl/core';
+// import {decodeTextureFormat} from '@luma.gl/core';
+import {TextureView, Texture} from '@luma.gl/core';
+
+import {WebGLDevice} from '../webgl-device';
+import {WEBGLTexture} from './webgl-texture';
+
+export class WEBGLTextureView extends TextureView {
+  readonly device: WebGLDevice;
+  readonly gl: WebGL2RenderingContext;
+  readonly handle: WebGLTexture;
+
+  readonly texture: WEBGLTexture;
+
+  constructor(device: Device, props: TextureViewProps & {texture: WEBGLTexture}) {
+    super(device, {...Texture.defaultProps, ...props});
+
+    this.device = device as WebGLDevice;
+    this.gl = this.device.gl;
+    this.handle = null;
+
+    this.texture = props.texture;
+  }
+}