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

package/dist/primitive-iterator.js

@@ -0,0 +1,117 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { GL } from "./constants.js";
+import { getAttributeValues, getPositionAttribute, isGeometry } from "./geometry.js";
+/**
+ * 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, attributes = {}, mode, start = 0, end) {
+    let indices;
+    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 ?? (end = indices?.length ?? start);
+    const dereference = (index) => 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}`);
+    }
+}
+//# sourceMappingURL=primitive-iterator.js.map

package/dist/primitive-iterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive-iterator.js","sourceRoot":"","sources":["../src/primitive-iterator.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,EAAE,EAAC,uBAAoB;AAE/B,OAAO,EAAC,kBAAkB,EAAE,oBAAoB,EAAE,UAAU,EAAC,sBAAmB;AAYhF;;;;GAIG;AACH,MAAM,SAAS,CAAC,CAAC,qBAAqB,CACpC,iBAAqF,EACrF,aAAqB,EAAE,EACvB,IAAa,EACb,KAAK,GAAG,CAAC,EACT,GAAY;IAEZ,IAAI,OAA+B,CAAC;IACpC,IAAI,UAAU,CAAC,iBAAiB,CAAC,EAAE,CAAC;QAClC,MAAM,QAAQ,GAAG,iBAAiB,CAAC;QACnC,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9E,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC;QACjC,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC;QACrB,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,MAAM,QAAQ,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;YAChD,GAAG,GAAG,OAAO,EAAE,MAAM,IAAI,kBAAkB,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC;QACtF,CAAC;IACH,CAAC;SAAM,IAAI,iBAAiB,EAAE,CAAC;QAC7B,OAAO,GAAG,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;IAClD,CAAC;IAED,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAChD,CAAC;IACD,GAAG,KAAH,GAAG,GAAK,OAAO,EAAE,MAAM,IAAI,KAAK,EAAC;IAEjC,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IACxF,IAAI,cAAc,GAAG,CAAC,CAAC;IAEvB,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,EAAE,CAAC,MAAM;YACZ,KAAK,IAAI,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC;gBAC7C,MAAM;oBACJ,UAAU;oBACV,IAAI,EAAE,EAAE,CAAC,MAAM;oBACf,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC;oBACtB,cAAc,EAAE,cAAc,EAAE;iBACjC,CAAC;YACJ,CAAC;YACD,OAAO;QAET,KAAK,EAAE,CAAC,KAAK;YACX,KAAK,IAAI,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,CAAC,GAAG,GAAG,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;gBACpD,MAAM;oBACJ,UAAU;oBACV,IAAI,EAAE,EAAE,CAAC,KAAK;oBACd,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC;oBACtB,EAAE,EAAE,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC;oBAC1B,cAAc,EAAE,cAAc,EAAE;iBACjC,CAAC;YACJ,CAAC;YACD,OAAO;QAET,KAAK,EAAE,CAAC,UAAU;YAChB,KAAK,IAAI,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC;gBACjD,MAAM;oBACJ,UAAU;oBACV,IAAI,EAAE,EAAE,CAAC,KAAK;oBACd,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC;oBACtB,EAAE,EAAE,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC;oBAC1B,cAAc,EAAE,cAAc,EAAE;iBACjC,CAAC;YACJ,CAAC;YACD,OAAO;QAET,KAAK,EAAE,CAAC,SAAS;YACf,KAAK,IAAI,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC;gBAC7C,MAAM;oBACJ,UAAU;oBACV,IAAI,EAAE,EAAE,CAAC,KAAK;oBACd,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC;oBACtB,EAAE,EAAE,WAAW,CAAC,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;oBACpD,cAAc,EAAE,cAAc,EAAE;iBACjC,CAAC;YACJ,CAAC;YACD,OAAO;QAET,KAAK,EAAE,CAAC,SAAS;YACf,KAAK,IAAI,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,CAAC,GAAG,GAAG,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;gBACpD,MAAM;oBACJ,UAAU;oBACV,IAAI,EAAE,EAAE,CAAC,SAAS;oBAClB,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC;oBACtB,EAAE,EAAE,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC;oBAC1B,EAAE,EAAE,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC;oBAC1B,cAAc,EAAE,cAAc,EAAE;iBACjC,CAAC;YACJ,CAAC;YACD,OAAO;QAET,KAAK,EAAE,CAAC,cAAc;YACpB,KAAK,IAAI,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC;gBACjD,MAAM,GAAG,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBACtC,MAAM;oBACJ,UAAU;oBACV,IAAI,EAAE,EAAE,CAAC,SAAS;oBAClB,EAAE,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;oBACxC,EAAE,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;oBACxC,EAAE,EAAE,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC;oBAC1B,cAAc,EAAE,cAAc,EAAE;iBACjC,CAAC;YACJ,CAAC;YACD,OAAO;QAET,KAAK,EAAE,CAAC,YAAY;YAClB,KAAK,IAAI,KAAK,GAAG,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC;gBACrD,MAAM;oBACJ,UAAU;oBACV,IAAI,EAAE,EAAE,CAAC,SAAS;oBAClB,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC;oBACtB,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC;oBACtB,EAAE,EAAE,WAAW,CAAC,KAAK,GAAG,CAAC,CAAC;oBAC1B,cAAc,EAAE,cAAc,EAAE;iBACjC,CAAC;YACJ,CAAC;YACD,OAAO;QAET;YACE,MAAM,IAAI,KAAK,CAAC,0BAA0B,IAAI,EAAE,CAAC,CAAC;IACtD,CAAC;AACH,CAAC"}

package/dist/rgb565.d.ts

@@ -0,0 +1,5 @@
+/** Decodes a packed RGB565 value into 8-bit RGB components. */
+export declare function decodeRGB565(rgb565: number, target?: number[]): number[];
+/** Encodes 8-bit RGB components into a packed RGB565 value. */
+export declare function encodeRGB565(rgb: ArrayLike<number>): number;
+//# sourceMappingURL=rgb565.d.ts.map

