7249730651

Committed 18 Dec 2023 02:49PM UTC coverage: 72.866% (+0.07%) from 72.792%

Build # 7249730651

Build Type

Pull #1884

github

Committed by

web-flow

Commit Message

Merge ef476b5de into a46cf8380

Pull Request Pull Request #1884: feat(engine) Support all vertex format types in GPUGeometry

Run Details

1303 of 1748 branches covered (0.0%)

Branch coverage included in aggregate %.

51 of 52 new or added lines in 3 files covered. (98.08%)

7 existing lines in 1 file now uncovered.

21053 of 28933 relevant lines covered (72.76%)

16.38 hits per line

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

27.48

/modules/webgl/src/classic/typed-array-utils.ts

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

import {TypedArray, TypedArrayConstructor} from '@luma.gl/core';
import {GL, GLDataType, GLPixelType} from '@luma.gl/constants';

const ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';

/**
 * Converts TYPED ARRAYS to corresponding GL constant
 * Used to auto deduce gl parameter types
 * @param arrayOrType
 * @returns
 */
export function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLDataType {
  // If typed array, look up constructor
  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
  switch (type) {
    case Float32Array:
      return GL.FLOAT;
    case Uint16Array:
      return GL.UNSIGNED_SHORT;
    case Uint32Array:
      return GL.UNSIGNED_INT;
    case Uint8Array:
      return GL.UNSIGNED_BYTE;
    case Uint8ClampedArray:
      return GL.UNSIGNED_BYTE;
    case Int8Array:
      return GL.BYTE;
    case Int16Array:
      return GL.SHORT;
    case Int32Array:
      return GL.INT;
    default:
      throw new Error(ERR_TYPE_DEDUCTION);
  }
}

/**
 * Converts GL constant to corresponding TYPED ARRAY
 * Used to auto deduce gl parameter types
 * @param glType
 * @param param1
 * @returns
 */
// eslint-disable-next-line complexity
export function getTypedArrayFromGLType(
  glType: GLDataType | GLPixelType,
  options?: {
    clamped?: boolean;
  }
): TypedArrayConstructor {
  const {clamped = true} = options || {};
  // Sorted in some order of likelihood to reduce amount of comparisons
  switch (glType) {
    case GL.FLOAT:
      return Float32Array;
    case GL.UNSIGNED_SHORT:
    case GL.UNSIGNED_SHORT_5_6_5:
    case GL.UNSIGNED_SHORT_4_4_4_4:
    case GL.UNSIGNED_SHORT_5_5_5_1:
      return Uint16Array;
    case GL.UNSIGNED_INT:
      return Uint32Array;
    case GL.UNSIGNED_BYTE:
      return clamped ? Uint8ClampedArray : Uint8Array;
    case GL.BYTE:
      return Int8Array;
    case GL.SHORT:
      return Int16Array;
    case GL.INT:
      return Int32Array;
    default:
      throw new Error('Failed to deduce typed array type from GL constant');
  }
}

/**
 * Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)
 * https: *stackoverflow.com/questions/41969562/
 * how-can-i-flip-the-result-of-webglrenderingcontext-readpixels
 * @param param0
 */
export function flipRows(options: {
  data: TypedArray;
  width: number;
  height: number;
  bytesPerPixel?: number;
  temp?: Uint8Array;
}): void {
  const {data, width, height, bytesPerPixel = 4, temp} = options;
  const bytesPerRow = width * bytesPerPixel;

  // make a temp buffer to hold one row
  const tempBuffer = temp || new Uint8Array(bytesPerRow);
  for (let y = 0; y < height / 2; ++y) {
    const topOffset = y * bytesPerRow;
    const bottomOffset = (height - y - 1) * bytesPerRow;
    // make copy of a row on the top half
    tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));
    // copy a row from the bottom half to the top
    data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);
    // copy the copy of the top half row to the bottom half
    data.set(tempBuffer, bottomOffset);
  }
}


export function scalePixels(options: {
  data: TypedArray;
  width: number;
  height: number;
}): {
  data: Uint8Array;
  width: number;
  height: number;
} {
  const {data, width, height} = options;
  const newWidth = Math.round(width / 2);
  const newHeight = Math.round(height / 2);
  const newData = new Uint8Array(newWidth * newHeight * 4);
  for (let y = 0; y < newHeight; y++) {
    for (let x = 0; x < newWidth; x++) {
      for (let c = 0; c < 4; c++) {
        newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];
      }
    }
  }
  return {data: newData, width: newWidth, height: newHeight};
}

