@luma.gl/webgl 8.6.0-alpha.2 → 8.6.0-alpha.3

package/src/classes/program.ts

@@ -1,11 +1,11 @@
-import {log, assert, uid} from '@luma.gl/api';
+import {log, assert, uid, cast, Shader} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 import WebGLResource, {ResourceProps} from './webgl-resource';
 import Texture from './texture';
 import Framebuffer from './framebuffer';
 import {parseUniformName, getUniformSetter} from './uniforms';
-import {VertexShader, FragmentShader} from './webgl-shader';
+import {WEBGLShader} from '../adapter/webgl-shader';
 import ProgramConfiguration from './program-configuration';
 import {copyUniform, checkUniformValues} from './uniforms';
 
@@ -19,38 +19,38 @@ const LOG_PROGRAM_PERF_PRIORITY = 4;
 const GL_SEPARATE_ATTRIBS = 0x8c8d;
 
 export type ProgramProps = ResourceProps & {
-  hash?;
-  vs?; 
-  fs?;
-  varyings?; 
+  hash?: string;
+  vs?: string | Shader;
+  fs?: string | Shader;
+  varyings?: string[];
   bufferMode?: number;
-}
+};
 
 export type ProgramDrawOptions = {
-  logPriority?: any;
-  drawMode?: any;
+  logPriority?: number;
+  drawMode?: number;
   vertexCount: any;
   offset?: number;
-  start?: any;
-  end?: any;
+  start?: number;
+  end?: number;
   isIndexed?: boolean;
   indexType?: any;
   instanceCount?: number;
   isInstanced?: boolean;
   vertexArray?: any;
-  transformFeedback?: any;
-  framebuffer?: any;
+  transformFeedback?: any; // TransformFeedback;
+  framebuffer?: Framebuffer;
   parameters?: {};
-  uniforms?: any;
+  uniforms?: Record<string, any>;
   samplers?: any;
 };
 
 export default class Program extends WebGLResource<ProgramProps> {
   configuration: ProgramConfiguration;
   // Experimental flag to avoid deleting Program object while it is cached
-  hash: string;; // Used by ProgramManager
-  vs;
-  fs;
+  hash: string; // Used by ProgramManager
+  vs: WEBGLShader;
+  fs: WEBGLShader;
   uniforms: Record<string, any>;
   varyings: Record<string, any>;
   _textureUniforms: Record<string, any>;
@@ -58,18 +58,30 @@ export default class Program extends WebGLResource<ProgramProps> {
   _textureIndexCounter: number = 0;
   _uniformCount: number = 0;
   _uniformSetters: Record<string, Function>;
-  
-  constructor(gl: WebGLRenderingContext, props: ProgramProps = {}) {
-    super(WebGLDevice.attach(gl), props, {} as any);
-
 
+  constructor(device: WebGLDevice | WebGLRenderingContext, props: ProgramProps = {}) {
+    super(WebGLDevice.attach(device), props, {} as any);
     this.initialize(props);
-
     Object.seal(this);
-
     this._setId(props.id);
   }
 
+  destroy(options = {}) {
+    if (this._isCached) {
+      // This object is cached, do not delete
+      return this;
+    }
+    return super.delete(options);
+  }
+
+  delete(options = {}) {
+    if (this._isCached) {
+      // This object is cached, do not delete
+      return this;
+    }
+    return super.delete(options);
+  }
+
   initialize(props: ProgramProps = {}) {
     const {hash, vs, fs, varyings, bufferMode = GL_SEPARATE_ATTRIBS} = props;
 
@@ -77,15 +89,18 @@ export default class Program extends WebGLResource<ProgramProps> {
 
     // Create shaders if needed
     this.vs =
-      typeof vs === 'string' ? new VertexShader(this.gl, {id: `${props.id}-vs`, source: vs}) : vs;
+      typeof vs === 'string'
+        ? this.device.createShader({id: `${props.id}-vs`, source: vs, stage: 'vertex'})
+        : cast<WEBGLShader>(vs);
     this.fs =
-      typeof fs === 'string' ? new FragmentShader(this.gl, {id: `${props.id}-fs`, source: fs}) : fs;
-    assert(this.vs instanceof VertexShader);
-    assert(this.fs instanceof FragmentShader);
+      typeof fs === 'string'
+        ? this.device.createShader({id: `${props.id}-fs`, source: fs, stage: 'fragment'})
+        : cast<WEBGLShader>(fs);
+    assert(this.vs.stage === 'vertex');
+    assert(this.fs.stage === 'fragment');
 
     // uniforms
     this.uniforms = {};
-
     this._textureUniforms = {};
 
     // Setup varyings if supplied
@@ -102,14 +117,6 @@ export default class Program extends WebGLResource<ProgramProps> {
     return this.setProps(props);
   }
 
-  delete(options = {}) {
-    if (this._isCached) {
-      // This object is cached, do not delete
-      return this;
-    }
-    return super.delete(options);
-  }
-
   setProps(props) {
     if ('uniforms' in props) {
       this.setUniforms(props.uniforms);
@@ -121,30 +128,30 @@ export default class Program extends WebGLResource<ProgramProps> {
   // This function unifies those ways into a single call using common parameters with sane defaults
   draw(options: ProgramDrawOptions): boolean {
     const {
-    logPriority, // Probe log priority, enables Model to do more integrated logging
-
-    drawMode = GL.TRIANGLES,
-    vertexCount,
-    offset = 0,
-    start,
-    end,
-    isIndexed = false,
-    indexType = GL.UNSIGNED_SHORT,
-    instanceCount = 0,
-    isInstanced = instanceCount > 0,
-
-    vertexArray = null,
-    transformFeedback,
-    framebuffer,
-
-    // Deprecated
-    uniforms,
-    samplers
-  } = options;
-
-  let {parameters = {}} = options;
-
-  if (uniforms || samplers) {
+      logPriority, // Probe log priority, enables Model to do more integrated logging
+
+      drawMode = GL.TRIANGLES,
+      vertexCount,
+      offset = 0,
+      start,
+      end,
+      isIndexed = false,
+      indexType = GL.UNSIGNED_SHORT,
+      instanceCount = 0,
+      isInstanced = instanceCount > 0,
+
+      vertexArray = null,
+      transformFeedback,
+      framebuffer,
+
+      // Deprecated
+      uniforms,
+      samplers
+    } = options;
+
+    let {parameters = {}} = options;
+
+    if (uniforms || samplers) {
       // DEPRECATED: v7.0 (deprecated earlier but warning not properly implemented)
       log.deprecated('Program.draw({uniforms})', 'Program.setUniforms(uniforms)')();
       this.setUniforms(uniforms || {});
@@ -342,7 +349,8 @@ export default class Program extends WebGLResource<ProgramProps> {
 
   // Generate a default name for the program based on names of the shaders
   _getName() {
-    let programName = this.vs.getName() || this.fs.getName();
+    // let programName = this.vs.getName() || this.fs.getName();
+    let programName = this.vs.id || this.fs.id;
     programName = programName.replace(/shader/i, '');
     programName = programName ? `${programName}-program` : 'program';
     return programName;

package/src/classes/query.ts

@@ -1,6 +1,6 @@
 // WebGL2 Query (also handles disjoint timer extensions)
 import {assert} from '@luma.gl/api';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 import {isWebGL2} from '../context/context/webgl-checks';
 import WebGLResource, {ResourceProps} from './webgl-resource';
 

package/src/classes/renderbuffer.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-inline-comments */
 import {assert} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 import WebGLResource, {ResourceProps} from './webgl-resource';
 import {isRenderbufferFormatSupported, getRenderbufferFormatBytesPerPixel} from './renderbuffer-formats';
 import {isWebGL2} from '../context/context/webgl-checks';

package/src/classes/{webgl-shader.ts → shader.ts}

@@ -1,82 +1,18 @@
 // luma.gl, MIT license
-import {log, assert, uid, Shader as ShaderAPI, ShaderProps} from '@luma.gl/api';
+import {assert, uid, ShaderProps} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import {getShaderInfo, CompilerMessage, formatCompilerLog} from '@luma.gl/shadertools';
+import {getShaderInfo} from '@luma.gl/shadertools';
 import {assertWebGLContext} from '../context/context/webgl-checks';
-import {parseShaderCompilerLog} from '../webgl-utils/parse-shader-compiler-log';
-import WebGLDevice from '../device/webgl-device';
+import {WEBGLShader} from '../adapter/webgl-shader'
+import WebGLDevice from '../adapter/webgl-device'
 
 const ERR_SOURCE = 'Shader: GLSL source code must be a JavaScript string';
 
-
 export type {ShaderProps};
 
-export class WEBGLShader extends ShaderAPI {
-  readonly device: WebGLDevice;
-  readonly gl: WebGLRenderingContext;
-  readonly handle: WebGLShader;
-
-  readonly stage: 'vertex' | 'fragment';
-
-  constructor(gl: WebGLRenderingContext, props: ShaderProps) {
-    super(WebGLDevice.attach(gl), {id: getShaderIdFromProps(props), ...props});
-    this.device = WebGLDevice.attach(gl);
-    this.gl = gl;
-    switch (this.props.stage) {
-      case 'vertex':
-        this.handle = this.props.handle || this.gl.createShader(GL.VERTEX_SHADER);
-        break;
-      case 'fragment':
-        this.handle = this.props.handle || this.gl.createShader(GL.FRAGMENT_SHADER);
-        break;
-      default:
-        throw new Error(this.props.stage);
-    }
-    this.stage = this.props.stage;
-    this._compile(props.source);
-  }
-
-  destroy(): void {
-    if (this.handle) {
-      this.removeStats();
-      this.gl.deleteShader(this.handle);
-      // @ts-expect-error
-      this.handle = null;
-    }
-  }  
-  
-  async compilationInfo(): Promise<readonly CompilerMessage[]> {
-    const log = this.gl.getShaderInfoLog(this.handle);
-    return parseShaderCompilerLog(log);
-  }
-
-  // PRIVATE METHODS
-  _compile(source) {
-    if (!source.startsWith('#version ')) {
-      source = `#version 100\n${source}`;
-    }
-    this.gl.shaderSource(this.handle, source);
-    this.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 = this.gl.getShaderParameter(this.handle, GL.COMPILE_STATUS);
-    if (!compileStatus) {
-      const shaderLog = this.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 ${shaderName}\n${formattedLog}`)();
-      throw new Error(`GLSL compilation errors in ${shaderName}`);
-    }
-  }
-}
- 
 /**
  * Encapsulates the compiled or linked Shaders that execute portions of the WebGL Pipeline
- * For now this is an internal class
+ * This is an internal class, use FragmentShader or VertexShader
  */
 export class Shader extends WEBGLShader {
   shaderType: GL.FRAGMENT_SHADER | GL.VERTEX_SHADER;
@@ -97,9 +33,7 @@ export class Shader extends WEBGLShader {
   constructor(gl: WebGLRenderingContext, props: Omit<ShaderProps, 'stage'>) {
     assertWebGLContext(gl);
     assert(typeof props.source === 'string', ERR_SOURCE);
-
-    // @ts-expect-error
-    super(gl, {...props, id: getShaderIdFromProps(props), stage: props.shaderType === GL.VERTEX_SHADER ? 'vertex' : 'fragment'});
+    super(WebGLDevice.attach(gl), {...props, stage: props.shaderType === GL.VERTEX_SHADER ? 'vertex' : 'fragment'});
 
     this.shaderType = props.shaderType;
     this.source = props.source;
@@ -193,10 +127,3 @@ function getShaderProps(props: Omit<ShaderProps, 'stage'> | string, shaderType:
   }
   return {...props, shaderType};
 }
-
-/** 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.getTypeName(props.shaderType)}`);
-}

package/src/classes/texture-3d.ts

@@ -1,6 +1,6 @@
 import {Device} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 import {assertWebGL2Context} from '../context/context/webgl-checks';
 import {withParameters} from '../context/state-tracker/with-parameters';
 import Texture, {TextureProps} from './texture';

package/src/classes/texture-cube.ts

@@ -1,6 +1,6 @@
 import {Device, log} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 import {assertWebGLContext} from '../context/context/webgl-checks';
 import Texture, {TextureProps} from './texture';
 

package/src/classes/texture.ts

@@ -4,7 +4,7 @@ import GL from '@luma.gl/constants';
 import {isWebGL2, assertWebGL2Context} from '../context/context/webgl-checks';
 import {withParameters} from '../context/state-tracker/with-parameters';
 import {getKey, getKeyValue} from '../webgl-utils/constants-to-keys';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 import Buffer from './webgl-buffer';
 import {
   TEXTURE_FORMATS,

package/src/classes/transform-feedback.ts

@@ -1,6 +1,6 @@
 import {log, isObjectEmpty} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 import {isWebGL2, assertWebGL2Context} from '../context/context/webgl-checks';
 import WebGLResource, {ResourceProps} from './webgl-resource';
 import Buffer from './webgl-buffer';

package/src/classes/vertex-array-object.ts

@@ -1,7 +1,8 @@
+import type {NumberArray} from '@luma.gl/api';
 import {assert, getScratchArray, fillArray} from '@luma.gl/api';
 import GL from '@luma.gl/constants';
 import {getBrowser} from '@probe.gl/env';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 import {assertWebGL2Context, isWebGL2} from '../context/context/webgl-checks';
 import Program from './program';
 import WebGLResource, {ResourceProps} from './webgl-resource';
@@ -83,13 +84,13 @@ export default class VertexArrayObject extends WebGLResource<VertexArrayObjectPr
   private isDefaultArray: boolean = false;
 
   // Create a VertexArray
-  constructor(gl: WebGLRenderingContext, opts?: VertexArrayObjectProps) {
+  constructor(gl: WebGLRenderingContext, props?: VertexArrayObjectProps) {
     // Use program's id if program but no id is supplied
-    super(WebGLDevice.attach(gl), {...opts, id: opts?.id || (opts?.program && opts?.program.id)}, {} as any);
+    super(WebGLDevice.attach(gl), {...props, id: props?.id || (props?.program && props?.program.id)}, {} as any);
 
     this.buffer = null;
     this.bufferValue = null;
-    this.isDefaultArray = opts?.isDefaultArray || false;
+    this.isDefaultArray = props?.isDefaultArray || false;
 
     Object.seal(this);
   }
@@ -108,7 +109,7 @@ export default class VertexArrayObject extends WebGLResource<VertexArrayObjectPr
 
   // Set (bind) an elements buffer, for indexed rendering.
   // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
-  setElementBuffer(elementBuffer = null, opts = {}) {
+  setElementBuffer(elementBuffer: Buffer = null, opts = {}) {
     assert(!elementBuffer || elementBuffer.target === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
 
     // The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject...
@@ -120,7 +121,7 @@ export default class VertexArrayObject extends WebGLResource<VertexArrayObjectPr
   }
 
   /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
-  setBuffer(location, buffer, accessor): this {
+  setBuffer(location: number, buffer: Buffer, accessor: any): this {
     // Check target
     if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {
       return this.setElementBuffer(buffer, accessor);
@@ -158,7 +159,7 @@ export default class VertexArrayObject extends WebGLResource<VertexArrayObjectPr
    * TODO - handle single values for size 1 attributes?
    * TODO - convert classic arrays based on known type?
    */ 
-  enable(location, enable = true): this {
+  enable(location: number, enable = true): this {
     // Attribute 0 cannot be disabled in most desktop OpenGL based browsers
     const disablingAttributeZero =
       !enable &&
@@ -227,7 +228,7 @@ export default class VertexArrayObject extends WebGLResource<VertexArrayObjectPr
 
   // TODO - convert Arrays based on known type? (read type from accessor, don't assume Float32Array)
   // TODO - handle single values for size 1 attributes?
-  _normalizeConstantArrayValue(arrayValue) {
+  _normalizeConstantArrayValue(arrayValue: NumberArray) {
     if (Array.isArray(arrayValue)) {
       return new Float32Array(arrayValue);
     }

package/src/classes/vertex-array.ts

@@ -3,6 +3,7 @@ import GL from '@luma.gl/constants';
 import Accessor from './accessor';
 import Buffer from './webgl-buffer';
 import Program from './program'; 
+import type {AttributeBinding} from '../helpers/program-bindings'
 import ProgramConfiguration from './program-configuration';
 import VertexArrayObject, {VertexArrayObjectProps} from './vertex-array-object';
 
@@ -165,7 +166,7 @@ export default class VertexArray {
   }
 
   // Set a location in vertex attributes array to a buffer
-  setBuffer(locationOrName, buffer: Buffer, appAccessor = {}): this {
+  setBuffer(locationOrName: number | string, buffer: Buffer, appAccessor = {}): this {
     // Check target
     if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {
       this.setElementBuffer(buffer, appAccessor);
@@ -317,18 +318,18 @@ export default class VertexArray {
     return {location, accessor};
   }
 
-  _getAttributeInfo(attributeName) {
+  _getAttributeInfo(attributeName: string | number): AttributeBinding {
     return this.configuration && this.configuration.getAttributeInfo(attributeName);
   }
 
-  _getAttributeIndex(locationOrName) {
+  _getAttributeIndex(locationOrName: number | string): {location: number, name?: string} {
     const location = Number(locationOrName);
     if (Number.isFinite(location)) {
       return {location};
     }
 
-    const multiLocation = MULTI_LOCATION_ATTRIBUTE_REGEXP.exec(locationOrName);
-    const name = multiLocation ? multiLocation[1] : locationOrName;
+    const multiLocation = MULTI_LOCATION_ATTRIBUTE_REGEXP.exec(String(locationOrName));
+    const name = multiLocation ? multiLocation[1] : String(locationOrName);
     const locationOffset = multiLocation ? Number(multiLocation[2]) : 0;
 
     if (this.configuration) {
@@ -341,7 +342,12 @@ export default class VertexArray {
     return {location: -1};
   }
 
-  _setAttribute(locationOrName, value): void {
+  _setAttribute(locationOrName: number | string, value: Buffer): void;
+  _setAttribute(locationOrName: number | string, value: [Buffer, any]): void;
+  _setAttribute(locationOrName: number | string, value: ArrayBuffer | any[]): void;
+  _setAttribute(locationOrName: number | string, value: {value: Buffer}): void;
+
+  _setAttribute(locationOrName: number | string, value): void {
     if (value instanceof Buffer) {
       //  Signature: {attributeName: Buffer}
       this.setBuffer(locationOrName, value);
@@ -368,7 +374,7 @@ export default class VertexArray {
   // Updates all constant attribute values (constants are used when vertex attributes are disabled).
   // This needs to be done repeatedly since in contrast to buffer bindings,
   // constants are stored on the WebGL context, not the VAO
-  _setConstantAttributes(vertexCount, instanceCount): void {
+  _setConstantAttributes(vertexCount: number, instanceCount: number): void {
     // TODO - use accessor to determine what length to use
     const elementCount = Math.max(vertexCount | 0, instanceCount | 0);
     let constant = this.values[0];
@@ -397,7 +403,7 @@ export default class VertexArray {
     this.vertexArrayObject.setBuffer(0, buffer, this.accessors[0]);
   }
 
-  _setConstantAttribute(location, constant): void {
+  _setConstantAttribute(location: number | string, constant): void {
     VertexArrayObject.setConstant(this.gl, location, constant);
   }
 

package/src/classes/webgl-buffer.ts

@@ -5,7 +5,7 @@ import {getWebGL2Context, assertWebGL2Context} from '../context/context/webgl-ch
 import {AccessorObject} from '../types';
 import Accessor from './accessor';
 import {getGLTypeFromTypedArray, getTypedArrayFromGLType} from '../webgl-utils/typed-array-utils';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 
 const DEBUG_DATA_LENGTH = 10;
 

package/src/classes/webgl-resource.ts

@@ -4,7 +4,7 @@ import type {Device} from '@luma.gl/api';
 export type {ResourceProps} from '@luma.gl/api';
 import {isWebGL2, assertWebGLContext} from '../context/context/webgl-checks';
 import {getKey, getKeyValue} from '../webgl-utils/constants-to-keys';
-import WebGLDevice from '../device/webgl-device';
+import WebGLDevice from '../adapter/webgl-device';
 
 const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual methods';
 

package/src/context/parameters/unified-parameter-api.ts

@@ -81,8 +81,9 @@ export function setParameters(gl: WebGLRenderingContext, parameters: GLParameter
  * considered a very slow operation, to be used only if/when a context already manipulated
  * by external code needs to be synchronized for the first time
  */
- export function getParameters(gl: WebGLRenderingContext, parameters?: Record<keyof GLParameters, any>): GLParameters;
- export function getParameters(gl: WebGLRenderingContext, parameters: number): any;
+export function getParameters(gl: WebGLRenderingContext, parameters?: Record<keyof GLParameters, any>): GLParameters;
+export function getParameters(gl: WebGLRenderingContext, parameters?: (keyof GLParameters)[]): GLParameters;
+export function getParameters(gl: WebGLRenderingContext, parameters: keyof GLParameters): GLParameters;
 
 export function getParameters(gl, parameters) {
   // default to querying all parameters