package/dist/rgb565.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgb565.d.ts","sourceRoot":"","sources":["../src/rgb565.ts"],"names":[],"mappings":"AAIA,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,EAAc,GAAG,MAAM,EAAE,CAQnF;AAED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAK3D"}

package/dist/rgb565.js

@@ -0,0 +1,24 @@
+// 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, target = [0, 0, 0]) {
+    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) {
+    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) {
+    return Math.max(0, Math.min(255, value));
+}
+//# sourceMappingURL=rgb565.js.map

package/dist/rgb565.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgb565.js","sourceRoot":"","sources":["../src/rgb565.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,+DAA+D;AAC/D,MAAM,UAAU,YAAY,CAAC,MAAc,EAAE,SAAmB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACvE,MAAM,GAAG,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC;IAChC,MAAM,KAAK,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC;IACjC,MAAM,IAAI,GAAG,MAAM,GAAG,EAAE,CAAC;IACzB,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACpC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC;IACxC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC;IACtC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,YAAY,CAAC,GAAsB;IACjD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;IAC5D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;IAC9D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;IAC7D,OAAO,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;AAC3C,CAAC;AAED,SAAS,SAAS,CAAC,KAAa;IAC9B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;AAC3C,CAAC"}

package/dist/typed-array-utils.d.ts

@@ -0,0 +1,3 @@
+/** Concatenates the visible bytes of multiple typed-array or DataView instances. */
+export declare function concatTypedArrays(arrays?: readonly ArrayBufferView[]): Uint8Array;
+//# sourceMappingURL=typed-array-utils.d.ts.map

package/dist/typed-array-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-array-utils.d.ts","sourceRoot":"","sources":["../src/typed-array-utils.ts"],"names":[],"mappings":"AAIA,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,SAAS,eAAe,EAAO,GAAG,UAAU,CAUrF"}

package/dist/typed-array-utils.js

@@ -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 = []) {
+    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;
+}
+//# sourceMappingURL=typed-array-utils.js.map

