@math.gl/geometry 4.2.0-alpha.5

package/dist/lib/geometry-utils.d.ts

@@ -0,0 +1,9 @@
+import type { GeometryAttribute } from "./geometry.js";
+type GeometryLike = {
+    indices?: GeometryAttribute;
+    attributes: Record<string, GeometryAttribute | undefined>;
+};
+/** Expands indexed attributes into a non-indexed geometry-like object. */
+export declare function unpackIndexedGeometry<T extends GeometryLike>(geometry: T): GeometryLike;
+export {};
+//# sourceMappingURL=geometry-utils.d.ts.map

package/dist/lib/geometry-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-utils.d.ts","sourceRoot":"","sources":["../../src/lib/geometry-utils.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,iBAAiB,EAAC,sBAAmB;AAElD,KAAK,YAAY,GAAG;IAClB,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC,CAAC;CAC3D,CAAC;AAEF,0EAA0E;AAC1E,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,YAAY,EAAE,QAAQ,EAAE,CAAC,GAAG,YAAY,CAqBvF"}

package/dist/lib/geometry-utils.js

@@ -0,0 +1,29 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Expands indexed attributes into a non-indexed geometry-like object. */
+export function unpackIndexedGeometry(geometry) {
+    if (!geometry.indices)
+        return geometry;
+    const indices = geometry.indices.value;
+    const attributes = {};
+    for (const [name, attribute] of Object.entries(geometry.attributes)) {
+        if (!attribute)
+            continue;
+        if (attribute.constant || !attribute.size) {
+            attributes[name] = attribute;
+            continue;
+        }
+        const ArrayType = attribute.value.constructor;
+        const value = new ArrayType(indices.length * attribute.size);
+        for (let i = 0; i < indices.length; i++) {
+            for (let component = 0; component < attribute.size; component++) {
+                value[i * attribute.size + component] =
+                    attribute.value[Number(indices[i]) * attribute.size + component];
+            }
+        }
+        attributes[name] = { ...attribute, value };
+    }
+    return { attributes };
+}
+//# sourceMappingURL=geometry-utils.js.map

package/dist/lib/geometry-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-utils.js","sourceRoot":"","sources":["../../src/lib/geometry-utils.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAUpC,0EAA0E;AAC1E,MAAM,UAAU,qBAAqB,CAAyB,QAAW;IACvE,IAAI,CAAC,QAAQ,CAAC,OAAO;QAAE,OAAO,QAAQ,CAAC;IACvC,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC;IACvC,MAAM,UAAU,GAAsC,EAAE,CAAC;IACzD,KAAK,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;QACpE,IAAI,CAAC,SAAS;YAAE,SAAS;QACzB,IAAI,SAAS,CAAC,QAAQ,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;YAC1C,UAAU,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;YAC7B,SAAS;QACX,CAAC;QACD,MAAM,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,WAAoC,CAAC;QACvE,MAAM,KAAK,GAAG,IAAI,SAAS,CAAC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,IAAI,CAAe,CAAC;QAC3E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,CAAC;gBAChE,KAAK,CAAC,CAAC,GAAG,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC;oBACnC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,CAAC;YACrE,CAAC;QACH,CAAC;QACD,UAAU,CAAC,IAAI,CAAC,GAAG,EAAC,GAAG,SAAS,EAAE,KAAK,EAAC,CAAC;IAC3C,CAAC;IACD,OAAO,EAAC,UAAU,EAAC,CAAC;AACtB,CAAC"}

package/dist/lib/geometry.d.ts

@@ -0,0 +1,36 @@
+import type { TypedArray } from '@math.gl/types';
+export type PrimitiveTopology = 'point-list' | 'line-list' | 'line-strip' | 'triangle-list' | 'triangle-strip';
+export type GeometryAttribute = {
+    size?: number;
+    value: TypedArray;
+    constant?: boolean;
+    normalized?: boolean;
+    [key: string]: unknown;
+};
+export type GeometryAttributeInput = GeometryAttribute | TypedArray;
+export type GeometryAttributes = Record<string, GeometryAttribute | undefined> & {
+    indices?: GeometryAttribute & {
+        size: 1;
+        value: Uint16Array | Uint32Array;
+    };
+};
+export type GeometryProps = {
+    id?: string;
+    topology: PrimitiveTopology;
+    vertexCount?: number;
+    attributes: Record<string, GeometryAttributeInput>;
+    indices?: GeometryAttributeInput;
+};
+/** A renderer-independent, typed-array-backed geometry container. */
+export declare class Geometry {
+    readonly id: string;
+    readonly topology: PrimitiveTopology;
+    readonly vertexCount: number;
+    readonly indices?: GeometryAttribute;
+    readonly attributes: Record<string, GeometryAttribute>;
+    userData: Record<string, unknown>;
+    constructor(props: GeometryProps);
+    getVertexCount(): number;
+    getAttributes(): GeometryAttributes;
+}
+//# sourceMappingURL=geometry.d.ts.map

