@luma.gl/webgl 9.1.0-alpha.9 → 9.1.0-beta.11

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

@@ -2,14 +2,21 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {RenderPipelineProps, RenderPipelineParameters, PrimitiveTopology} from '@luma.gl/core';
-import type {ShaderLayout, UniformValue, Binding} from '@luma.gl/core';
-import type {RenderPass, VertexArray} from '@luma.gl/core';
+import type {
+  RenderPipelineProps,
+  RenderPipelineParameters,
+  PrimitiveTopology,
+  ShaderLayout,
+  UniformValue,
+  Binding,
+  RenderPass,
+  VertexArray
+} from '@luma.gl/core';
 import {RenderPipeline, log} from '@luma.gl/core';
 // import {getAttributeInfosFromLayouts} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
 
-import {getShaderLayout} from '../helpers/get-shader-layout';
+import {getShaderLayoutFromGLSL} from '../helpers/get-shader-layout';
 import {withDeviceAndGLParameters} from '../converters/device-parameters';
 import {setUniform} from '../helpers/set-uniform';
 import {splitUniformsAndBindings} from '../../utils/split-uniforms-and-bindings';
@@ -73,7 +80,7 @@ export class WEBGLRenderPipeline extends RenderPipeline {
     this._linkShaders();
 
     log.time(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
-    this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
+    this.introspectedLayout = getShaderLayoutFromGLSL(this.device.gl, this.handle);
     log.timeEnd(1, `RenderPipeline ${this.id} - shaderLayout introspection`)();
 
     // Merge provided layout with introspected layout
@@ -103,12 +110,12 @@ export class WEBGLRenderPipeline extends RenderPipeline {
       // and reference them as `app` from both GLSL and JS.
       // TODO - this is rather hacky - we could also remap the name directly in the shader layout.
       const binding =
-        this.shaderLayout.bindings.find(binding => binding.name === name) ||
-        this.shaderLayout.bindings.find(binding => binding.name === `${name}Uniforms`);
+        this.shaderLayout.bindings.find(binding_ => binding_.name === name) ||
+        this.shaderLayout.bindings.find(binding_ => binding_.name === `${name}Uniforms`);
 
       if (!binding) {
         const validBindings = this.shaderLayout.bindings
-          .map(binding => `"${binding.name}"`)
+          .map(binding_ => `"${binding_.name}"`)
           .join(', ');
         if (!options?.disableWarnings) {
           log.warn(
@@ -310,22 +317,37 @@ export class WEBGLRenderPipeline extends RenderPipeline {
   }
 
   /** Report link status. First, check for shader compilation failures if linking fails */
-  _reportLinkStatus(status: 'success' | 'linking' | 'validation') {
+  async _reportLinkStatus(status: 'success' | 'linking' | 'validation'): Promise<void> {
     switch (status) {
       case 'success':
         return;
 
       default:
         // First check for shader compilation failures if linking fails
-        if (this.vs.compilationStatus === 'error') {
-          this.vs.debugShader();
-          throw new Error(`Error during compilation of shader ${this.vs.id}`);
+        switch (this.vs.compilationStatus) {
+          case 'error':
+            this.vs.debugShader();
+            throw new Error(`Error during compilation of shader ${this.vs.id}`);
+          case 'pending':
+            this.vs.asyncCompilationStatus.then(() => this.vs.debugShader());
+            break;
+          case 'success':
+            break;
         }
-        if (this.fs?.compilationStatus === 'error') {
-          this.fs.debugShader();
-          throw new Error(`Error during compilation of shader ${this.fs.id}`);
+
+        switch (this.fs?.compilationStatus) {
+          case 'error':
+            this.fs.debugShader();
+            throw new Error(`Error during compilation of shader ${this.fs.id}`);
+          case 'pending':
+            this.fs.asyncCompilationStatus.then(() => this.fs.debugShader());
+            break;
+          case 'success':
+            break;
         }
-        throw new Error(`Error during ${status}: ${this.device.gl.getProgramInfoLog(this.handle)}`);
+
+        const linkErrorLog = this.device.gl.getProgramInfoLog(this.handle);
+        throw new Error(`Error during ${status}: ${linkErrorLog}`);
     }
   }
 
@@ -392,11 +414,12 @@ export class WEBGLRenderPipeline extends RenderPipeline {
       }
     }
 
-    for (const [, texture] of Object.entries(this.bindings)) {
-      if (texture instanceof WEBGLTexture) {
-        texture.update();
-      }
-    }
+    // TODO - remove this should be handled by ExternalTexture
+    // for (const [, texture] of Object.entries(this.bindings)) {
+    //   if (texture instanceof WEBGLTexture) {
+    //     texture.update();
+    //   }
+    // }
 
     return texturesRenderable;
   }

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

@@ -39,14 +39,18 @@ export class WEBGLShader extends Shader {
     }
   }
 
+  get asyncCompilationStatus(): Promise<'pending' | 'success' | 'error'> {
+    return this._waitForCompilationComplete().then(() => this.compilationStatus);
+  }
+
   override async getCompilationInfo(): Promise<readonly CompilerMessage[]> {
     await this._waitForCompilationComplete();
     return this.getCompilationInfoSync();
   }
 
   override getCompilationInfoSync(): readonly CompilerMessage[] {
-    const log = this.device.gl.getShaderInfoLog(this.handle);
-    return log ? parseShaderCompilerLog(log) : [];
+    const shaderLog = this.device.gl.getShaderInfoLog(this.handle);
+    return shaderLog ? parseShaderCompilerLog(shaderLog) : [];
   }
 
   override getTranslatedSource(): string | null {
@@ -59,16 +63,14 @@ export class WEBGLShader extends Shader {
 
   /** Compile a shader and get compilation status */
   protected async _compile(source: string): Promise<void> {
-    const addGLSLVersion = (source: string) =>
-      source.startsWith('#version ') ? source : `#version 300 es\n${source}`;
-    source = addGLSLVersion(source);
+    source = source.startsWith('#version ') ? source : `#version 300 es\n${source}`;
 
     const {gl} = this.device;
     gl.shaderSource(this.handle, source);
     gl.compileShader(this.handle);
 
     // For performance reasons, avoid checking shader compilation errors on production
-    if (log.level === 0) {
+    if (!this.device.props.debug) {
       this.compilationStatus = 'pending';
       return;
     }