package/dist/typed-array-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-array-utils.js","sourceRoot":"","sources":["../src/typed-array-utils.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,oFAAoF;AACpF,MAAM,UAAU,iBAAiB,CAAC,SAAqC,EAAE;IACvE,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,MAAM,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;IAClF,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC;IAC1C,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAC/E,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;QAC9B,UAAU,IAAI,KAAK,CAAC,UAAU,CAAC;IACjC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@math.gl/geometry-utils",
+  "description": "Typed-array geometry processing and attribute compression utilities",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "4.2.0-alpha.5",
+  "keywords": [
+    "webgl",
+    "webgpu",
+    "geometry",
+    "typed array",
+    "attribute compression"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/visgl/math.gl.git"
+  },
+  "types": "dist/index.d.ts",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@math.gl/core": "4.2.0-alpha.5",
+    "@math.gl/types": "4.2.0-alpha.5"
+  },
+  "gitHead": "9c13785761867748e2edb167b5f2749dce803039"
+}

package/src/attribute-compression.ts

@@ -0,0 +1,232 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// Derived from Cesium under the Apache 2.0 license.
+// https://github.com/CesiumGS/cesium/blob/main/LICENSE.md
+
+import {Vector2, Vector3, assert, clamp, _MathUtils} from '@math.gl/core';
+
+type Vector4 = {x: number; y: number; z: number; w: number};
+
+const RIGHT_SHIFT = 1 / 256;
+const LEFT_SHIFT = 256;
+const scratchVector2 = new Vector2();
+const scratchVector3 = new Vector3();
+const scratchEncodeVector2 = new Vector2();
+const octEncodeScratch = new Vector2();
+const uint8ForceArray = new Uint8Array(1);
+
+function forceUint8(value: number): number {
+  uint8ForceArray[0] = value;
+  return uint8ForceArray[0];
+}
+
+function fromSNorm(value: number, rangeMaximum = 255): number {
+  return (clamp(value, 0, rangeMaximum) / rangeMaximum) * 2 - 1;
+}
+
+function toSNorm(value: number, rangeMaximum = 255): number {
+  return Math.round((clamp(value, -1, 1) * 0.5 + 0.5) * rangeMaximum);
+}
+
+function signNotZero(value: number): number {
+  return value < 0 ? -1 : 1;
+}
+
+/**
+ * Encodes a normalized vector into two SNORM values following octahedral encoding.
+ *
+ * @param vector Normalized vector to encode.
+ * @param rangeMaximum Maximum value of the SNORM range.
+ * @param result Target for the two encoded components.
+ */
+export function octEncodeInRange(vector: Vector3, rangeMaximum: number, result: Vector2): Vector2 {
+  assert(vector);
+  assert(result);
+  scratchVector3.from(vector);
+  assert(Math.abs(scratchVector3.magnitudeSquared() - 1) <= _MathUtils.EPSILON6);
+
+  const denominator = Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z);
+  result.x = vector.x / denominator;
+  result.y = vector.y / denominator;
+
+  if (vector.z < 0) {
+    const x = result.x;
+    const y = result.y;
+    result.x = (1 - Math.abs(y)) * signNotZero(x);
+    result.y = (1 - Math.abs(x)) * signNotZero(y);
+  }
+
+  result.x = toSNorm(result.x, rangeMaximum);
+  result.y = toSNorm(result.y, rangeMaximum);
+  return result;
+}
+
+/** Encodes a normalized vector into two 8-bit octahedral components. */
+export function octEncode(vector: Vector3, result: Vector2): Vector2 {
+  return octEncodeInRange(vector, 255, result);
+}
+
+/** Encodes a normalized vector into four 8-bit octahedral components. */
+export function octEncodeToVector4(vector: Vector3, result: Vector4): Vector4 {
+  octEncodeInRange(vector, 65535, octEncodeScratch);
+  result.x = forceUint8(octEncodeScratch.x * RIGHT_SHIFT);
+  result.y = forceUint8(octEncodeScratch.x);
+  result.z = forceUint8(octEncodeScratch.y * RIGHT_SHIFT);
+  result.w = forceUint8(octEncodeScratch.y);
+  return result;
+}
+
+/**
+ * Decodes two SNORM octahedral components into a normalized vector.
+ *
+ * @param x First encoded component.
+ * @param y Second encoded component.
+ * @param rangeMaximum Maximum value of the SNORM range.
+ * @param result Target for the decoded vector.
+ */
+export function octDecodeInRange(
+  x: number,
+  y: number,
+  rangeMaximum: number,
+  result: Vector3
+): Vector3 {
+  assert(result);
+  if (x < 0 || x > rangeMaximum || y < 0 || y > rangeMaximum) {
+    throw new Error(`x and y must be unsigned normalized integers between 0 and ${rangeMaximum}`);
+  }
+
+  result.x = fromSNorm(x, rangeMaximum);
+  result.y = fromSNorm(y, rangeMaximum);
+  result.z = 1 - (Math.abs(result.x) + Math.abs(result.y));
+
+  if (result.z < 0) {
+    const oldX = result.x;
+    result.x = (1 - Math.abs(result.y)) * signNotZero(oldX);
+    result.y = (1 - Math.abs(oldX)) * signNotZero(result.y);
+  }
+  return result.normalize();
+}
+
+/** Decodes two 8-bit octahedral components into a normalized vector. */
+export function octDecode(x: number, y: number, result: Vector3): Vector3 {
+  return octDecodeInRange(x, y, 255, result);
+}
+
+/** Decodes four 8-bit octahedral components into a normalized vector. */
+export function octDecodeFromVector4(encoded: Vector4, result: Vector3): Vector3 {
+  assert(encoded);
+  assert(result);
+  const {x, y, z, w} = encoded;
+  if (x < 0 || x > 255 || y < 0 || y > 255 || z < 0 || z > 255 || w < 0 || w > 255) {
+    throw new Error('x, y, z, and w must be unsigned normalized integers between 0 and 255');
+  }
+  return octDecodeInRange(x * LEFT_SHIFT + y, z * LEFT_SHIFT + w, 65535, result);
+}
+
+/** Packs an octahedrally encoded two-component vector into one number. */
+export function octPackFloat(encoded: Vector2): number {
+  scratchVector2.from(encoded);
+  return 256 * scratchVector2.x + scratchVector2.y;
+}
+
+/** Encodes a normalized vector into an octahedral representation packed into one number. */
+export function octEncodeFloat(vector: Vector3): number {
+  octEncode(vector, scratchEncodeVector2);
+  return octPackFloat(scratchEncodeVector2);
+}
+
+/** Decodes an octahedral representation packed into one number. */
+export function octDecodeFloat(value: number, result: Vector3): Vector3 {
+  assert(Number.isFinite(value));
+  const temporary = value / 256;
+  const x = Math.floor(temporary);
+  const y = (temporary - x) * 256;
+  return octDecode(x, y, result);
+}
+
+/** Packs three normalized vectors into two numeric octahedral values. */
+export function octPack(
+  vector1: Vector3,
+  vector2: Vector3,
+  vector3: Vector3,
+  result: Vector2
+): Vector2 {
+  assert(vector1);
+  assert(vector2);
+  assert(vector3);
+  assert(result);
+  const encoded1 = octEncodeFloat(vector1);
+  const encoded2 = octEncodeFloat(vector2);
+  const encoded3 = octEncode(vector3, scratchEncodeVector2);
+  result.x = 65536 * encoded3.x + encoded1;
+  result.y = 65536 * encoded3.y + encoded2;
+  return result;
+}
+
+/** Decodes three normalized vectors packed by {@link octPack}. */
+export function octUnpack(
+  packed: Vector2,
+  vector1: Vector3,
+  vector2: Vector3,
+  vector3: Vector3
+): void {
+  let temporary = packed.x / 65536;
+  const x = Math.floor(temporary);
+  const encodedFloat1 = (temporary - x) * 65536;
+  temporary = packed.y / 65536;
+  const y = Math.floor(temporary);
+  const encodedFloat2 = (temporary - y) * 65536;
+  octDecodeFloat(encodedFloat1, vector1);
+  octDecodeFloat(encodedFloat2, vector2);
+  octDecode(x, y, vector3);
+}
+
+/** Packs two normalized texture coordinates into one number with 12 bits per component. */
+export function compressTextureCoordinates(textureCoordinates: Vector2): number {
+  const x = (textureCoordinates.x * 4095) | 0;
+  const y = (textureCoordinates.y * 4095) | 0;
+  return 4096 * x + y;
+}
+
+/** Decompresses texture coordinates packed by {@link compressTextureCoordinates}. */
+export function decompressTextureCoordinates(compressed: number, result: Vector2): Vector2 {
+  const temporary = compressed / 4096;
+  const x = Math.floor(temporary);
+  result.x = x / 4095;
+  result.y = (compressed - x * 4096) / 4095;
+  return result;
+}
+
+/** Decodes delta- and ZigZag-encoded vertex buffers in place. */
+export function zigZagDeltaDecode(
+  uBuffer: Uint16Array,
+  vBuffer: Uint16Array,
+  heightBuffer?: Uint16Array | number[]
+): void {
+  assert(uBuffer);
+  assert(vBuffer);
+  assert(uBuffer.length === vBuffer.length);
+  if (heightBuffer) {
+    assert(uBuffer.length === heightBuffer.length);
+  }
+
+  let u = 0;
+  let v = 0;
+  let height = 0;
+  for (let index = 0; index < uBuffer.length; index++) {
+    u += zigZagDecode(uBuffer[index]);
+    v += zigZagDecode(vBuffer[index]);
+    uBuffer[index] = u;
+    vBuffer[index] = v;
+    if (heightBuffer) {
+      height += zigZagDecode(heightBuffer[index]);
+      heightBuffer[index] = height;
+    }
+  }
+}
+
+function zigZagDecode(value: number): number {
+  return (value >> 1) ^ -(value & 1);
+}

