@math.gl/geometry-utils 4.2.0-alpha.5

package/src/gl-type.ts

@@ -0,0 +1,87 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {TypedArray, TypedArrayConstructor} from '@math.gl/types';
+import {GL_TYPE} from './constants';
+
+const GL_TYPE_TO_ARRAY_TYPE: Record<number, TypedArrayConstructor> = {
+  [GL_TYPE.DOUBLE]: Float64Array,
+  [GL_TYPE.FLOAT]: Float32Array,
+  [GL_TYPE.UNSIGNED_SHORT]: Uint16Array,
+  [GL_TYPE.UNSIGNED_INT]: Uint32Array,
+  [GL_TYPE.UNSIGNED_BYTE]: Uint8Array,
+  [GL_TYPE.BYTE]: Int8Array,
+  [GL_TYPE.SHORT]: Int16Array,
+  [GL_TYPE.INT]: Int32Array,
+  [GL_TYPE.UNSIGNED_SHORT_4_4_4_4]: Uint16Array,
+  [GL_TYPE.UNSIGNED_SHORT_5_5_5_1]: Uint16Array,
+  [GL_TYPE.UNSIGNED_SHORT_5_6_5]: Uint16Array
+};
+
+const NAME_TO_GL_TYPE: Record<string, number> = Object.fromEntries(
+  Object.entries(GL_TYPE).map(([name, glType]) => [name, glType])
+);
+
+const TYPE_CONVERSION_ERROR = 'Failed to convert GL type';
+
+/** Converts between WebGL component constants and JavaScript typed arrays. */
+export default class GLType {
+  /** Returns the WebGL component constant for a typed array or typed-array constructor. */
+  static fromTypedArray(arrayOrType: TypedArray | TypedArrayConstructor): number {
+    const arrayType = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+    if (arrayType === Uint8ClampedArray) {
+      return GL_TYPE.UNSIGNED_BYTE;
+    }
+    for (const [glType, candidateArrayType] of Object.entries(GL_TYPE_TO_ARRAY_TYPE)) {
+      if (candidateArrayType === arrayType) {
+        return Number(glType);
+      }
+    }
+    throw new Error(TYPE_CONVERSION_ERROR);
+  }
+
+  /** Returns a WebGL component constant from its uppercase name. */
+  static fromName(name: string): number {
+    const glType = NAME_TO_GL_TYPE[name];
+    if (glType === undefined) {
+      throw new Error(TYPE_CONVERSION_ERROR);
+    }
+    return glType;
+  }
+
+  /** Returns the typed-array constructor for a WebGL component constant. */
+  static getArrayType(glType: number): TypedArrayConstructor {
+    const ArrayType = GL_TYPE_TO_ARRAY_TYPE[glType];
+    if (!ArrayType) {
+      throw new Error(TYPE_CONVERSION_ERROR);
+    }
+    return ArrayType;
+  }
+
+  /** Returns the size in bytes of one element of a WebGL component type. */
+  static getByteSize(glType: number): number {
+    return GLType.getArrayType(glType).BYTES_PER_ELEMENT;
+  }
+
+  /** Returns whether a value is a supported WebGL component type. */
+  static validate(glType: number): boolean {
+    return Boolean(GL_TYPE_TO_ARRAY_TYPE[glType]);
+  }
+
+  /** Creates a typed view over an ArrayBuffer or an existing ArrayBuffer view. */
+  static createTypedArray(
+    glType: number,
+    buffer: ArrayBufferLike | ArrayBufferView,
+    byteOffset = 0,
+    length?: number
+  ): TypedArray {
+    const ArrayType = GLType.getArrayType(glType);
+    const arrayBuffer = ArrayBuffer.isView(buffer) ? buffer.buffer : buffer;
+    const viewByteOffset = ArrayBuffer.isView(buffer) ? buffer.byteOffset : 0;
+    const resolvedByteOffset = viewByteOffset + byteOffset;
+    const resolvedLength =
+      length ?? Math.floor((buffer.byteLength - byteOffset) / ArrayType.BYTES_PER_ELEMENT);
+    return new ArrayType(arrayBuffer as ArrayBuffer, resolvedByteOffset, resolvedLength);
+  }
+}

package/src/index.ts

@@ -0,0 +1,38 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export type {TypedArray, TypedArrayConstructor} from '@math.gl/types';
+
+export {GL, GL_TYPE, GL_PRIMITIVE, GL_PRIMITIVE_MODE} from './constants';
+export {default as GLType} from './gl-type';
+
+export type {Geometry, GeometryAttribute} from './geometry';
+export {isGeometry} from './geometry';
+
+export type {Primitive} from './primitive-iterator';
+export {makeAttributeIterator} from './attribute-iterator';
+export {makePrimitiveIterator} from './primitive-iterator';
+export {computeVertexNormals} from './compute-vertex-normals';
+
+export {encodeRGB565, decodeRGB565} from './rgb565';
+export {concatTypedArrays} from './typed-array-utils';
+
+export {
+  octEncodeInRange,
+  octEncode,
+  octEncodeToVector4,
+  octDecodeInRange,
+  octDecode,
+  octDecodeFromVector4,
+  octPackFloat,
+  octEncodeFloat,
+  octDecodeFloat,
+  octPack,
+  octUnpack,
+  compressTextureCoordinates,
+  decompressTextureCoordinates,
+  zigZagDeltaDecode
+} from './attribute-compression';
+
+export {emod} from './coordinates';