package/dist/lib/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/lib/geometry.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAE/C,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,eAAe,GACf,gBAAgB,CAAC;AAErB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,iBAAiB,GAAG,UAAU,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC,GAAG;IAC/E,OAAO,CAAC,EAAE,iBAAiB,GAAG;QAAC,IAAI,EAAE,CAAC,CAAC;QAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAAA;KAAC,CAAC;CAC3E,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;IACnD,OAAO,CAAC,EAAE,sBAAsB,CAAC;CAClC,CAAC;AAIF,qEAAqE;AACrE,qBAAa,QAAQ;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACvD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM;gBAE3B,KAAK,EAAE,aAAa;IAkChC,cAAc,IAAI,MAAM;IAIxB,aAAa,IAAI,kBAAkB;CAKpC"}

package/dist/lib/geometry.js

@@ -0,0 +1,89 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+let geometryId = 0;
+/** A renderer-independent, typed-array-backed geometry container. */
+export class Geometry {
+    constructor(props) {
+        this.userData = {};
+        this.id = props.id || `geometry-${++geometryId}`;
+        this.topology = props.topology;
+        this.attributes = {};
+        let indices = props.indices ? normalizeAttribute(props.indices) : undefined;
+        for (const [name, input] of Object.entries(props.attributes || {})) {
+            const attribute = normalizeAttribute(input);
+            if (name === 'POSITION' || name === 'positions') {
+                attribute.size || (attribute.size = 3);
+            }
+            if (name === 'indices') {
+                if (indices)
+                    throw new Error('Geometry has multiple index attributes');
+                indices = attribute;
+            }
+            else {
+                this.attributes[name] = attribute;
+            }
+        }
+        if (indices) {
+            if (!(indices.value instanceof Uint16Array || indices.value instanceof Uint32Array)) {
+                throw new Error('Geometry indices must be a Uint16Array or Uint32Array');
+            }
+            indices.size = 1;
+            this.indices = indices;
+            validateIndices(indices, this.attributes);
+        }
+        this.vertexCount = props.vertexCount ?? calculateVertexCount(this.attributes, this.indices);
+        if (!Number.isInteger(this.vertexCount) || this.vertexCount < 0) {
+            throw new Error('Geometry vertexCount must be a non-negative integer');
+        }
+    }
+    getVertexCount() {
+        return this.vertexCount;
+    }
+    getAttributes() {
+        return (this.indices ? { indices: this.indices, ...this.attributes } : this.attributes);
+    }
+}
+function normalizeAttribute(input) {
+    const attribute = isTypedArray(input) ? { value: input } : { ...input };
+    if (!isTypedArray(attribute.value)) {
+        throw new Error('Geometry attributes must contain a typed-array value');
+    }
+    if (attribute.size !== undefined && (!Number.isInteger(attribute.size) || attribute.size < 1)) {
+        throw new Error('Geometry attribute size must be a positive integer');
+    }
+    if (attribute.size && attribute.value.length % attribute.size !== 0) {
+        throw new Error('Geometry attribute length must be divisible by its size');
+    }
+    return attribute;
+}
+function isTypedArray(value) {
+    return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function validateIndices(indices, attributes) {
+    let maximumIndex = -1;
+    for (const index of indices.value)
+        maximumIndex = Math.max(maximumIndex, Number(index));
+    for (const [name, attribute] of Object.entries(attributes)) {
+        if (!attribute.constant && attribute.size) {
+            const attributeVertexCount = attribute.value.length / attribute.size;
+            if (maximumIndex >= attributeVertexCount) {
+                throw new Error(`Geometry index ${maximumIndex} exceeds ${name} vertex count ${attributeVertexCount}`);
+            }
+        }
+    }
+}
+function calculateVertexCount(attributes, indices) {
+    if (indices)
+        return indices.value.length;
+    let count = Infinity;
+    for (const attribute of Object.values(attributes)) {
+        if (!attribute.constant && attribute.size) {
+            count = Math.min(count, attribute.value.length / attribute.size);
+        }
+    }
+    if (!Number.isFinite(count))
+        throw new Error('Geometry has no countable attributes');
+    return count;
+}
+//# sourceMappingURL=geometry.js.map

package/dist/lib/geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../src/lib/geometry.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@math.gl/geometry",
+  "description": "CPU geometry primitives and tessellation for math.gl",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "4.2.0-alpha.5",
+  "keywords": [
+    "geometry",
+    "gltf",
+    "math",
+    "mesh",
+    "tessellation",
+    "3d"
+  ],
+  "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/types": "4.2.0-alpha.5"
+  },
+  "gitHead": "9c13785761867748e2edb167b5f2749dce803039"
+}

