@luma.gl/webgl 9.0.0-beta.1 → 9.0.0-beta.10

package/src/classic/copy-and-blit.ts

@@ -1,10 +1,11 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {assert, Buffer, Texture, Framebuffer, FramebufferProps} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
 
-import {WEBGLTexture} from '../adapter/resources/webgl-texture';
+import {WEBGLTextureView} from '../adapter/resources/webgl-texture-view';
 import {WEBGLFramebuffer} from '../adapter/resources/webgl-framebuffer';
 import {getGLTypeFromTypedArray, getTypedArrayFromGLType} from './typed-array-utils';
 import {glFormatToComponents, glTypeToBytes} from './format-utils';
@@ -66,7 +67,7 @@ export function readPixelsToArray(
   // Deduce the type from color attachment if not provided.
   sourceType =
     sourceType ||
-    (framebuffer.colorAttachments[attachment] as WEBGLTexture)?.type ||
+    (framebuffer.colorAttachments[attachment] as WEBGLTextureView)?.texture?.type ||
     GL.UNSIGNED_BYTE;
 
   // Deduce type and allocated pixelArray if needed
@@ -106,7 +107,13 @@ export function readPixelsToBuffer(
     sourceType?: number;
   }
 ): WEBGLBuffer {
-  const {target, sourceX = 0, sourceY = 0, sourceFormat = GL.RGBA, targetByteOffset = 0} = options || {};
+  const {
+    target,
+    sourceX = 0,
+    sourceY = 0,
+    sourceFormat = GL.RGBA,
+    targetByteOffset = 0
+  } = options || {};
   // following parameters are auto deduced if not provided
   let {sourceWidth, sourceHeight, sourceType} = options || {};
   const {framebuffer, deleteFramebuffer} = getFramebuffer(source);
@@ -240,8 +247,7 @@ export function copyToTexture(
         break;
       case GL.TEXTURE_2D_ARRAY:
       case GL.TEXTURE_3D:
-        device.assertWebGL2();
-        device.gl2.copyTexSubImage3D(
+        device.gl.copyTexSubImage3D(
           textureTarget,
           targetMipmaplevel,
           targetX,

package/src/classic/format-utils.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {assert} from '@luma.gl/core';

package/src/classic/typed-array-utils.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {TypedArray, TypedArrayConstructor} from '@luma.gl/core';
@@ -108,12 +109,7 @@ export function flipRows(options: {
   }
 }
 
-
-export function scalePixels(options: {
-  data: TypedArray;
-  width: number;
-  height: number;
-}): {
+export function scalePixels(options: {data: TypedArray; width: number; height: number}): {
   data: Uint8Array;
   width: number;
   height: number;

package/src/context/debug/spector.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {log, loadScript} from '@luma.gl/core';
@@ -34,8 +35,8 @@ export async function loadSpectorJS(props?: SpectorProps) {
   if (!globalThis.SPECTOR) {
     try {
       await loadScript(SPECTOR_CDN_URL);
-    } catch(error) {
-      log.warn(String(error))
+    } catch (error) {
+      log.warn(String(error));
     }
   }
 }
@@ -64,14 +65,16 @@ export function initializeSpectorJS(props?: SpectorProps) {
     // enables recording some extra information merged in the capture like texture memory sizes and formats
     spector.spyCanvases();
     // A callback when results are ready
-    spector?.onCaptureStarted.add((capture: unknown) => log.info('Spector capture started:', capture)());
+    spector?.onCaptureStarted.add((capture: unknown) =>
+      log.info('Spector capture started:', capture)()
+    );
     spector?.onCapture.add((capture: unknown) => {
       log.info('Spector capture complete:', capture)();
       // Use undocumented Spector API to open the UI with our capture
       // See https://github.com/BabylonJS/Spector.js/blob/767ad1195a25b85a85c381f400eb50a979239eca/src/spector.ts#L124
-      spector?.getResultUI()
+      spector?.getResultUI();
       spector?.resultView.display();
-      spector?.resultView.addCapture(capture)
+      spector?.resultView.addCapture(capture);
     });
   }
 

package/src/context/debug/webgl-developer-tools.ts

@@ -1,10 +1,11 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {log, loadScript} from '@luma.gl/core';
 // Rename constant to prevent inlining. We need the full set of constants for generating debug strings.
 import {GL as GLEnum} from '@luma.gl/constants';
-import {isBrowser} from '@probe.gl/env'
+import {isBrowser} from '@probe.gl/env';
 
 const WEBGL_DEBUG_CDN_URL = 'https://unpkg.com/webgl-debug@2.0.1/index.js';
 
@@ -12,7 +13,6 @@ type DebugContextProps = {
   debug?: boolean;
   throwOnError?: boolean;
   break?: string[];
-  webgl2?: boolean;
 };
 
 // const DEFAULT_DEBUG_CONTEXT_PROPS: Required<DebugContextProps> = {
@@ -23,12 +23,12 @@ type DebugContextProps = {
 // }
 
 type ContextData = {
-  realContext?: WebGLRenderingContext;
-  debugContext?: WebGLRenderingContext;
-}
+  realContext?: WebGL2RenderingContext;
+  debugContext?: WebGL2RenderingContext;
+};
 
 // Helper to get shared context data
-function getContextData(gl: any): ContextData {
+function getWebGLContextData(gl: any): ContextData {
   gl.luma = gl.luma || {};
   return gl.luma;
 }
@@ -39,7 +39,7 @@ declare global {
 }
 
 /**
- * Loads Khronos WebGLDeveloperTools from CDN if not already installed 
+ * Loads Khronos WebGLDeveloperTools from CDN if not already installed
  * const WebGLDebugUtils = require('webgl-debug');
  * @see https://github.com/KhronosGroup/WebGLDeveloperTools
  * @see https://github.com/vorg/webgl-debug
@@ -55,7 +55,10 @@ export async function loadWebGLDeveloperTools(): Promise<void> {
 
 // Returns (a potentially new) context with debug instrumentation turned off or on.
 // Note that this actually returns a new context
-export function makeDebugContext(gl: WebGLRenderingContext, props: DebugContextProps = {}): WebGLRenderingContext | null {
+export function makeDebugContext(
+  gl: WebGL2RenderingContext,
+  props: DebugContextProps = {}
+): WebGL2RenderingContext | null {
   // Return null to ensure we don't try to create a context in this case (TODO what case is that?)
   if (!gl) {
     return null;
@@ -65,20 +68,23 @@ export function makeDebugContext(gl: WebGLRenderingContext, props: DebugContextP
 }
 
 // Returns the real context from either of the real/debug contexts
-function getRealContext(gl: WebGLRenderingContext): WebGLRenderingContext {
-  const data = getContextData(gl);
+function getRealContext(gl: WebGL2RenderingContext): WebGL2RenderingContext {
+  const data = getWebGLContextData(gl);
   // If the context has a realContext member, it is a debug context so return the realContext
   return data.realContext ? data.realContext : gl;
 }
 
 // Returns the debug context from either of the real/debug contexts
-function getDebugContext(gl: WebGLRenderingContext, props: DebugContextProps): WebGLRenderingContext {
+function getDebugContext(
+  gl: WebGL2RenderingContext,
+  props: DebugContextProps
+): WebGL2RenderingContext {
   if (!globalThis.WebGLDebugUtils) {
     log.warn('webgl-debug not loaded')();
     return gl;
   }
 
-  const data = getContextData(gl);
+  const data = getWebGLContextData(gl);
 
   // If this already has a debug context, return it.
   if (data.debugContext) {
@@ -99,7 +105,7 @@ function getDebugContext(gl: WebGLRenderingContext, props: DebugContextProps): W
       glDebug[key] = GLEnum[key];
     }
   }
-  
+
   // Ensure we have a clean prototype on the instrumented object
   // Note: setPrototypeOf does come with perf warnings, but we already take a bigger perf reduction
   // by synchronizing the WebGL errors after each WebGL call.
@@ -120,7 +126,7 @@ function getDebugContext(gl: WebGLRenderingContext, props: DebugContextProps): W
 
 function getFunctionString(functionName: string, functionArgs): string {
   // Cover bug in webgl-debug-tools
-  functionArgs = Array.from(functionArgs).map(arg => arg === undefined ? 'undefined' : arg);
+  functionArgs = Array.from(functionArgs).map(arg => (arg === undefined ? 'undefined' : arg));
   let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs);
   args = `${args.slice(0, 100)}${args.length > 100 ? '...' : ''}`;
   return `gl.${functionName}(${args})`;
@@ -128,11 +134,10 @@ function getFunctionString(functionName: string, functionArgs): string {
 
 function onGLError(props: DebugContextProps, err, functionName: string, args: any[]): void {
   // Cover bug in webgl-debug-tools
-  args = Array.from(args).map(arg => arg === undefined ? 'undefined' : arg);
+  args = Array.from(args).map(arg => (arg === undefined ? 'undefined' : arg));
   const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);
   const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);
-  const glName = props.webgl2 ? 'gl2' : 'gl1';
-  const message = `${errorMessage} in ${glName}.${functionName}(${functionArgs})`;
+  const message = `${errorMessage} in gl.${functionName}(${functionArgs})`;
   log.error(message)();
   debugger; // eslint-disable-line
   if (props.throwOnError) {
@@ -141,7 +146,11 @@ function onGLError(props: DebugContextProps, err, functionName: string, args: an
 }
 
 // Don't generate function string until it is needed
-function onValidateGLFunc(props: DebugContextProps, functionName: string, functionArgs: any[]): void {
+function onValidateGLFunc(
+  props: DebugContextProps,
+  functionName: string,
+  functionArgs: any[]
+): void {
   let functionString: string = '';
   if (log.level >= 1) {
     functionString = getFunctionString(functionName, functionArgs);
@@ -151,7 +160,9 @@ function onValidateGLFunc(props: DebugContextProps, functionName: string, functi
   // If array of breakpoint strings supplied, check if any of them is contained in current GLEnum function
   if (props.break && props.break.length > 0) {
     functionString = functionString || getFunctionString(functionName, functionArgs);
-    const isBreakpoint = props.break.every((breakOn: string) => functionString.indexOf(breakOn) !== -1);
+    const isBreakpoint = props.break.every(
+      (breakOn: string) => functionString.indexOf(breakOn) !== -1
+    );
     if (isBreakpoint) {
       debugger; // eslint-disable-line
     }

package/src/context/{context → helpers}/create-browser-context.ts

@@ -1,10 +1,9 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 /**
  * ContextProps
- * @param webgl2 Set to false to not create a WebGL2 context (force webgl1)
- * @param webgl1 set to false to not create a WebGL1 context (fail if webgl2 not available)
  * @param onContextLost
  * @param onContextRestored
  *
@@ -19,9 +18,6 @@
  * @param failIfMajorPerformanceCaveat Do not create if the system performance is low.
  */
 type ContextProps = {
-  type?: 'webgl' | 'webgl1' | 'webgl2' | string;
-  webgl1?: boolean;
-  webgl2?: boolean;
   onContextLost?: (event: Event) => void;
   onContextRestored?: (event: Event) => void;
   alpha?: boolean; // indicates if the canvas contains an alpha buffer.
@@ -35,8 +31,6 @@ type ContextProps = {
 };
 
 const DEFAULT_CONTEXT_PROPS: ContextProps = {
-  webgl2: true, // Attempt to create a WebGL2 context
-  webgl1: true, // Attempt to create a WebGL1 context (false to fail if webgl2 not available)
   powerPreference: 'high-performance', // After all, most apps are using WebGL for performance reasons
   // eslint-disable-next-line no-console
   onContextLost: () => console.error('WebGL context lost'),
@@ -52,7 +46,7 @@ const DEFAULT_CONTEXT_PROPS: ContextProps = {
 export function createBrowserContext(
   canvas: HTMLCanvasElement | OffscreenCanvas,
   props: ContextProps
-): WebGLRenderingContext {
+): WebGL2RenderingContext {
   props = {...DEFAULT_CONTEXT_PROPS, ...props};
 
   // Try to extract any extra information about why context creation failed
@@ -61,31 +55,17 @@ export function createBrowserContext(
   canvas.addEventListener('webglcontextcreationerror', onCreateError, false);
 
   // Create the desired context
-  let gl: WebGLRenderingContext | WebGL2RenderingContext | null = null;
-
-  if (props.type === 'webgl2') {
-    props = {...props, webgl1: false};
-  }
-  if (props.type === 'webgl1') {
-    props = {...props, webgl2: false};
-  }
+  let gl: WebGL2RenderingContext | null = null;
 
   // props.failIfMajorPerformanceCaveat = true;
 
-  // Prefer webgl2 over webgl1 if both are acceptable
-  if (!gl && props.webgl2) {
-    gl = canvas.getContext('webgl2', props) as WebGL2RenderingContext;
-  }
-  if (!gl && props.webgl1) {
-    gl = canvas.getContext('webgl', props) as WebGLRenderingContext;
-  }
+  // We require webgl2 context
+  gl ||= canvas.getContext('webgl2', props) as WebGL2RenderingContext;
 
   // Software GPU
 
   // props.failIfMajorPerformanceCaveat = false;
-  // if (!gl && props.webgl2) {
-  //   gl = canvas.getContext('webgl2', props);
-  // }
+
   // if (!gl && props.webgl1) {
   //   gl = canvas.getContext('webgl', props);
   // }
@@ -94,11 +74,7 @@ export function createBrowserContext(
   canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);
 
   if (!gl) {
-    throw new Error(
-      `Failed to create ${props.webgl2 && !props.webgl1 ? 'WebGL2' : 'WebGL'} context: ${
-        errorMessage || 'Unknown error'
-      }`
-    );
+    throw new Error(`Failed to create WebGL context: ${errorMessage || 'Unknown error'}`);
   }
 
   if (props.onContextLost) {
@@ -120,7 +96,7 @@ export function createBrowserContext(
 }
 
 /* TODO - can we call this asynchronously to catch the error events?
-export async function createBrowserContextAsync(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): Promise<WebGLRenderingContext> {
+export async function createBrowserContextAsync(canvas: HTMLCanvasElement | OffscreenCanvas, props: ContextProps): Promise<WebGL2RenderingContext> {
   props = {...DEFAULT_CONTEXT_PROPS, ...props};
 
  // Try to extract any extra information about why context creation failed

package/src/context/{polyfill/context-data.ts → helpers/webgl-context-data.ts}

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 /**
@@ -13,7 +14,7 @@ export interface WebGLContextData {
  * Gets luma.gl specific state from a context
  * @returns context state
  */
-export function getContextData(gl: WebGLRenderingContext): WebGLContextData {
+export function getWebGLContextData(gl: WebGL2RenderingContext): WebGLContextData {
   // @ts-expect-error
   const luma = gl.luma as WebGLContextData | null;
   if (!luma) {

package/src/context/helpers/webgl-extensions.ts

@@ -0,0 +1,17 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {GLExtensions} from '@luma.gl/constants';
+
+/** Ensure extensions are only requested once */
+export function getWebGLExtension(
+  gl: WebGL2RenderingContext,
+  name: string,
+  extensions: GLExtensions
+): unknown {
+  if (extensions[name] === undefined) {
+    extensions[name] = gl.getExtension(name) || null;
+  }
+  return extensions[name];
+}

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

@@ -1,10 +1,10 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 // Provides a unified API for getting and setting any WebGL parameter
 // Also knows default values of all parameters, enabling fast cache initialization
 // Provides base functionality for the state caching.
-import {Device} from '@luma.gl/core';
 import type {GLParameters} from '@luma.gl/constants';
 import {
   GL_PARAMETER_DEFAULTS,
@@ -13,8 +13,6 @@ import {
   GL_PARAMETER_GETTERS
 } from './webgl-parameter-tables';
 
-import {WebGLDevice} from '../../adapter/webgl-device';
-
 export type {GLParameters};
 
 /**
@@ -23,13 +21,7 @@ export type {GLParameters};
  * @note requires a `cache` object to be set on the context (gl.state.cache)
  * This object is used to fill in any missing values for composite setter functions
  */
-export function setGLParameters(
-  device: Device | WebGLRenderingContext,
-  parameters: GLParameters
-): void {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
-
+export function setGLParameters(gl: WebGL2RenderingContext, parameters: GLParameters): void {
   if (isObjectEmpty(parameters)) {
     return;
   }
@@ -92,12 +84,9 @@ export function setGLParameters(
  * by external code needs to be synchronized for the first time
  */
 export function getGLParameters(
-  device: Device | WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   parameters: keyof GLParameters | (keyof GLParameters)[] | GLParameters = GL_PARAMETER_DEFAULTS
 ): GLParameters {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
-
   // support both arrays of parameters and objects (keys represent parameters)
 
   if (typeof parameters === 'number') {
@@ -123,8 +112,8 @@ export function getGLParameters(
  * NOT the canvas size dimensions, so they will have to be properly set after
  * calling this function.
  */
-export function resetGLParameters(device: Device | WebGLRenderingContext): void {
-  setGLParameters(device, GL_PARAMETER_DEFAULTS);
+export function resetGLParameters(gl: WebGL2RenderingContext): void {
+  setGLParameters(gl, GL_PARAMETER_DEFAULTS);
 }
 
 // Helpers