1	// luma.gl, MIT license	1✔
2	// Copyright (c) vis.gl contributors	1✔
3		1✔
4	import {TypedArray, TypedArrayConstructor} from '@luma.gl/core';	1✔
5	import {GL, GLDataType, GLPixelType} from '@luma.gl/constants';	1✔
6		1✔
7	const ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';	1✔
8		1✔
9	/**	1✔
10	* Converts TYPED ARRAYS to corresponding GL constant	1✔
11	* Used to auto deduce gl parameter types	1✔
12	* @param arrayOrType	1✔
13	* @returns	1✔
14	*/	1✔
15	export function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLDataType {	1✔
UNCOV 16	// If typed array, look up constructor	×
17	const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;	×
18	switch (type) {	×
19	case Float32Array:	×
20	return GL.FLOAT;	×
21	case Uint16Array:	×
22	return GL.UNSIGNED_SHORT;	×
23	case Uint32Array:	×
24	return GL.UNSIGNED_INT;	×
25	case Uint8Array:	×
26	return GL.UNSIGNED_BYTE;	×
27	case Uint8ClampedArray:	×
28	return GL.UNSIGNED_BYTE;	×
29	case Int8Array:	×
30	return GL.BYTE;	×
31	case Int16Array:	×
32	return GL.SHORT;	×
33	case Int32Array:	×
34	return GL.INT;	×
35	default:	×
36	throw new Error(ERR_TYPE_DEDUCTION);	×
37	}	×
38	}	×
39		1✔
40	/**	1✔
41	* Converts GL constant to corresponding TYPED ARRAY	1✔
42	* Used to auto deduce gl parameter types	1✔
43	* @param glType	1✔
44	* @param param1	1✔
45	* @returns	1✔
46	*/	1✔
47	// eslint-disable-next-line complexity	1✔
48	export function getTypedArrayFromGLType(	1✔
UNCOV 49	glType: GLDataType \| GLPixelType,	×
UNCOV 50	options?: {	×
51	clamped?: boolean;	×
52	}	×
53	): TypedArrayConstructor {	×
54	const {clamped = true} = options \|\| {};	×
55	// Sorted in some order of likelihood to reduce amount of comparisons	×
56	switch (glType) {	×
57	case GL.FLOAT:	×
58	return Float32Array;	×
59	case GL.UNSIGNED_SHORT:	×
60	case GL.UNSIGNED_SHORT_5_6_5:	×
61	case GL.UNSIGNED_SHORT_4_4_4_4:	×
62	case GL.UNSIGNED_SHORT_5_5_5_1:	×
63	return Uint16Array;	×
64	case GL.UNSIGNED_INT:	×
65	return Uint32Array;	×
66	case GL.UNSIGNED_BYTE:	×
67	return clamped ? Uint8ClampedArray : Uint8Array;	×
68	case GL.BYTE:	×
69	return Int8Array;	×
70	case GL.SHORT:	×
71	return Int16Array;	×
72	case GL.INT:	×
73	return Int32Array;	×
74	default:	×
75	throw new Error('Failed to deduce typed array type from GL constant');	×
76	}	×
77	}	×
78		1✔
79	/**	1✔
80	* Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)	1✔
81	* https: *stackoverflow.com/questions/41969562/	1✔
82	* how-can-i-flip-the-result-of-webglrenderingcontext-readpixels	1✔
83	* @param param0	1✔
84	*/	1✔
85	export function flipRows(options: {	1✔
UNCOV 86	data: TypedArray;	×
UNCOV 87	width: number;	×
88	height: number;	×
89	bytesPerPixel?: number;	×
90	temp?: Uint8Array;	×
91	}): void {	×
92	const {data, width, height, bytesPerPixel = 4, temp} = options;	×
93	const bytesPerRow = width * bytesPerPixel;	×
94		×
95	// make a temp buffer to hold one row	×
96	const tempBuffer = temp \|\| new Uint8Array(bytesPerRow);	×
97	for (let y = 0; y < height / 2; ++y) {	×
98	const topOffset = y * bytesPerRow;	×
99	const bottomOffset = (height - y - 1) * bytesPerRow;	×
100	// make copy of a row on the top half	×
101	tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));	×
102	// copy a row from the bottom half to the top	×
103	data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);	×
104	// copy the copy of the top half row to the bottom half	×
105	data.set(tempBuffer, bottomOffset);	×
106	}	×
107	}	×
108		1✔
109		1✔
110	export function scalePixels(options: {	1✔
UNCOV 111	data: TypedArray;	×
UNCOV 112	width: number;	×
113	height: number;	×
114	}): {	×
115	data: Uint8Array;	×
116	width: number;	×
117	height: number;	×
118	} {	×
119	const {data, width, height} = options;	×
120	const newWidth = Math.round(width / 2);	×
121	const newHeight = Math.round(height / 2);	×
122	const newData = new Uint8Array(newWidth * newHeight * 4);	×
123	for (let y = 0; y < newHeight; y++) {	×
124	for (let x = 0; x < newWidth; x++) {	×
125	for (let c = 0; c < 4; c++) {	×
126	newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];	×
127	}	×
128	}	×
129	}	×
130	return {data: newData, width: newWidth, height: newHeight};	×
131	}	×

visgl / luma.gl / 7249730651

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