package/src/geometries/box-geometry.ts

@@ -0,0 +1,70 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Geometry, type GeometryAttributeInput} from '../lib/geometry';
+import {assertPositive, makeIndices, type PrimitiveGeometryProps} from './geometry-helpers';
+
+export type BoxGeometryProps = PrimitiveGeometryProps & {size?: readonly [number, number, number]};
+
+/** Tessellates the glTF box shape: centered at the origin with total axis lengths `size`. */
+export class BoxGeometry extends Geometry {
+  constructor(props: BoxGeometryProps = {}) {
+    const size = props.size || [1, 1, 1];
+    assertPositive(size[0], 'size[0]');
+    assertPositive(size[1], 'size[1]');
+    assertPositive(size[2], 'size[2]');
+    const half = [size[0] / 2, size[1] / 2, size[2] / 2];
+    const positions: number[] = [];
+    const normals: number[] = [];
+    const texCoords: number[] = [];
+    const indices: number[] = [];
+    const faces = [
+      {n: [1, 0, 0], u: [0, 0, -1], v: [0, 1, 0], h1: half[2], h2: half[1]},
+      {n: [-1, 0, 0], u: [0, 0, 1], v: [0, 1, 0], h1: half[2], h2: half[1]},
+      {n: [0, 1, 0], u: [1, 0, 0], v: [0, 0, -1], h1: half[0], h2: half[2]},
+      {n: [0, -1, 0], u: [1, 0, 0], v: [0, 0, 1], h1: half[0], h2: half[2]},
+      {n: [0, 0, 1], u: [1, 0, 0], v: [0, 1, 0], h1: half[0], h2: half[1]},
+      {n: [0, 0, -1], u: [-1, 0, 0], v: [0, 1, 0], h1: half[0], h2: half[1]}
+    ];
+    for (const face of faces) {
+      const base = positions.length / 3;
+      for (const [s, t, u, v] of [
+        [-1, -1, 0, 0],
+        [1, -1, 1, 0],
+        [1, 1, 1, 1],
+        [-1, 1, 0, 1]
+      ]) {
+        positions.push(
+          face.n[0] * half[0] + face.u[0] * face.h1 * s + face.v[0] * face.h2 * t,
+          face.n[1] * half[1] + face.u[1] * face.h1 * s + face.v[1] * face.h2 * t,
+          face.n[2] * half[2] + face.u[2] * face.h1 * s + face.v[2] * face.h2 * t
+        );
+        normals.push(...face.n);
+        texCoords.push(u, v);
+      }
+      indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+    }
+    super({
+      id: props.id,
+      topology: 'triangle-list',
+      indices: makeIndices(24, indices),
+      attributes: {
+        POSITION: {size: 3, value: new Float32Array(positions)},
+        NORMAL: {size: 3, value: new Float32Array(normals)},
+        TEXCOORD_0: {size: 2, value: new Float32Array(texCoords)},
+        ...props.attributes
+      } as Record<string, GeometryAttributeInput>
+    });
+  }
+}
+
+export type CubeGeometryProps = PrimitiveGeometryProps & {size?: number};
+
+/** Convenience alias for an equal-sided box. */
+export class CubeGeometry extends BoxGeometry {
+  constructor(props: CubeGeometryProps = {}) {
+    const size = props.size ?? 1;
+    super({...props, size: [size, size, size]});
+  }
+}

