7107205482

Committed 05 Dec 2023 10:12PM UTC coverage: 76.474% (-0.2%) from 76.648%

Build # 7107205482

Build Type

Pull #1864

github

Committed by

web-flow

Commit Message

Merge 33ac9c763 into 38b58964a

Pull Request Pull Request #1864: [webgl] Remove BufferWithAccessor

Run Details

1815 of 2394 branches covered (0.0%)

Branch coverage included in aggregate %.

78 of 135 new or added lines in 7 files covered. (57.78%)

118 existing lines in 3 files now uncovered.

34583 of 45201 relevant lines covered (76.51%)

43.5 hits per line

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

85.31

/modules/core-tests/test/adapter/resources/buffer.spec.ts

// luma.gl, MIT license
// Copyright (c) vis.gl contributors

import {Buffer} from '@luma.gl/core';
import {GL} from '@luma.gl/constants';
import test from 'tape-promise/tape';

import {getWebGLTestDevices} from '@luma.gl/test-utils';

test('Buffer#constructor/delete', t => {
  for (const device of getWebGLTestDevices()) {
    const buffer = device.createBuffer({usage: Buffer.VERTEX});
    t.ok(buffer.handle, `${device.info.type} Buffer construction successful`);

    buffer.destroy();
    t.ok(!buffer.handle, `${device.info.type} Buffer.destroy() successful`);

    buffer.destroy();
    t.ok(!buffer.handle, `${device.info.type} repeated Buffer.destroy() successful`);
  }
  t.end();
});

test('Buffer#constructor offset and size', t => {
  const data = new Float32Array([1, 2, 3]);

  for (const device of getWebGLTestDevices()) {
    let buffer = device.createBuffer({data, byteOffset: 8});
    let expectedData = new Float32Array([0, 0, 1, 2, 3]);
    t.equal(
      buffer.byteLength,
      expectedData.byteLength,
      `${device.info.type} Buffer byteLength set properly`
    );

    if (device.isWebGL2) {
      const receivedData = buffer.getData();
      t.deepEqual(
        new Float32Array(receivedData.buffer),
        expectedData,
        `${device.info.type} Buffer constructor offsets data`
      );
    }

    buffer = device.createBuffer({data, byteLength: data.byteLength + 12});
    expectedData = new Float32Array([1, 2, 3, 0, 0, 0]);
    t.equal(
      buffer.byteLength,
      expectedData.byteLength,
      `${device.info.type} Buffer byteLength set properly`
    );
    if (device.isWebGL2) {
      const receivedData = buffer.getData();
      t.deepEqual(
        new Float32Array(receivedData.buffer),
        expectedData,
        `${device.info.type} Buffer constructor sets buffer data`
      );
    }

    buffer = device.createBuffer({data, byteOffset: 8, byteLength: data.byteLength + 12});
    expectedData = new Float32Array([0, 0, 1, 2, 3, 0]);
    t.equal(
      buffer.byteLength,
      expectedData.byteLength,
      `${device.info.type} Buffer byteLength set properly`
    );

    if (device.isWebGL2) {
      const receivedData = buffer.getData();
      t.deepEqual(
        new Float32Array(receivedData.buffer),
        expectedData,
        `${device.info.type} Buffer constructor sets buffer byteLength and offsets data`
      );
    }
  }
  t.end();
});

test('Buffer#bind/unbind', t => {
  for (const device of getWebGLTestDevices()) {
    const buffer = device.createBuffer({usage: Buffer.VERTEX});
    device.gl.bindBuffer(buffer.glTarget, buffer.handle);
    t.ok(buffer instanceof Buffer, `${device.info.type} Buffer bind/unbind successful`);
    device.gl.bindBuffer(buffer.glTarget, null);
    buffer.destroy();
  }
  t.end();
});

test('Buffer#construction', t => {
  for (const device of getWebGLTestDevices()) {
    let buffer;

    buffer = device.createBuffer({usage: Buffer.VERTEX, data: new Float32Array([1, 2, 3])});
    t.ok(
      buffer.glTarget === GL.ARRAY_BUFFER,
      `${device.info.type} Buffer(ARRAY_BUFFER) successful`
    );
    buffer.destroy();

    // TODO - buffer could check for integer ELEMENT_ARRAY_BUFFER types
    buffer = device.createBuffer({usage: Buffer.INDEX, data: new Float32Array([1, 2, 3])});
    t.ok(
      buffer.glTarget === GL.ELEMENT_ARRAY_BUFFER,
      `${device.info.type} Buffer(ELEMENT_ARRAY_BUFFER) successful`
    );

    buffer.destroy();
  }

  t.end();
});

