7224312233

Committed 15 Dec 2023 04:03PM UTC coverage: 72.792% (+0.08%) from 72.715%

Build # 7224312233

Build Type

Pull #1879

github

Committed by

web-flow

Commit Message

Merge 8d1b5b4d0 into 3cedfca24

Pull Request Pull Request #1879: [engine] Minimum Transform implementation

Run Details

1270 of 1715 branches covered (0.0%)

Branch coverage included in aggregate %.

111 of 146 new or added lines in 5 files covered. (76.03%)

7 existing lines in 1 file now uncovered.

21003 of 28883 relevant lines covered (72.72%)

16.4 hits per line

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

34.65

/modules/webgl/src/adapter/resources/webgl-transform-feedback.ts

import type {PrimitiveTopology, ShaderLayout, TransformFeedbackProps} from '@luma.gl/core';
import {log, TransformFeedback, Buffer, BufferRange} from '@luma.gl/core';
import {GL} from '@luma.gl/constants';
import {WebGLDevice} from '../webgl-device';
import {WEBGLBuffer} from '../..';
import {getGLPrimitive} from '../helpers/webgl-topology-utils';

export class WEBGLTransformFeedback extends TransformFeedback {
  readonly device: WebGLDevice;
  readonly gl2: WebGL2RenderingContext;
  readonly handle: WebGLTransformFeedback;

  /**
   * NOTE: The Model already has this information while drawing, but
   * TransformFeedback currently needs it internally, to look up
   * varying information outside of a draw() call.
   */
  readonly layout: ShaderLayout;
  buffers: Record<string, BufferRange> = {};
  unusedBuffers: Record<string, Buffer> = {};
  /**
   * Allows us to avoid a Chrome bug where a buffer that is already bound to a
   * different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
   * This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346
   */
  bindOnUse = true;
  private _bound: boolean = false;

  constructor(device: WebGLDevice, props: TransformFeedbackProps) {
    super(device, props);

    device.assertWebGL2();
    this.device = device;
    this.gl2 = device.gl2;
    this.handle = this.props.handle || this.gl2.createTransformFeedback();
    this.layout = this.props.layout;

    if (props.buffers) {
      this.setBuffers(props.buffers);
    }

    Object.seal(this);
  }

  override destroy(): void {
    this.gl2.deleteTransformFeedback(this.handle);
    super.destroy();
  }

  begin(topology: PrimitiveTopology = 'point-list'): void {
    this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, this.handle);
    if (this.bindOnUse) {
      this._bindBuffers();
    }
    this.gl2.beginTransformFeedback(getGLPrimitive(topology));
  }

  end(): void {
    this.gl2.endTransformFeedback();
    if (!this.bindOnUse) {
      this._unbindBuffers();
    }
    this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, null);
  }

  // SUBCLASS

  setBuffers(buffers: Record<string, Buffer | BufferRange>): void {
    this.buffers = {};
    this.unusedBuffers = {};

    this.bind(() => {
      for (const bufferName in buffers) {
        this.setBuffer(bufferName, buffers[bufferName]);
      }
    });
  }

  setBuffer(locationOrName: string | number, bufferOrRange: Buffer | BufferRange): void {
    const location = this._getVaryingIndex(locationOrName);
    const {buffer, byteLength, byteOffset} = this._getBufferRange(bufferOrRange);

    if (location < 0) {
      this.unusedBuffers[locationOrName] = buffer;
      log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
      return;
    }

    this.buffers[location] = {buffer, byteLength, byteOffset};

    // Need to avoid chrome bug where buffer that is already bound to a different target
    // cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
    if (!this.bindOnUse) {
      this._bindBuffer(location, buffer, byteOffset, byteLength);
    }
  }

  getBuffer(locationOrName: string | number): Buffer | BufferRange | null {
    if (isIndex(locationOrName)) {
      return this.buffers[locationOrName] || null;
    }
    const location = this._getVaryingIndex(locationOrName);
    return location >= 0 ? this.buffers[location] : null;
  }

  bind(funcOrHandle = this.handle) {
    if (typeof funcOrHandle !== 'function') {
      this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, funcOrHandle);
      return this;
    }

    let value: unknown;

    if (!this._bound) {
      this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, this.handle);
      this._bound = true;
      value = funcOrHandle();
      this._bound = false;
      this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, null);
    } else {
      value = funcOrHandle();
    }

    return value;
  }

  unbind() {
    this.bind(null);
  }

  // PRIVATE METHODS

  /** Extract offsets for bindBufferRange */
  protected _getBufferRange(
    bufferOrRange: Buffer | {buffer: Buffer; byteOffset?: number; byteLength?: number}
  ): Required<BufferRange> {
    if (bufferOrRange instanceof WEBGLBuffer) {
      return {buffer: bufferOrRange, byteOffset: 0, byteLength: bufferOrRange.byteLength};
    }

    // To use bindBufferRange either offset or size must be specified.
    // @ts-expect-error Must be a BufferRange.
    const {buffer, byteOffset = 0, byteLength = bufferOrRange.buffer.byteLength} = bufferOrRange;
    return {buffer, byteOffset, byteLength};
  }

  protected _getVaryingIndex(locationOrName: string | number): number {
    if (isIndex(locationOrName)) {
      return Number(locationOrName);
    }

    for (const varying of this.layout.varyings) {
      if (locationOrName === varying.name) {
        return varying.location;
      }
    }

    return -1;
  }

  /**
   * Need to avoid chrome bug where buffer that is already bound to a different target
   * cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.
   */
  protected _bindBuffers(): void {
    for (const bufferIndex in this.buffers) {
      const {buffer, byteLength, byteOffset} = this._getBufferRange(this.buffers[bufferIndex]);
      this._bindBuffer(Number(bufferIndex), buffer, byteOffset, byteLength);
    }
  }

  protected _unbindBuffers(): void {
    for (const bufferIndex in this.buffers) {
      this.gl2.bindBufferBase(GL.TRANSFORM_FEEDBACK_BUFFER, Number(bufferIndex), null);
    }
  }

  protected _bindBuffer(
    index: number,
    buffer: Buffer,
    byteOffset = 0,
    byteLength?: number
  ): void {
    const handle = buffer && (buffer as WEBGLBuffer).handle;
    if (!handle || byteLength === undefined) {
      this.gl2.bindBufferBase(GL.TRANSFORM_FEEDBACK_BUFFER, index, handle);
    } else {
      this.gl2.bindBufferRange(GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);
    }
  }
}

/**
 * Returns true if the given value is an integer, or a string that
 * trivially converts to an integer (only numeric characters).
 */
function isIndex(value: string | number): boolean {
  if (typeof value === 'number') {
    return Number.isInteger(value);
  }
  return /^\d+$/.test(value);
}

1	import type {PrimitiveTopology, ShaderLayout, TransformFeedbackProps} from '@luma.gl/core';	1✔
2	import {log, TransformFeedback, Buffer, BufferRange} from '@luma.gl/core';	1✔
3	import {GL} from '@luma.gl/constants';	1✔
4	import {WebGLDevice} from '../webgl-device';	1✔
5	import {WEBGLBuffer} from '../..';	1✔
6	import {getGLPrimitive} from '../helpers/webgl-topology-utils';	1✔
7		1✔
8	export class WEBGLTransformFeedback extends TransformFeedback {	1✔
9	readonly device: WebGLDevice;	1✔
10	readonly gl2: WebGL2RenderingContext;	1✔
11	readonly handle: WebGLTransformFeedback;	1✔
12		1✔
13	/**	1✔
14	* NOTE: The Model already has this information while drawing, but	1✔
15	* TransformFeedback currently needs it internally, to look up	1✔
16	* varying information outside of a draw() call.	1✔
17	*/	1✔
18	readonly layout: ShaderLayout;	1✔
19	buffers: Record<string, BufferRange> = {};	1✔
20	unusedBuffers: Record<string, Buffer> = {};	1✔
21	/**	1✔
22	* Allows us to avoid a Chrome bug where a buffer that is already bound to a	1✔
23	* different target cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.	1✔
24	* This a major workaround, see: https://github.com/KhronosGroup/WebGL/issues/2346	1✔
25	*/	1✔
26	bindOnUse = true;	1✔
27	private _bound: boolean = false;	1✔
28		1✔
29	constructor(device: WebGLDevice, props: TransformFeedbackProps) {	1✔
30	super(device, props);	×
31		×
32	device.assertWebGL2();	×
33	this.device = device;	×
34	this.gl2 = device.gl2;	×
35	this.handle = this.props.handle \|\| this.gl2.createTransformFeedback();	×
36	this.layout = this.props.layout;	×
37		×
38	if (props.buffers) {	×
39	this.setBuffers(props.buffers);	×
40	}	×
41		×
42	Object.seal(this);	×
43	}	×
44		1✔
45	override destroy(): void {	1✔
46	this.gl2.deleteTransformFeedback(this.handle);	×
47	super.destroy();	×
48	}	×
49		1✔
50	begin(topology: PrimitiveTopology = 'point-list'): void {	1✔
51	this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, this.handle);	×
52	if (this.bindOnUse) {	×
53	this._bindBuffers();	×
54	}	×
55	this.gl2.beginTransformFeedback(getGLPrimitive(topology));	×
56	}	×
57		1✔
58	end(): void {	1✔
59	this.gl2.endTransformFeedback();	×
60	if (!this.bindOnUse) {	×
61	this._unbindBuffers();	×
62	}	×
63	this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, null);	×
64	}	×
65		1✔
66	// SUBCLASS	1✔
67		1✔
68	setBuffers(buffers: Record<string, Buffer \| BufferRange>): void {	1✔
69	this.buffers = {};	×
70	this.unusedBuffers = {};	×
71		×
72	this.bind(() => {	×
73	for (const bufferName in buffers) {	×
74	this.setBuffer(bufferName, buffers[bufferName]);	×
75	}	×
76	});	×
77	}	×
78		1✔
79	setBuffer(locationOrName: string \| number, bufferOrRange: Buffer \| BufferRange): void {	1✔
80	const location = this._getVaryingIndex(locationOrName);	×
81	const {buffer, byteLength, byteOffset} = this._getBufferRange(bufferOrRange);	×
82		×
83	if (location < 0) {	×
84	this.unusedBuffers[locationOrName] = buffer;	×
85	log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();	×
86	return;	×
87	}	×
88		×
89	this.buffers[location] = {buffer, byteLength, byteOffset};	×
90		×
91	// Need to avoid chrome bug where buffer that is already bound to a different target	×
92	// cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.	×
93	if (!this.bindOnUse) {	×
94	this._bindBuffer(location, buffer, byteOffset, byteLength);	×
95	}	×
96	}	×
97		1✔
98	getBuffer(locationOrName: string \| number): Buffer \| BufferRange \| null {	1✔
NEW 99	if (isIndex(locationOrName)) {	×
NEW 100	return this.buffers[locationOrName] \|\| null;	×
NEW 101	}	×
NEW 102	const location = this._getVaryingIndex(locationOrName);	×
NEW 103	return location >= 0 ? this.buffers[location] : null;	×
NEW 104	}	×
105		1✔
106	bind(funcOrHandle = this.handle) {	1✔
107	if (typeof funcOrHandle !== 'function') {	×
108	this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, funcOrHandle);	×
109	return this;	×
110	}	×
111		×
112	let value: unknown;	×
113		×
114	if (!this._bound) {	×
115	this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, this.handle);	×
116	this._bound = true;	×
117	value = funcOrHandle();	×
118	this._bound = false;	×
119	this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, null);	×
120	} else {	×
121	value = funcOrHandle();	×
122	}	×
123		×
124	return value;	×
125	}	×
126		1✔
127	unbind() {	1✔
128	this.bind(null);	×
129	}	×
130		1✔
131	// PRIVATE METHODS	1✔
132		1✔
133	/** Extract offsets for bindBufferRange */	1✔
134	protected _getBufferRange(	1✔
135	bufferOrRange: Buffer \| {buffer: Buffer; byteOffset?: number; byteLength?: number}	×
136	): Required<BufferRange> {	×
137	if (bufferOrRange instanceof WEBGLBuffer) {	×
138	return {buffer: bufferOrRange, byteOffset: 0, byteLength: bufferOrRange.byteLength};	×
139	}	×
140		×
141	// To use bindBufferRange either offset or size must be specified.	×
142	// @ts-expect-error Must be a BufferRange.	×
143	const {buffer, byteOffset = 0, byteLength = bufferOrRange.buffer.byteLength} = bufferOrRange;	×
144	return {buffer, byteOffset, byteLength};	×
145	}	×
146		1✔
147	protected _getVaryingIndex(locationOrName: string \| number): number {	1✔
148	if (isIndex(locationOrName)) {	×
149	return Number(locationOrName);	×
150	}	×
151		×
152	for (const varying of this.layout.varyings) {	×
153	if (locationOrName === varying.name) {	×
154	return varying.location;	×
155	}	×
156	}	×
157		×
158	return -1;	×
159	}	×
160		1✔
161	/**	1✔
162	* Need to avoid chrome bug where buffer that is already bound to a different target	1✔
163	* cannot be bound to 'TRANSFORM_FEEDBACK_BUFFER' target.	1✔
164	*/	1✔
165	protected _bindBuffers(): void {	1✔
166	for (const bufferIndex in this.buffers) {	×
167	const {buffer, byteLength, byteOffset} = this._getBufferRange(this.buffers[bufferIndex]);	×
168	this._bindBuffer(Number(bufferIndex), buffer, byteOffset, byteLength);	×
169	}	×
170	}	×
171		1✔
172	protected _unbindBuffers(): void {	1✔
173	for (const bufferIndex in this.buffers) {	×
174	this.gl2.bindBufferBase(GL.TRANSFORM_FEEDBACK_BUFFER, Number(bufferIndex), null);	×
175	}	×
176	}	×
177		1✔
178	protected _bindBuffer(	1✔
179	index: number,	×
180	buffer: Buffer,	×
181	byteOffset = 0,	×
182	byteLength?: number	×
183	): void {	×
184	const handle = buffer && (buffer as WEBGLBuffer).handle;	×
185	if (!handle \|\| byteLength === undefined) {	×
186	this.gl2.bindBufferBase(GL.TRANSFORM_FEEDBACK_BUFFER, index, handle);	×
187	} else {	×
188	this.gl2.bindBufferRange(GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);	×
189	}	×
190	}	×
191	}	1✔
192		1✔
193	/**	1✔
194	* Returns true if the given value is an integer, or a string that	1✔
195	* trivially converts to an integer (only numeric characters).	1✔
196	*/	1✔
197	function isIndex(value: string \| number): boolean {	×
198	if (typeof value === 'number') {	×
199	return Number.isInteger(value);	×
200	}	×
201	return /^\d+$/.test(value);	×
202	}	×

visgl / luma.gl / 7224312233

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