7104664796

Committed 05 Dec 2023 05:58PM UTC coverage: 76.794% (+0.5%) from 76.294%

Build # 7104664796

Build Type

Pull #1859

github

Committed by

web-flow

Commit Message

Merge 883dafd2c into 38b58964a

Pull Request Pull Request #1859: Fix `babel-plugin-inline-webgl-constants`

Run Details

1864 of 2484 branches covered (0.0%)

Branch coverage included in aggregate %.

37 of 49 new or added lines in 4 files covered. (75.51%)

132 existing lines in 3 files now uncovered.

35150 of 45715 relevant lines covered (76.89%)

43.2 hits per line

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

62.24

/modules/shadertools/test/modules/engine/picking.spec.ts

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

import test from 'tape-promise/tape';
import {webgl2Device} from '@luma.gl/test-utils';

import {Transform} from '@luma.gl/engine';
import {picking} from '@luma.gl/shadertools';

/* eslint-disable camelcase */

const TEST_DATA = {
  vertexColorData: new Float32Array([
    0,
    0,
    0,
    255,
    100,
    150,
    50,
    50,
    50,
    251,
    103,
    153, // is picked only when threshold is 5
    150,
    100,
    255,
    254.5,
    100,
    150, // is picked with default threshold (1)
    100,
    150,
    255,
    255,
    255,
    255,
    255,
    100,
    149.5 // // is picked with default threshold (1)
  ])
};

const TEST_CASES = [
  {
    highlightedObjectColor: null,
    isPicked: [0, 0, 0, 0, 0, 0, 0, 0, 0]
  },
  {
    highlightedObjectColor: [255, 255, 255],
    isPicked: [0, 0, 0, 0, 0, 0, 0, 1, 0]
  },
  {
    highlightedObjectColor: [255, 100, 150],
    isPicked: [0, 1, 0, 0, 0, 0, 0, 0, 0]
  }
];

test('picking#getUniforms', (t) => {
  t.deepEqual(picking.getUniforms({}), {
    isActive: false,
    isAttribute: false,
    useFloatColors: true,
    isHighlightActive: false,
    highlightColor: [0, 1, 1, 1]
  }, 'Empty input');

  t.deepEqual(
    picking.getUniforms({
      isActive: true,
      highlightedObjectColor: undefined,
      highlightColor: [255, 0, 0]
    }),
    {
      isActive: true,
      isAttribute: false,
      useFloatColors: true,
      isHighlightActive: false,
      highlightColor: [1, 0, 0, 1]
    }, 'Undefined input');

  t.deepEqual(
    picking.getUniforms({
      isActive: true,
      highlightedObjectColor: null,
      highlightColor: [255, 0, 0]
    }),
    {
      isActive: true,
      isAttribute: false,
      useFloatColors: true,
      isHighlightActive: false,
      highlightedObjectColor: [0, 0, 0],
      highlightColor: [1, 0, 0, 1]
    }, 'Null input');

  t.deepEqual(
    picking.getUniforms({
      highlightedObjectColor: [0, 0, 1],
      highlightColor: [102, 0, 0, 51]
    }),
    {
      isActive: false,
      isAttribute: false,
      useFloatColors: true,
      isHighlightActive: true,
      highlightedObjectColor: [0, 0, 1],
      highlightColor: [0.4, 0, 0, 0.2]
    }
  );

  t.deepEqual(
    picking.getUniforms({
      highlightedObjectColor: [0, 0, 1],
      highlightColor: [102, 0, 0, 51],
      useFloatColors: false
    }),
    {
      isActive: false,
      isAttribute: false,
      useFloatColors: false,
      isHighlightActive: true,
      highlightedObjectColor: [0, 0, 1],
      highlightColor: [0.4, 0, 0, 0.2]
    }
  );

  t.end();
});