package/src/attribute-iterator.ts

@@ -0,0 +1,28 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {TypedArray, TypedArrayConstructor} from '@math.gl/types';
+
+/**
+ * Iterates over the fixed-size elements of a typed array.
+ *
+ * For performance, each iteration reuses the same typed-array view-sized value.
+ */
+export function* makeAttributeIterator(values: TypedArray, size: number): Iterable<TypedArray> {
+  if (!Number.isInteger(size) || size <= 0) {
+    throw new Error('Attribute size must be a positive integer');
+  }
+  if (values.length % size !== 0) {
+    throw new Error('Attribute length must be divisible by its size');
+  }
+
+  const ArrayType = values.constructor as TypedArrayConstructor;
+  const element = new ArrayType(size);
+  for (let index = 0; index < values.length; index += size) {
+    for (let componentIndex = 0; componentIndex < size; componentIndex++) {
+      element[componentIndex] = values[index + componentIndex]!;
+    }
+    yield element;
+  }
+}

package/src/compute-vertex-normals.ts

@@ -0,0 +1,63 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Vector3} from '@math.gl/core';
+import {GL} from './constants';
+import type {Geometry} from './geometry';
+import {getAttributeValues, getPositionAttribute} from './geometry';
+import {makePrimitiveIterator} from './primitive-iterator';
+
+/** Computes smooth, area-weighted vertex normals for a triangle geometry. */
+export function computeVertexNormals(geometry: Geometry): Float32Array {
+  if (
+    geometry.mode !== GL.TRIANGLES &&
+    geometry.mode !== GL.TRIANGLE_STRIP &&
+    geometry.mode !== GL.TRIANGLE_FAN
+  ) {
+    throw new Error('Triangle geometry is required');
+  }
+
+  const position = getPositionAttribute(geometry);
+  const positions = getAttributeValues(position);
+  const positionSize = position.size || 3;
+  if (positionSize < 3) {
+    throw new Error('Position attributes must have at least three components');
+  }
+
+  const vertexCount = positions.length / positionSize;
+  const normals = new Float32Array(vertexCount * 3);
+  const vectorA = new Vector3();
+  const vectorB = new Vector3();
+  const vectorC = new Vector3();
+  const edgeCB = new Vector3();
+  const edgeAB = new Vector3();
+
+  for (const primitive of makePrimitiveIterator(geometry)) {
+    const {i1, i2, i3} = primitive;
+    if (i2 === undefined || i3 === undefined) {
+      continue;
+    }
+    vectorA.fromArray(positions, i1 * positionSize);
+    vectorB.fromArray(positions, i2 * positionSize);
+    vectorC.fromArray(positions, i3 * positionSize);
+    const faceNormal = edgeCB
+      .subVectors(vectorC, vectorB)
+      .cross(edgeAB.subVectors(vectorA, vectorB));
+
+    for (const vertexIndex of [i1, i2, i3]) {
+      normals[vertexIndex * 3] += faceNormal.x;
+      normals[vertexIndex * 3 + 1] += faceNormal.y;
+      normals[vertexIndex * 3 + 2] += faceNormal.z;
+    }
+  }
+
+  const normal = new Vector3();
+  for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
+    normal.fromArray(normals, vertexIndex * 3);
+    if (normal.magnitudeSquared() > 0) {
+      normal.normalize().toArray(normals, vertexIndex * 3);
+    }
+  }
+  return normals;
+}