test('Buffer#write', t => {
  const expectedData = new Float32Array([1, 2, 3]);
  for (const device of getWebGLTestDevices()) {
    const buffer = device.createBuffer({usage: Buffer.VERTEX, byteLength: 12});
    buffer.write(expectedData);
    if (device.isWebGL2) {
      const receivedData = buffer.getData();
      t.deepEqual(
        new Float32Array(receivedData.buffer),
        expectedData,
        `${device.info.type} Buffer.subData(ARRAY_BUFFER) stores correct bytes`
      );
    } else {
      t.ok(buffer instanceof Buffer, `${device.info.type} Buffer.subData(ARRAY_BUFFER) successful`);
    }
    buffer.destroy();

    // TODO - this seems to be testing that usage is correctly observed, move up
    // buffer = device.createBuffer({usage: Buffer.VERTEX, data: new Float32Array([1, 2, 3])});
    // buffer.write(new Float32Array([1, 2, 3]));
    // t.ok(buffer instanceof Buffer, `${device.info.type} Buffer.subData(ARRAY_BUFFER) successful`);
    // buffer.destroy();

    // buffer = device.createBuffer({usage: Buffer.INDEX}).write(new Float32Array([1, 2, 3]));
    // t.ok(
    //   buffer instanceof Buffer,
    //   `${device.info.type} buffer.initialize(ELEMENT_ARRAY_BUFFER) successful`
    // );
    // buffer.destroy();
  }
  t.end();
});

/*
test('Buffer#getData', t => {
  for (const device of getWebGLTestDevices()) {
    if (!gl2) {
      t.comment('WebGL2 not available, skipping tests');
      t.end();
      return;
    }

    let data = new Float32Array([1, 2, 3]);
    let buffer = device.createBuffer({data});

    let receivedData = buffer.getData();
    let expectedData = new Float32Array([1, 2, 3]);
    t.deepEqual(data, receivedData, 'Buffer.getData: default parameters successful');

    receivedData = buffer.getData({
      dstData: new Float32Array(2),
      srcByteOffset: Float32Array.BYTES_PER_ELEMENT
    });
    expectedData = new Float32Array([2, 3]);
    t.deepEqual(expectedData, receivedData, "Buffer.getData: with 'dstData' parameter successful");

    receivedData = buffer.getData({
      srcByteOffset: Float32Array.BYTES_PER_ELEMENT,
      dstOffset: 2
    });
    expectedData = new Float32Array([0, 0, 2, 3]);
    t.deepEqual(expectedData, receivedData, 'Buffer.getData: with src/dst offsets successful');

    // NOTE: when source and dst offsets are specified, 'length' needs to be set so that
    // source buffer access is not outof bounds, otherwise 'getBufferSubData' will throw exception.
    receivedData = buffer.getData({
      srcByteOffset: Float32Array.BYTES_PER_ELEMENT * 2,
      dstOffset: 1,
      length: 1
    });
    expectedData = new Float32Array([0, 3]);
    t.deepEqual(
      expectedData,
      receivedData,
      'Buffer.getData: with src/dst offsets and length successful'
    );

    // @ts-expect-error
    data = new Uint8Array([128, 255, 1]);
    buffer = device.createBuffer({data});

    receivedData = buffer.getData();
    t.deepEqual(data, receivedData, 'Buffer.getData: Uint8Array + default parameters successful');
  }
  t.end();
});
*/

