12258388188

Committed 10 Dec 2024 02:36PM UTC coverage: 75.332% (-0.008%) from 75.34%

Build # 12258388188

Build Type

push

github

Committed by

web-flow

Commit Message

fix(webgl): Fix webglAdapter.attach() (#2299)

Run Details

2018 of 2645 branches covered (76.29%)

Branch coverage included in aggregate %.

20 of 28 new or added lines in 2 files covered. (71.43%)

1 existing line in 1 file now uncovered.

26236 of 34861 relevant lines covered (75.26%)

50.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.91

/modules/webgl/src/adapter/webgl-adapter.ts

// luma.gl
// SPDX-License-Identifier: MIT
// Copyright (c) vis.gl contributors

import type {WebGLDevice} from './webgl-device';
import {Adapter, Device, DeviceProps, log} from '@luma.gl/core';
import {enforceWebGL2} from '../context/polyfills/polyfill-webgl1-extensions';
import {loadSpectorJS, DEFAULT_SPECTOR_PROPS} from '../context/debug/spector';
import {loadWebGLDeveloperTools} from '../context/debug/webgl-developer-tools';

const LOG_LEVEL = 1;

export class WebGLAdapter extends Adapter {
  /** type of device's created by this adapter */
  readonly type: Device['type'] = 'webgl';

  constructor() {
    super();
    // Add spector default props to device default props, so that runtime settings are observed
    Device.defaultProps = {...Device.defaultProps, ...DEFAULT_SPECTOR_PROPS};
  }

  /** Force any created WebGL contexts to be WebGL2 contexts, polyfilled with WebGL1 extensions */
  enforceWebGL2(enable: boolean): void {
    enforceWebGL2(enable);
  }

  /** Check if WebGL 2 is available */
  isSupported(): boolean {
    return typeof WebGL2RenderingContext !== 'undefined';
  }

  override isDeviceHandle(handle: unknown): boolean {
    // WebGL
    if (typeof WebGL2RenderingContext !== 'undefined' && handle instanceof WebGL2RenderingContext) {
      return true;
    }

    if (typeof WebGLRenderingContext !== 'undefined' && handle instanceof WebGLRenderingContext) {
      log.warn('WebGL1 is not supported', handle)();
    }

    return false;
  }

  /**
   * Get a device instance from a GL context
   * Creates a WebGLCanvasContext against the contexts canvas
   * @note autoResize will be disabled, assuming that whoever created the external context will be handling resizes.
   * @param gl
   * @returns
   */
  async attach(gl: Device | WebGL2RenderingContext): Promise<WebGLDevice> {
    const {WebGLDevice} = await import('./webgl-device');
    if (gl instanceof WebGLDevice) {
      return gl;
    }
    // @ts-expect-error
    if (gl?.device instanceof WebGLDevice) {
      // @ts-expect-error
      return gl.device as WebGLDevice;
    }
    if (!isWebGL(gl)) {
      throw new Error('Invalid WebGL2RenderingContext');
    }

    // We create a new device using the provided WebGL context and its canvas
    // Assume that whoever created the external context will be handling resizes.
    return new WebGLDevice({
      _handle: gl,
      createCanvasContext: {canvas: gl.canvas, autoResize: false}
    });
  }

  async create(props: DeviceProps = {}): Promise<WebGLDevice> {
    const {WebGLDevice} = await import('./webgl-device');

    log.groupCollapsed(LOG_LEVEL, 'WebGLDevice created')();

    const promises: Promise<unknown>[] = [];

    // Load webgl and spector debug scripts from CDN if requested
    if (props.debugWebGL || props.debug) {
      promises.push(loadWebGLDeveloperTools());
    }

    if (props.debugSpectorJS) {
      promises.push(loadSpectorJS(props));
    }

    // Wait for all the loads to settle before creating the context.
    // The Device.create() functions are async, so in contrast to the constructor, we can `await` here.
    const results = await Promise.allSettled(promises);
    for (const result of results) {
      if (result.status === 'rejected') {
        log.error(`Failed to initialize debug libraries ${result.reason}`)();
      }
    }

    const device = new WebGLDevice(props);

    // Log some debug info about the newly created context
    const message = `\
Created ${device.type}${device.debug ? ' debug' : ''} context: \
${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
    log.probe(LOG_LEVEL, message)();
    log.table(LOG_LEVEL, device.info)();

    log.groupEnd(LOG_LEVEL)();

    return device;
  }
}

/** Check if supplied parameter is a WebGL2RenderingContext */
function isWebGL(gl: any): gl is WebGL2RenderingContext {
  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
    return true;
  }
  // Look for debug contexts, headless gl etc
  return Boolean(gl && Number.isFinite(gl._version));
}

export const webgl2Adapter = new WebGLAdapter();

1	// luma.gl	1✔
2	// SPDX-License-Identifier: MIT	1✔
3	// Copyright (c) vis.gl contributors	1✔
4		1✔
5	import type {WebGLDevice} from './webgl-device';	1✔
6	import {Adapter, Device, DeviceProps, log} from '@luma.gl/core';	1✔
7	import {enforceWebGL2} from '../context/polyfills/polyfill-webgl1-extensions';	1✔
8	import {loadSpectorJS, DEFAULT_SPECTOR_PROPS} from '../context/debug/spector';	1✔
9	import {loadWebGLDeveloperTools} from '../context/debug/webgl-developer-tools';	1✔
10		1✔
11	const LOG_LEVEL = 1;	1✔
12		1✔
13	export class WebGLAdapter extends Adapter {	1✔
14	/** type of device's created by this adapter */	1✔
15	readonly type: Device['type'] = 'webgl';	1✔
16		1✔
17	constructor() {	1✔
18	super();	1✔
19	// Add spector default props to device default props, so that runtime settings are observed	1✔
20	Device.defaultProps = {...Device.defaultProps, ...DEFAULT_SPECTOR_PROPS};	1✔
21	}	1✔
22		1✔
23	/** Force any created WebGL contexts to be WebGL2 contexts, polyfilled with WebGL1 extensions */	1✔
24	enforceWebGL2(enable: boolean): void {	1✔
25	enforceWebGL2(enable);	2✔
26	}	2✔
27		1✔
28	/** Check if WebGL 2 is available */	1✔
29	isSupported(): boolean {	1✔
30	return typeof WebGL2RenderingContext !== 'undefined';	1✔
31	}	1✔
32		1✔
33	override isDeviceHandle(handle: unknown): boolean {	1✔
34	// WebGL	×
35	if (typeof WebGL2RenderingContext !== 'undefined' && handle instanceof WebGL2RenderingContext) {	×
36	return true;	×
37	}	×
38		×
39	if (typeof WebGLRenderingContext !== 'undefined' && handle instanceof WebGLRenderingContext) {	×
40	log.warn('WebGL1 is not supported', handle)();	×
41	}	×
42		×
43	return false;	×
44	}	×
45		1✔
46	/**	1✔
47	* Get a device instance from a GL context	1✔
48	* Creates a WebGLCanvasContext against the contexts canvas	1✔
49	* @note autoResize will be disabled, assuming that whoever created the external context will be handling resizes.	1✔
50	* @param gl	1✔
51	* @returns	1✔
52	*/	1✔
53	async attach(gl: Device \| WebGL2RenderingContext): Promise<WebGLDevice> {	1✔
54	const {WebGLDevice} = await import('./webgl-device');	×
55	if (gl instanceof WebGLDevice) {	×
56	return gl;	×
57	}	×
58	// @ts-expect-error	×
59	if (gl?.device instanceof WebGLDevice) {	×
60	// @ts-expect-error	×
61	return gl.device as WebGLDevice;	×
62	}	×
63	if (!isWebGL(gl)) {	×
64	throw new Error('Invalid WebGL2RenderingContext');	×
65	}	×
NEW 66		×
NEW 67	// We create a new device using the provided WebGL context and its canvas	×
NEW 68	// Assume that whoever created the external context will be handling resizes.	×
NEW 69	return new WebGLDevice({	×
NEW 70	_handle: gl,	×
NEW 71	createCanvasContext: {canvas: gl.canvas, autoResize: false}	×
NEW 72	});	×
UNCOV 73	}	×
74		1✔
75	async create(props: DeviceProps = {}): Promise<WebGLDevice> {	1✔
76	const {WebGLDevice} = await import('./webgl-device');	3✔
77		3✔
78	log.groupCollapsed(LOG_LEVEL, 'WebGLDevice created')();	3✔
79		3✔
80	const promises: Promise<unknown>[] = [];	3✔
81		3✔
82	// Load webgl and spector debug scripts from CDN if requested	3✔
83	if (props.debugWebGL \|\| props.debug) {	3✔
84	promises.push(loadWebGLDeveloperTools());	1✔
85	}	1✔
86		3✔
87	if (props.debugSpectorJS) {	3!
88	promises.push(loadSpectorJS(props));	×
89	}	×
90		3✔
91	// Wait for all the loads to settle before creating the context.	3✔
92	// The Device.create() functions are async, so in contrast to the constructor, we can `await` here.	3✔
93	const results = await Promise.allSettled(promises);	3✔
94	for (const result of results) {	3✔
95	if (result.status === 'rejected') {	1!
96	log.error(`Failed to initialize debug libraries ${result.reason}`)();	×
97	}	×
98	}	1✔
99		3✔
100	const device = new WebGLDevice(props);	3✔
101		3✔
102	// Log some debug info about the newly created context	3✔
103	const message = `\	3✔
104	Created ${device.type}${device.debug ? ' debug' : ''} context: \	3!
105	${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;	3✔
106	log.probe(LOG_LEVEL, message)();	3✔
107	log.table(LOG_LEVEL, device.info)();	3✔
108		3✔
109	log.groupEnd(LOG_LEVEL)();	3✔
110		3✔
111	return device;	3✔
112	}	3✔
113	}	1✔
114		1✔
115	/** Check if supplied parameter is a WebGL2RenderingContext */	1✔
NEW 116	function isWebGL(gl: any): gl is WebGL2RenderingContext {	×
117	if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {	×
118	return true;	×
119	}	×
120	// Look for debug contexts, headless gl etc	×
121	return Boolean(gl && Number.isFinite(gl._version));	×
122	}	×
123		1✔
124	export const webgl2Adapter = new WebGLAdapter();	1✔

visgl / luma.gl / 12258388188

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous