7197813811

Committed 13 Dec 2023 04:00PM UTC coverage: 72.718% (+0.03%) from 72.692%

Build # 7197813811

Build Type

Pull #1876

github

Committed by

web-flow

Commit Message

Merge e053c230c into 2c98529b8

Pull Request Pull Request #1876: Update TransformFeedback API document

Run Details

1270 of 1712 branches covered (0.0%)

Branch coverage included in aggregate %.

6 of 8 new or added lines in 2 files covered. (75.0%)

41 existing lines in 2 files now uncovered.

20962 of 28861 relevant lines covered (72.63%)

16.41 hits per line

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

37.31

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

import type {PrimitiveTopology, ShaderLayout, TransformFeedbackProps} from '@luma.gl/core';
import {log, TransformFeedback, Buffer} 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';

/** For bindRange */
type BufferRange = {
  buffer: Buffer;
  byteOffset?: number;
  byteLength?: number;
};

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);
    }
  }

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

visgl / luma.gl / 7197813811

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