package/src/primitive-iterator.ts

@@ -0,0 +1,145 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {TypedArray} from '@math.gl/types';
+import {GL} from './constants';
+import type {Geometry} from './geometry';
+import {getAttributeValues, getPositionAttribute, isGeometry} from './geometry';
+
+/** One dereferenced point, line, or triangle primitive. */
+export type Primitive = {
+  attributes: object;
+  type: number;
+  i1: number;
+  i2?: number;
+  i3?: number;
+  primitiveIndex: number;
+};
+
+/**
+ * Iterates through a geometry's primitives and dereferences optional indices.
+ *
+ * The legacy argument form `(indices, attributes, mode, start, end)` is also supported.
+ */
+export function* makePrimitiveIterator(
+  geometryOrIndices?: Geometry | TypedArray | {value?: TypedArray; values?: TypedArray},
+  attributes: object = {},
+  mode?: number,
+  start = 0,
+  end?: number
+): Iterable<Primitive> {
+  let indices: TypedArray | undefined;
+  if (isGeometry(geometryOrIndices)) {
+    const geometry = geometryOrIndices;
+    indices = geometry.indices ? getAttributeValues(geometry.indices) : undefined;
+    attributes = geometry.attributes;
+    mode = geometry.mode;
+    if (end === undefined) {
+      const position = getPositionAttribute(geometry);
+      end = indices?.length ?? getAttributeValues(position).length / (position.size || 3);
+    }
+  } else if (geometryOrIndices) {
+    indices = getAttributeValues(geometryOrIndices);
+  }
+
+  if (mode === undefined) {
+    throw new Error('Primitive mode is required');
+  }
+  end ??= indices?.length ?? start;
+
+  const dereference = (index: number): number => Number(indices ? indices[index] : index);
+  let primitiveIndex = 0;
+
+  switch (mode) {
+    case GL.POINTS:
+      for (let index = start; index < end; index++) {
+        yield {
+          attributes,
+          type: GL.POINTS,
+          i1: dereference(index),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+
+    case GL.LINES:
+      for (let index = start; index + 1 < end; index += 2) {
+        yield {
+          attributes,
+          type: GL.LINES,
+          i1: dereference(index),
+          i2: dereference(index + 1),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+
+    case GL.LINE_STRIP:
+      for (let index = start; index + 1 < end; index++) {
+        yield {
+          attributes,
+          type: GL.LINES,
+          i1: dereference(index),
+          i2: dereference(index + 1),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+
+    case GL.LINE_LOOP:
+      for (let index = start; index < end; index++) {
+        yield {
+          attributes,
+          type: GL.LINES,
+          i1: dereference(index),
+          i2: dereference(index + 1 < end ? index + 1 : start),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+
+    case GL.TRIANGLES:
+      for (let index = start; index + 2 < end; index += 3) {
+        yield {
+          attributes,
+          type: GL.TRIANGLES,
+          i1: dereference(index),
+          i2: dereference(index + 1),
+          i3: dereference(index + 2),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+
+    case GL.TRIANGLE_STRIP:
+      for (let index = start; index + 2 < end; index++) {
+        const odd = (index - start) % 2 === 1;
+        yield {
+          attributes,
+          type: GL.TRIANGLES,
+          i1: dereference(odd ? index + 1 : index),
+          i2: dereference(odd ? index : index + 1),
+          i3: dereference(index + 2),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+
+    case GL.TRIANGLE_FAN:
+      for (let index = start + 1; index + 1 < end; index++) {
+        yield {
+          attributes,
+          type: GL.TRIANGLES,
+          i1: dereference(start),
+          i2: dereference(index),
+          i3: dereference(index + 1),
+          primitiveIndex: primitiveIndex++
+        };
+      }
+      return;
+
+    default:
+      throw new Error(`Unknown primitive mode ${mode}`);
+  }
+}

package/src/rgb565.ts

@@ -0,0 +1,26 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Decodes a packed RGB565 value into 8-bit RGB components. */
+export function decodeRGB565(rgb565: number, target: number[] = [0, 0, 0]): number[] {
+  const red = (rgb565 >> 11) & 31;
+  const green = (rgb565 >> 5) & 63;
+  const blue = rgb565 & 31;
+  target[0] = (red << 3) | (red >> 2);
+  target[1] = (green << 2) | (green >> 4);
+  target[2] = (blue << 3) | (blue >> 2);
+  return target;
+}
+
+/** Encodes 8-bit RGB components into a packed RGB565 value. */
+export function encodeRGB565(rgb: ArrayLike<number>): number {
+  const red = Math.round(clampByte(rgb[0] ?? 0) * (31 / 255));
+  const green = Math.round(clampByte(rgb[1] ?? 0) * (63 / 255));
+  const blue = Math.round(clampByte(rgb[2] ?? 0) * (31 / 255));
+  return (red << 11) | (green << 5) | blue;
+}
+
+function clampByte(value: number): number {
+  return Math.max(0, Math.min(255, value));
+}

package/src/typed-array-utils.ts

@@ -0,0 +1,16 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Concatenates the visible bytes of multiple typed-array or DataView instances. */
+export function concatTypedArrays(arrays: readonly ArrayBufferView[] = []): Uint8Array {
+  const byteLength = arrays.reduce((length, array) => length + array.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let byteOffset = 0;
+  for (const array of arrays) {
+    const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    result.set(bytes, byteOffset);
+    byteOffset += bytes.byteLength;
+  }
+  return result;
+}