package/src/constants.ts

@@ -0,0 +1,42 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Portable point, line, and triangle primitive types. */
+export const GL_PRIMITIVE = {
+  POINTS: 0x0000,
+  LINES: 0x0001,
+  TRIANGLES: 0x0004
+} as const;
+
+/** WebGL-compatible primitive topology constants. */
+export const GL_PRIMITIVE_MODE = {
+  POINTS: 0x0000,
+  LINES: 0x0001,
+  LINE_LOOP: 0x0002,
+  LINE_STRIP: 0x0003,
+  TRIANGLES: 0x0004,
+  TRIANGLE_STRIP: 0x0005,
+  TRIANGLE_FAN: 0x0006
+} as const;
+
+/** WebGL-compatible vertex component type constants. */
+export const GL_TYPE = {
+  BYTE: 5120,
+  UNSIGNED_BYTE: 5121,
+  SHORT: 5122,
+  UNSIGNED_SHORT: 5123,
+  INT: 5124,
+  UNSIGNED_INT: 5125,
+  FLOAT: 5126,
+  DOUBLE: 5130,
+  UNSIGNED_SHORT_4_4_4_4: 32819,
+  UNSIGNED_SHORT_5_5_5_1: 32820,
+  UNSIGNED_SHORT_5_6_5: 33635
+} as const;
+
+/** WebGL-compatible constants used by geometry utilities. */
+export const GL = {
+  ...GL_PRIMITIVE_MODE,
+  ...GL_TYPE
+} as const;