package/src/geometries/capsule-geometry.ts

@@ -0,0 +1,120 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Geometry} from '../lib/geometry';
+import {
+  assertNonNegative,
+  assertPositive,
+  assertSegments,
+  type PrimitiveGeometryProps
+} from './geometry-helpers';
+import {makeSurfaceOfRevolution, type ProfileRing} from './surface-of-revolution';
+
+export type CapsuleGeometryProps = PrimitiveGeometryProps & {
+  height?: number;
+  radiusBottom?: number;
+  radiusTop?: number;
+  nradial?: number;
+  ncap?: number;
+  nvertical?: number;
+};
+
+/** Tessellates the convex hull of two endpoint spheres described by the glTF capsule shape. */
+export class CapsuleGeometry extends Geometry {
+  constructor(props: CapsuleGeometryProps = {}) {
+    const {
+      height = 1,
+      radiusBottom = 0.5,
+      radiusTop = 0.5,
+      nradial = 10,
+      ncap = 5,
+      nvertical = 1
+    } = props;
+    assertPositive(height, 'height');
+    assertNonNegative(radiusBottom, 'radiusBottom');
+    assertNonNegative(radiusTop, 'radiusTop');
+    if (radiusBottom === 0 && radiusTop === 0)
+      throw new Error('At least one radius must be greater than zero');
+    assertSegments(nradial, 'nradial', 3);
+    assertSegments(ncap, 'ncap', 1);
+    assertSegments(nvertical, 'nvertical', 1);
+
+    const rings: ProfileRing[] = [];
+    const deltaRadius = radiusTop - radiusBottom;
+    if (Math.abs(deltaRadius) >= height) {
+      const topWins = radiusTop >= radiusBottom;
+      const radius = topWins ? radiusTop : radiusBottom;
+      const center = topWins ? height / 2 : -height / 2;
+      addSphereRings(rings, center, radius, ncap * 2);
+    } else {
+      const sinSlope = deltaRadius / height;
+      const radialNormal = Math.sqrt(1 - sinSlope * sinSlope);
+      const sideNormalY = -sinSlope;
+      const bottomCenter = -height / 2;
+      const topCenter = height / 2;
+      for (let i = 0; i <= ncap; i++) {
+        const normalY = -1 + ((sideNormalY + 1) * i) / ncap;
+        const normalRadius = Math.sqrt(Math.max(0, 1 - normalY * normalY));
+        rings.push({
+          radius: radiusBottom * normalRadius,
+          y: bottomCenter + radiusBottom * normalY,
+          normalRadius,
+          normalY
+        });
+      }
+      for (let i = 1; i <= nvertical; i++) {
+        const t = i / nvertical;
+        const radius = radiusBottom + deltaRadius * t;
+        const center = bottomCenter + height * t;
+        rings.push({
+          radius: radius * radialNormal,
+          y: center + radius * sideNormalY,
+          normalRadius: radialNormal,
+          normalY: sideNormalY
+        });
+      }
+      for (let i = 1; i <= ncap; i++) {
+        const normalY = sideNormalY + ((1 - sideNormalY) * i) / ncap;
+        const normalRadius = Math.sqrt(Math.max(0, 1 - normalY * normalY));
+        rings.push({
+          radius: radiusTop * normalRadius,
+          y: topCenter + radiusTop * normalY,
+          normalRadius,
+          normalY
+        });
+      }
+    }
+    const mesh = makeSurfaceOfRevolution(rings, nradial);
+    super({
+      id: props.id,
+      topology: 'triangle-list',
+      indices: mesh.indexArray,
+      attributes: {
+        POSITION: {size: 3, value: new Float32Array(mesh.positions)},
+        NORMAL: {size: 3, value: new Float32Array(mesh.normals)},
+        TEXCOORD_0: {size: 2, value: new Float32Array(mesh.texCoords)},
+        ...props.attributes
+      }
+    });
+  }
+}
+
+function addSphereRings(
+  rings: ProfileRing[],
+  center: number,
+  radius: number,
+  segments: number
+): void {
+  for (let i = 0; i <= segments; i++) {
+    const angle = -Math.PI / 2 + (i / segments) * Math.PI;
+    const normalRadius = Math.cos(angle);
+    const normalY = Math.sin(angle);
+    rings.push({
+      radius: radius * normalRadius,
+      y: center + radius * normalY,
+      normalRadius,
+      normalY
+    });
+  }
+}

