@luma.gl/webgl 9.0.0-alpha.5 → 9.0.0-alpha.51

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,20 +28,24 @@ 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.
-      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:

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

@@ -1,19 +1,20 @@
 // 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';
+// Copyright (c) vis.gl contributors
+
+import {Shader, ShaderProps, CompilerMessage} 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,16 +29,20 @@ 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);
-      // @ts-expect-error
-      this.handle = null;
+      // this.handle = null;
+      this.destroyed = true;
     }
   }
 
-  async compilationInfo(): Promise<readonly CompilerMessage[]> {
+  override async getCompilationInfo(): Promise<readonly CompilerMessage[]> {
+    return this.getCompilationInfoSync();
+  }
+
+  override getCompilationInfoSync() {
     const log = this.device.gl.getShaderInfoLog(this.handle);
     return parseShaderCompilerLog(log);
   }
@@ -45,7 +50,8 @@ import WebGLDevice from '../webgl-device';
   // PRIVATE METHODS
 
   _compile(source: string): void {
-    const addGLSLVersion = (source: string) => source.startsWith('#version ') ? source : `#version 100\n${source}`;
+    const addGLSLVersion = (source: string) =>
+      source.startsWith('#version ') ? source : `#version 100\n${source}`;
     source = addGLSLVersion(source);
 
     const {gl} = this.device;
@@ -55,24 +61,24 @@ import WebGLDevice from '../webgl-device';
     // 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 messages = parseShaderCompilerLog(shaderLog).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}`);
+    this.compilationStatus = gl.getShaderParameter(this.handle, GL.COMPILE_STATUS) ? 'success' : 'error';
+
+    // The `Shader` base class will determine if debug window should be opened based on props
+    this.debugShader();
+
+    if (this.compilationStatus === 'error') {
+      throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`);
     }
   }
 }
 
-// HELPERS
+// 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);
+// }
 
-/** 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`);
-}