1	// luma.gl, MIT license	1✔
2	// Copyright (c) vis.gl contributors	1✔
3		1✔
4	import {Buffer} from '@luma.gl/core';	1✔
5	import {GL} from '@luma.gl/constants';	1✔
6	import test from 'tape-promise/tape';	1✔
7		1✔
8	import {getWebGLTestDevices} from '@luma.gl/test-utils';	1✔
9		1✔
10	test('Buffer#constructor/delete', t => {	1✔
11	for (const device of getWebGLTestDevices()) {	1✔
12	const buffer = device.createBuffer({usage: Buffer.VERTEX});	1✔
13	t.ok(buffer.handle, `${device.info.type} Buffer construction successful`);	1✔
14		1✔
15	buffer.destroy();	1✔
16	t.ok(!buffer.handle, `${device.info.type} Buffer.destroy() successful`);	1✔
17		1✔
18	buffer.destroy();	1✔
19	t.ok(!buffer.handle, `${device.info.type} repeated Buffer.destroy() successful`);	1✔
20	}	1✔
21	t.end();	1✔
22	});	1✔
23		1✔
24	test('Buffer#constructor offset and size', t => {	1✔
25	const data = new Float32Array([1, 2, 3]);	1✔
26		1✔
27	for (const device of getWebGLTestDevices()) {	1✔
28	let buffer = device.createBuffer({data, byteOffset: 8});	1✔
29	let expectedData = new Float32Array([0, 0, 1, 2, 3]);	1✔
30	t.equal(	1✔
31	buffer.byteLength,	1✔
32	expectedData.byteLength,	1✔
33	`${device.info.type} Buffer byteLength set properly`	1✔
34	);	1✔
35		1✔
36	if (device.isWebGL2) {	1!
37	const receivedData = buffer.getData();	×
38	t.deepEqual(	×
NEW 39	new Float32Array(receivedData.buffer),	×
40	expectedData,	×
41	`${device.info.type} Buffer constructor offsets data`	×
42	);	×
43	}	×
44		1✔
45	buffer = device.createBuffer({data, byteLength: data.byteLength + 12});	1✔
46	expectedData = new Float32Array([1, 2, 3, 0, 0, 0]);	1✔
47	t.equal(	1✔
48	buffer.byteLength,	1✔
49	expectedData.byteLength,	1✔
50	`${device.info.type} Buffer byteLength set properly`	1✔
51	);	1✔
52	if (device.isWebGL2) {	1!
53	const receivedData = buffer.getData();	×
54	t.deepEqual(	×
NEW 55	new Float32Array(receivedData.buffer),	×
56	expectedData,	×
57	`${device.info.type} Buffer constructor sets buffer data`	×
58	);	×
59	}	×
60		1✔
61	buffer = device.createBuffer({data, byteOffset: 8, byteLength: data.byteLength + 12});	1✔
62	expectedData = new Float32Array([0, 0, 1, 2, 3, 0]);	1✔
63	t.equal(	1✔
64	buffer.byteLength,	1✔
65	expectedData.byteLength,	1✔
66	`${device.info.type} Buffer byteLength set properly`	1✔
67	);	1✔
68		1✔
69	if (device.isWebGL2) {	1!
70	const receivedData = buffer.getData();	×
71	t.deepEqual(	×
NEW 72	new Float32Array(receivedData.buffer),	×
73	expectedData,	×
74	`${device.info.type} Buffer constructor sets buffer byteLength and offsets data`	×
75	);	×
76	}	×
77	}	1✔
78	t.end();	1✔
79	});	1✔
80		1✔
81	test('Buffer#bind/unbind', t => {	1✔
82	for (const device of getWebGLTestDevices()) {	1✔
83	const buffer = device.createBuffer({usage: Buffer.VERTEX});	1✔
84	device.gl.bindBuffer(buffer.glTarget, buffer.handle);	1✔
85	t.ok(buffer instanceof Buffer, `${device.info.type} Buffer bind/unbind successful`);	1✔
86	device.gl.bindBuffer(buffer.glTarget, null);	1✔
87	buffer.destroy();	1✔
88	}	1✔
89	t.end();	1✔
90	});	1✔
91		1✔
92	test('Buffer#construction', t => {	1✔
93	for (const device of getWebGLTestDevices()) {	1✔
94	let buffer;	1✔
95		1✔
96	buffer = device.createBuffer({usage: Buffer.VERTEX, data: new Float32Array([1, 2, 3])});	1✔
97	t.ok(	1✔
98	buffer.glTarget === GL.ARRAY_BUFFER,	1✔
99	`${device.info.type} Buffer(ARRAY_BUFFER) successful`	1✔
100	);	1✔
101	buffer.destroy();	1✔
102		1✔
103	// TODO - buffer could check for integer ELEMENT_ARRAY_BUFFER types	1✔
104	buffer = device.createBuffer({usage: Buffer.INDEX, data: new Float32Array([1, 2, 3])});	1✔
105	t.ok(	1✔
106	buffer.glTarget === GL.ELEMENT_ARRAY_BUFFER,	1✔
107	`${device.info.type} Buffer(ELEMENT_ARRAY_BUFFER) successful`	1✔
108	);	1✔
109		1✔
110	buffer.destroy();	1✔
111	}	1✔
112		1✔
113	t.end();	1✔
114	});	1✔
115		1✔
116	test('Buffer#write', t => {	1✔
117	const expectedData = new Float32Array([1, 2, 3]);	1✔
118	for (const device of getWebGLTestDevices()) {	1✔
119	const buffer = device.createBuffer({usage: Buffer.VERTEX, byteLength: 12});	1✔
120	buffer.write(expectedData);	1✔
121	if (device.isWebGL2) {	1!
NEW 122	const receivedData = buffer.getData();	×
123	t.deepEqual(	×
NEW 124	new Float32Array(receivedData.buffer),	×
NEW 125	expectedData,	×
126	`${device.info.type} Buffer.subData(ARRAY_BUFFER) stores correct bytes`	×
127	);	×
128	} else {	1✔
129	t.ok(buffer instanceof Buffer, `${device.info.type} Buffer.subData(ARRAY_BUFFER) successful`);	1✔
130	}	1✔
131	buffer.destroy();	1✔
132		1✔
133	// TODO - this seems to be testing that usage is correctly observed, move up	1✔
134	// buffer = device.createBuffer({usage: Buffer.VERTEX, data: new Float32Array([1, 2, 3])});	1✔
135	// buffer.write(new Float32Array([1, 2, 3]));	1✔
136	// t.ok(buffer instanceof Buffer, `${device.info.type} Buffer.subData(ARRAY_BUFFER) successful`);	1✔
137	// buffer.destroy();	1✔
138		1✔
139	// buffer = device.createBuffer({usage: Buffer.INDEX}).write(new Float32Array([1, 2, 3]));	1✔
140	// t.ok(	1✔
141	// buffer instanceof Buffer,	1✔
142	// `${device.info.type} buffer.initialize(ELEMENT_ARRAY_BUFFER) successful`	1✔
143	// );	1✔
144	// buffer.destroy();	1✔
145	}	1✔
146	t.end();	1✔
147	});	1✔
148		1✔
149	/*	1✔
150	test('Buffer#getData', t => {	1✔
151	for (const device of getWebGLTestDevices()) {	1✔
152	if (!gl2) {	1✔
153	t.comment('WebGL2 not available, skipping tests');	1✔
154	t.end();	1✔
155	return;	1✔
156	}	1✔
157		1✔
158	let data = new Float32Array([1, 2, 3]);	1✔
159	let buffer = device.createBuffer({data});	1✔
160		1✔
161	let receivedData = buffer.getData();	1✔
162	let expectedData = new Float32Array([1, 2, 3]);	1✔
163	t.deepEqual(data, receivedData, 'Buffer.getData: default parameters successful');	1✔
164		1✔
165	receivedData = buffer.getData({	1✔
166	dstData: new Float32Array(2),	1✔
167	srcByteOffset: Float32Array.BYTES_PER_ELEMENT	1✔
168	});	1✔
169	expectedData = new Float32Array([2, 3]);	1✔
170	t.deepEqual(expectedData, receivedData, "Buffer.getData: with 'dstData' parameter successful");	1✔
171		1✔
172	receivedData = buffer.getData({	1✔
173	srcByteOffset: Float32Array.BYTES_PER_ELEMENT,	1✔
174	dstOffset: 2	1✔
175	});	1✔
176	expectedData = new Float32Array([0, 0, 2, 3]);	1✔
177	t.deepEqual(expectedData, receivedData, 'Buffer.getData: with src/dst offsets successful');	1✔
178		1✔
179	// NOTE: when source and dst offsets are specified, 'length' needs to be set so that	1✔
180	// source buffer access is not outof bounds, otherwise 'getBufferSubData' will throw exception.	1✔
181	receivedData = buffer.getData({	1✔
182	srcByteOffset: Float32Array.BYTES_PER_ELEMENT * 2,	1✔
183	dstOffset: 1,	1✔
184	length: 1	1✔
185	});	1✔
186	expectedData = new Float32Array([0, 3]);	1✔
187	t.deepEqual(	1✔
188	expectedData,	1✔
189	receivedData,	1✔
190	'Buffer.getData: with src/dst offsets and length successful'	1✔
191	);	1✔
192		1✔
193	// @ts-expect-error	1✔
194	data = new Uint8Array([128, 255, 1]);	1✔
195	buffer = device.createBuffer({data});	1✔
196		1✔
197	receivedData = buffer.getData();	1✔
198	t.deepEqual(data, receivedData, 'Buffer.getData: Uint8Array + default parameters successful');	1✔
199	}	1✔
200	t.end();	1✔
201	});	1✔
202	*/	1✔

visgl / luma.gl / 7107205482

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