package/src/geometries/cylinder-geometry.ts

@@ -0,0 +1,41 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {TruncatedConeGeometry, type TruncatedConeGeometryProps} from './truncated-cone-geometry';
+
+export type CylinderGeometryProps = Omit<
+  TruncatedConeGeometryProps,
+  'topRadius' | 'bottomRadius' | 'topCap' | 'bottomCap' | 'verticalAxis'
+> & {
+  radiusTop?: number;
+  radiusBottom?: number;
+};
+
+/** Tessellates the closed, Y-aligned glTF cylinder shape, including tapered cylinders. */
+export class CylinderGeometry extends TruncatedConeGeometry {
+  constructor(props: CylinderGeometryProps = {}) {
+    const {height = 2, radiusTop = 0.5, radiusBottom = 0.5} = props;
+    super({
+      ...props,
+      height,
+      topRadius: radiusTop,
+      bottomRadius: radiusBottom,
+      topCap: true,
+      bottomCap: true,
+      verticalAxis: 'y'
+    });
+  }
+}
+
+export type ConeGeometryProps = Omit<TruncatedConeGeometryProps, 'topRadius' | 'bottomRadius'> & {
+  radius?: number;
+};
+
+/** Convenience closed cone with its point at +Y. */
+export class ConeGeometry extends TruncatedConeGeometry {
+  constructor(props: ConeGeometryProps = {}) {
+    const {radius = 0.5, topCap = false, bottomCap = true} = props;
+    super({...props, topRadius: 0, bottomRadius: radius, topCap, bottomCap});
+  }
+}

package/src/geometries/geometry-helpers.ts

@@ -0,0 +1,34 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GeometryAttributeInput} from '../lib/geometry';
+
+export type PrimitiveGeometryProps = {
+  id?: string;
+  attributes?: Record<string, GeometryAttributeInput>;
+};
+
+export function assertPositive(value: number, name: string): void {
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`${name} must be greater than zero`);
+}
+
+export function assertNonNegative(value: number, name: string): void {
+  if (!Number.isFinite(value) || value < 0) throw new Error(`${name} must be non-negative`);
+}
+
+export function assertSegments(value: number, name: string, minimum = 1): void {
+  if (!Number.isInteger(value) || value < minimum)
+    throw new Error(`${name} must be an integer >= ${minimum}`);
+}
+
+export function makeIndices(vertexCount: number, values: number[]): Uint16Array | Uint32Array {
+  return vertexCount > 0xffff ? new Uint32Array(values) : new Uint16Array(values);
+}
+
+export type MeshData = {
+  positions: number[];
+  normals: number[];
+  texCoords: number[];
+  indices: number[];
+};

package/src/geometries/ico-sphere-geometry.ts