test('picking#isVertexPicked(highlightedObjectColor invalid)', (t) => {
  if (!Transform.isSupported(webgl2Device)) {
    t.comment('Transform not available, skipping tests');
    t.end();
    return;
  }

  const VS = `\
  attribute vec3 vertexColor;
  varying float isPicked;

  void main()
  {
    isPicked = float(isVertexPicked(vertexColor));
  }
  `;
  const vertexColorData = TEST_DATA.vertexColorData;

  const elementCount = vertexColorData.length / 3;
  const vertexColor = webgl2Device.createBuffer(vertexColorData);
  const isPicked = webgl2Device.createBuffer({byteLength: elementCount * 4});

  const transform = new Transform(webgl2Device, {
    sourceBuffers: {
      vertexColor
    },
    feedbackBuffers: {
      isPicked
    },
    vs: VS,
    varyings: ['isPicked'],
    modules: [picking],
    elementCount
  });

  TEST_CASES.forEach((testCase) => {
    const uniforms = picking.getUniforms({
      highlightedObjectColor: testCase.highlightedObjectColor
    });

    transform.run({uniforms});

    const expectedData = testCase.isPicked;
    const outData = transform.getBuffer('isPicked').getData();

    t.deepEqual(outData, expectedData, 'Vertex should correctly get picked');
  });

  t.end();
});

/* eslint-disable max-nested-callbacks */
test('picking#picking_setPickingColor', (t) => {
  if (!Transform.isSupported(webgl2Device)) {
    t.comment('Transform not available, skipping tests');
    t.end();
    return;
  }
  const VS = `\
  attribute vec3 vertexColor;
  varying float rgbColorASelected;

  void main()
  {
    picking_setPickingColor(vertexColor);
    rgbColorASelected = picking_vRGBcolor_Avalid.a;
  }
  `;

  const vertexColorData = TEST_DATA.vertexColorData;

  const elementCount = vertexColorData.length / 3;
  const vertexColor = webgl2Device.createBuffer(vertexColorData);
  const rgbColorASelected = webgl2Device.createBuffer({byteLength: elementCount * 4});

  const transform = new Transform(webgl2Device, {
    sourceBuffers: {
      vertexColor
    },
    feedbackBuffers: {
      rgbColorASelected
    },
    vs: VS,
    varyings: ['rgbColorASelected'],
    modules: [picking],
    elementCount
  });

  TEST_CASES.forEach((testCase) => {
    const uniforms = picking.getUniforms({
      highlightedObjectColor: testCase.highlightedObjectColor,
      // @ts-expect-error
      pickingThreshold: testCase.pickingThreshold
    });

    transform.run({uniforms});

    const outData = transform.getBuffer('rgbColorASelected').getData();

    t.deepEqual(outData, testCase.isPicked, 'Vertex should correctly get picked');
  });
  t.ok(true, 'picking_setPickingColor successful');

  t.end();
});
/* eslint-enable max-nested-callbacks */