package/src/coordinates.ts

@@ -0,0 +1,8 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Wraps a number into the half-open range `[0, 1)`. */
+export function emod(value: number): number {
+  return ((value % 1) + 1) % 1;
+}

package/src/geometry.ts

@@ -0,0 +1,49 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {TypedArray} from '@math.gl/types';
+
+/** A typed geometry attribute with either loaders.gl-style `value` or legacy `values` storage. */
+export type GeometryAttribute = {
+  value?: TypedArray;
+  values?: TypedArray;
+  size?: number;
+};
+
+/** Minimal geometry shape understood by the geometry utilities. */
+export type Geometry = {
+  mode: number;
+  indices?: GeometryAttribute | TypedArray;
+  attributes: Record<string, GeometryAttribute>;
+};
+
+/** Returns whether a value has the minimal geometry shape. */
+export function isGeometry(value: unknown): value is Geometry {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const geometry = value as Partial<Geometry>;
+  return typeof geometry.mode === 'number' && Boolean(geometry.attributes);
+}
+
+/** Returns the typed array stored in a geometry attribute. */
+export function getAttributeValues(attribute: GeometryAttribute | TypedArray): TypedArray {
+  if (ArrayBuffer.isView(attribute)) {
+    return attribute as TypedArray;
+  }
+  const values = attribute.value || attribute.values;
+  if (!values) {
+    throw new Error('Geometry attribute does not contain typed-array values');
+  }
+  return values;
+}
+
+/** Returns a geometry's position attribute. */
+export function getPositionAttribute(geometry: Geometry): GeometryAttribute {
+  const position = geometry.attributes['POSITION'] || geometry.attributes['positions'];
+  if (!position) {
+    throw new Error('Geometry does not contain a position attribute');
+  }
+  return position;
+}