@@ -0,0 +1,96 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Geometry} from '../lib/geometry';
+import {assertPositive, assertSegments, type PrimitiveGeometryProps} from './geometry-helpers';
+
+export type IcoSphereGeometryProps = PrimitiveGeometryProps & {
+  radius?: number;
+  iterations?: number;
+};
+
+/** Subdivided icosahedron projected onto a sphere. Returned as a non-indexed triangle list. */
+export class IcoSphereGeometry extends Geometry {
+  constructor(props: IcoSphereGeometryProps = {}) {
+    const {radius = 0.5, iterations = 0} = props;
+    assertPositive(radius, 'radius');
+    assertSegments(iterations, 'iterations', 0);
+    if (iterations > 8) throw new Error('iterations must be <= 8');
+    const t = (1 + Math.sqrt(5)) / 2;
+    const vertices = [
+      [-1, t, 0],
+      [1, t, 0],
+      [-1, -t, 0],
+      [1, -t, 0],
+      [0, -1, t],
+      [0, 1, t],
+      [0, -1, -t],
+      [0, 1, -t],
+      [t, 0, -1],
+      [t, 0, 1],
+      [-t, 0, -1],
+      [-t, 0, 1]
+    ].map(normalize);
+    let faces = [
+      [0, 11, 5],
+      [0, 5, 1],
+      [0, 1, 7],
+      [0, 7, 10],
+      [0, 10, 11],
+      [1, 5, 9],
+      [5, 11, 4],
+      [11, 10, 2],
+      [10, 7, 6],
+      [7, 1, 8],
+      [3, 9, 4],
+      [3, 4, 2],
+      [3, 2, 6],
+      [3, 6, 8],
+      [3, 8, 9],
+      [4, 9, 5],
+      [2, 4, 11],
+      [6, 2, 10],
+      [8, 6, 7],
+      [9, 8, 1]
+    ].map(face => face.map(index => vertices[index]));
+    for (let iteration = 0; iteration < iterations; iteration++) {
+      const subdivided: number[][][] = [];
+      for (const [a, b, c] of faces) {
+        const ab = normalize([a[0] + b[0], a[1] + b[1], a[2] + b[2]]);
+        const bc = normalize([b[0] + c[0], b[1] + c[1], b[2] + c[2]]);
+        const ca = normalize([c[0] + a[0], c[1] + a[1], c[2] + a[2]]);
+        subdivided.push([a, ab, ca], [b, bc, ab], [c, ca, bc], [ab, bc, ca]);
+      }
+      faces = subdivided;
+    }
+    const positions: number[] = [];
+    const normals: number[] = [];
+    const texCoords: number[] = [];
+    for (const face of faces) {
+      for (const normal of face) {
+        positions.push(normal[0] * radius, normal[1] * radius, normal[2] * radius);
+        normals.push(...normal);
+        texCoords.push(
+          0.5 + Math.atan2(normal[0], normal[2]) / (2 * Math.PI),
+          0.5 - Math.asin(normal[1]) / Math.PI
+        );
+      }
+    }
+    super({
+      id: props.id,
+      topology: 'triangle-list',
+      attributes: {
+        POSITION: {size: 3, value: new Float32Array(positions)},
+        NORMAL: {size: 3, value: new Float32Array(normals)},
+        TEXCOORD_0: {size: 2, value: new Float32Array(texCoords)},
+        ...props.attributes
+      }
+    });
+  }
+}
+
+function normalize(vector: number[]): number[] {
+  const length = Math.hypot(...vector);
+  return vector.map(component => component / length);
+}

package/src/geometries/plane-geometry.ts

@@ -0,0 +1,64 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Geometry} from '../lib/geometry';
+import {
+  assertPositive,
+  assertSegments,
+  makeIndices,
+  type PrimitiveGeometryProps
+} from './geometry-helpers';
+
+export type PlaneGeometryProps = PrimitiveGeometryProps & {
+  sizeX: number;
+  sizeZ: number;
+  nx?: number;
+  nz?: number;
+};
+
+/** Tessellates a finite glTF plane in XZ with its front face and normal pointing +Y. */
+export class PlaneGeometry extends Geometry {
+  constructor(props: PlaneGeometryProps) {
+    const {sizeX, sizeZ, nx = 1, nz = 1} = props;
+    assertPositive(sizeX, 'sizeX');
+    assertPositive(sizeZ, 'sizeZ');
+    assertSegments(nx, 'nx');
+    assertSegments(nz, 'nz');
+    const positions: number[] = [];
+    const normals: number[] = [];
+    const texCoords: number[] = [];
+    const indexValues: number[] = [];
+    for (let z = 0; z <= nz; z++) {
+      const v = z / nz;
+      for (let x = 0; x <= nx; x++) {
+        const u = x / nx;
+        positions.push((u - 0.5) * sizeX, 0, (0.5 - v) * sizeZ);
+        normals.push(0, 1, 0);
+        texCoords.push(u, v);
+      }
+    }
+    const stride = nx + 1;
+    for (let z = 0; z < nz; z++) {
+      for (let x = 0; x < nx; x++) {
+        const a = z * stride + x;
+        const b = a + 1;
+        const c = a + stride;
+        const d = c + 1;
+        indexValues.push(a, b, d, a, d, c);
+      }
+    }
+    const vertexCount = positions.length / 3;
+    super({
+      id: props.id,
+      topology: 'triangle-list',
+      indices: makeIndices(vertexCount, indexValues),
+      attributes: {
+        POSITION: {size: 3, value: new Float32Array(positions)},
+        NORMAL: {size: 3, value: new Float32Array(normals)},
+        TEXCOORD_0: {size: 2, value: new Float32Array(texCoords)},
+        ...props.attributes
+      }
+    });
+  }
+}