1	// luma.gl, MIT license	1✔
2	// Copyright (c) vis.gl contributors	1✔
3		1✔
4	import test from 'tape-promise/tape';	1✔
5	import {webgl2Device} from '@luma.gl/test-utils';	1✔
6		1✔
7	import {Transform} from '@luma.gl/engine';	1✔
8	import {picking} from '@luma.gl/shadertools';	1✔
9		1✔
10	/* eslint-disable camelcase */	1✔
11		1✔
12	const TEST_DATA = {	1✔
13	vertexColorData: new Float32Array([	1✔
14	0,	1✔
15	0,	1✔
16	0,	1✔
17	255,	1✔
18	100,	1✔
19	150,	1✔
20	50,	1✔
21	50,	1✔
22	50,	1✔
23	251,	1✔
24	103,	1✔
25	153, // is picked only when threshold is 5	1✔
26	150,	1✔
27	100,	1✔
28	255,	1✔
29	254.5,	1✔
30	100,	1✔
31	150, // is picked with default threshold (1)	1✔
32	100,	1✔
33	150,	1✔
34	255,	1✔
35	255,	1✔
36	255,	1✔
37	255,	1✔
38	255,	1✔
39	100,	1✔
40	149.5 // // is picked with default threshold (1)	1✔
41	])	1✔
42	};	1✔
43		1✔
44	const TEST_CASES = [	1✔
45	{	1✔
46	highlightedObjectColor: null,	1✔
47	isPicked: [0, 0, 0, 0, 0, 0, 0, 0, 0]	1✔
48	},	1✔
49	{	1✔
50	highlightedObjectColor: [255, 255, 255],	1✔
51	isPicked: [0, 0, 0, 0, 0, 0, 0, 1, 0]	1✔
52	},	1✔
53	{	1✔
54	highlightedObjectColor: [255, 100, 150],	1✔
55	isPicked: [0, 1, 0, 0, 0, 0, 0, 0, 0]	1✔
56	}	1✔
57	];	1✔
58		1✔
59	test('picking#getUniforms', (t) => {	1✔
60	t.deepEqual(picking.getUniforms({}), {	1✔
61	isActive: false,	1✔
62	isAttribute: false,	1✔
63	useFloatColors: true,	1✔
64	isHighlightActive: false,	1✔
65	highlightColor: [0, 1, 1, 1]	1✔
66	}, 'Empty input');	1✔
67		1✔
68	t.deepEqual(	1✔
69	picking.getUniforms({	1✔
70	isActive: true,	1✔
71	highlightedObjectColor: undefined,	1✔
72	highlightColor: [255, 0, 0]	1✔
73	}),	1✔
74	{	1✔
75	isActive: true,	1✔
76	isAttribute: false,	1✔
77	useFloatColors: true,	1✔
78	isHighlightActive: false,	1✔
79	highlightColor: [1, 0, 0, 1]	1✔
80	}, 'Undefined input');	1✔
81		1✔
82	t.deepEqual(	1✔
83	picking.getUniforms({	1✔
84	isActive: true,	1✔
85	highlightedObjectColor: null,	1✔
86	highlightColor: [255, 0, 0]	1✔
87	}),	1✔
88	{	1✔
89	isActive: true,	1✔
90	isAttribute: false,	1✔
91	useFloatColors: true,	1✔
92	isHighlightActive: false,	1✔
93	highlightedObjectColor: [0, 0, 0],	1✔
94	highlightColor: [1, 0, 0, 1]	1✔
95	}, 'Null input');	1✔
96		1✔
97	t.deepEqual(	1✔
98	picking.getUniforms({	1✔
99	highlightedObjectColor: [0, 0, 1],	1✔
100	highlightColor: [102, 0, 0, 51]	1✔
101	}),	1✔
102	{	1✔
103	isActive: false,	1✔
104	isAttribute: false,	1✔
105	useFloatColors: true,	1✔
106	isHighlightActive: true,	1✔
107	highlightedObjectColor: [0, 0, 1],	1✔
108	highlightColor: [0.4, 0, 0, 0.2]	1✔
109	}	1✔
110	);	1✔
111		1✔
112	t.deepEqual(	1✔
113	picking.getUniforms({	1✔
114	highlightedObjectColor: [0, 0, 1],	1✔
115	highlightColor: [102, 0, 0, 51],	1✔
116	useFloatColors: false	1✔
117	}),	1✔
118	{	1✔
119	isActive: false,	1✔
120	isAttribute: false,	1✔
121	useFloatColors: false,	1✔
122	isHighlightActive: true,	1✔
123	highlightedObjectColor: [0, 0, 1],	1✔
124	highlightColor: [0.4, 0, 0, 0.2]	1✔
125	}	1✔
126	);	1✔
127		1✔
128	t.end();	1✔
129	});	1✔
130		1✔
131	test('picking#isVertexPicked(highlightedObjectColor invalid)', (t) => {	1✔
132	if (!Transform.isSupported(webgl2Device)) {	1✔
133	t.comment('Transform not available, skipping tests');	1✔
134	t.end();	1✔
135	return;	1✔
136	}	1✔
137		×
138	const VS = `\	×
139	attribute vec3 vertexColor;	×
UNCOV 140	varying float isPicked;	×
UNCOV 141		×
UNCOV 142	void main()	×
UNCOV 143	{	×
UNCOV 144	isPicked = float(isVertexPicked(vertexColor));	×
UNCOV 145	}	×
UNCOV 146	`;	×
UNCOV 147	const vertexColorData = TEST_DATA.vertexColorData;	×
UNCOV 148		×
149	const elementCount = vertexColorData.length / 3;	×
150	const vertexColor = webgl2Device.createBuffer(vertexColorData);	×
151	const isPicked = webgl2Device.createBuffer({byteLength: elementCount * 4});	×
152		×
153	const transform = new Transform(webgl2Device, {	×
154	sourceBuffers: {	×
155	vertexColor	×
156	},	×
157	feedbackBuffers: {	×
158	isPicked	×
159	},	×
160	vs: VS,	×
161	varyings: ['isPicked'],	×
162	modules: [picking],	×
163	elementCount	×
164	});	×
165		×
166	TEST_CASES.forEach((testCase) => {	×
167	const uniforms = picking.getUniforms({	×
168	highlightedObjectColor: testCase.highlightedObjectColor	×
169	});	×
170		×
171	transform.run({uniforms});	×
172		×
173	const expectedData = testCase.isPicked;	×
174	const outData = transform.getBuffer('isPicked').getData();	×
175		×
176	t.deepEqual(outData, expectedData, 'Vertex should correctly get picked');	×
177	});	×
178		×
179	t.end();	×
180	});	1✔
181		1✔
182	/* eslint-disable max-nested-callbacks */	1✔
183	test('picking#picking_setPickingColor', (t) => {	1✔
184	if (!Transform.isSupported(webgl2Device)) {	1✔
185	t.comment('Transform not available, skipping tests');	1✔
186	t.end();	1✔
187	return;	1✔
188	}	1✔
189	const VS = `\	×
190	attribute vec3 vertexColor;	×
191	varying float rgbColorASelected;	×
192		×
193	void main()	×
194	{	×
UNCOV 195	picking_setPickingColor(vertexColor);	×
UNCOV 196	rgbColorASelected = picking_vRGBcolor_Avalid.a;	×
UNCOV 197	}	×
UNCOV 198	`;	×
UNCOV 199		×
UNCOV 200	const vertexColorData = TEST_DATA.vertexColorData;	×
UNCOV 201		×
UNCOV 202	const elementCount = vertexColorData.length / 3;	×
UNCOV 203	const vertexColor = webgl2Device.createBuffer(vertexColorData);	×
UNCOV 204	const rgbColorASelected = webgl2Device.createBuffer({byteLength: elementCount * 4});	×
UNCOV 205		×
UNCOV 206	const transform = new Transform(webgl2Device, {	×
UNCOV 207	sourceBuffers: {	×
UNCOV 208	vertexColor	×
UNCOV 209	},	×
UNCOV 210	feedbackBuffers: {	×
UNCOV 211	rgbColorASelected	×
UNCOV 212	},	×
UNCOV 213	vs: VS,	×
UNCOV 214	varyings: ['rgbColorASelected'],	×
UNCOV 215	modules: [picking],	×
UNCOV 216	elementCount	×
UNCOV 217	});	×
UNCOV 218		×
UNCOV 219	TEST_CASES.forEach((testCase) => {	×
UNCOV 220	const uniforms = picking.getUniforms({	×
UNCOV 221	highlightedObjectColor: testCase.highlightedObjectColor,	×
UNCOV 222	// @ts-expect-error	×
UNCOV 223	pickingThreshold: testCase.pickingThreshold	×
UNCOV 224	});	×
UNCOV 225		×
UNCOV 226	transform.run({uniforms});	×
UNCOV 227		×
UNCOV 228	const outData = transform.getBuffer('rgbColorASelected').getData();	×
UNCOV 229		×
UNCOV 230	t.deepEqual(outData, testCase.isPicked, 'Vertex should correctly get picked');	×
UNCOV 231	});	×
UNCOV 232	t.ok(true, 'picking_setPickingColor successful');	×
UNCOV 233		×
UNCOV 234	t.end();	×
235	});	1✔
236	/* eslint-enable max-nested-callbacks */	1✔

visgl / luma.gl / 7104664796

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