leaflet-city-mapper 0.0.9 → 0.1.1

package/src/models/README.md

@@ -0,0 +1,27 @@
+# Models
+
+[Source guide](../README.md) | [Project README](../../README.md)
+
+Loads static GLB/glTF resources, decodes model attributes and builds scene nodes.
+Model loading uses a source worker before attaching nodes to the layer.
+
+## Loading and attachment
+
+```mermaid
+flowchart LR
+  Added["Layer added"] --> Worker["Worker: decode glTF / GLB + resources"]
+  Worker --> View["Wait for camera view"]
+  View --> Nodes["Build nodes, geometry and materials"]
+  Nodes --> Transform["Apply layer transform"]
+  Transform --> Attach["Attach to layer root"]
+  Attach --> Terrain["Optional terrain conformance"]
+```
+
+Missing scenes and empty root lists are errors. For misplaced models, inspect
+node and layer [transforms](../transforms/README.md) before projection.
+
+- [loadModel.js](./loadModel.js): load, attach and optionally conform a model to terrain.
+- [decodeModel.js](./decodeModel.js): decode model content.
+- [buildModelNodes.js](./buildModelNodes.js): assemble model scene nodes.
+
+Related: [workers](../workers/README.md), [materials](../materials/README.md), [transforms](../transforms/README.md).

package/src/models/applyModelTransform.js

@@ -1,14 +1,18 @@
 import { modelByLayer } from '../weakmaps/modelByLayer.js';
 
-
-export function applyModelTransform(layer) {
-  const model = modelByLayer.get(layer);
-  if (layer.options.rotation) {
-    const [x, y = x, z = x] = layer.options.rotation;
-    model.rotation[0] = x; model.rotation[1] = y; model.rotation[2] = z;
-  }
-  if (layer.options.scale) {
-    const [x, y = x, z = x] = layer.options.scale;
-    model.scale[0] = x; model.scale[1] = y; model.scale[2] = z;
-  }
-}
+/**
+ * Apply the layer's optional rotation and scale to its model.
+ *
+ * @param {L.Layer} layer Layer containing the transform options.
+ */
+export function applyModelTransform(layer) {
+  const model = modelByLayer.get(layer);
+  if (layer.options.rotation) {
+    const [x, y = x, z = x] = layer.options.rotation;
+    model.rotation[0] = x; model.rotation[1] = y; model.rotation[2] = z;
+  }
+  if (layer.options.scale) {
+    const [x, y = x, z = x] = layer.options.scale;
+    model.scale[0] = x; model.scale[1] = y; model.scale[2] = z;
+  }
+}

package/src/models/buildModelNodes.js

@@ -1,14 +1,24 @@
-import { modelNode } from './modelNode.js';
-import { releaseModelResources } from './releaseModelResources.js';
-
-export function buildModelNodes(context, scene) {
-  const nodes = /* alloc */ [];
-  let index;
-  try {
-    for (index of scene.nodes) nodes.push(modelNode(context, index));
-  } catch (error) {
-    releaseModelResources(context);
-    throw error;
-  }
-  return nodes;
-}
+import { modelNode } from './modelNode.js';
+import { releaseModelResources } from './releaseModelResources.js';
+
+/**
+ * Build scene roots, releasing allocated resources if node construction fails.
+ *
+ * @param {Object} context Model construction context.
+ * @param {Object} scene glTF scene containing root node indices.
+ *
+ * @returns {Array<Object>} Built root nodes.
+ *
+ * @throws {Error} If building a node fails.
+ */
+export function buildModelNodes(context, scene) {
+  const nodes = /* alloc */ [];
+  let index;
+  try {
+    for (index of scene.nodes) nodes.push(modelNode(context, index));
+  } catch (error) {
+    releaseModelResources(context);
+    throw error;
+  }
+  return nodes;
+}

package/src/models/createModelContext.js

@@ -1,15 +1,24 @@
-import { geometryEmpty } from '../globals/geometryEmpty.js';
-import { materialFor } from '../materials/modelMaterialFor.js';
-
-export function createModelContext(layer, description, images) {
-  const context = /* alloc */ {
-    backend: layer, description, images,
-    textures: /* alloc */ new Map(),
-    materials: /* alloc */ [],
-    active: /* alloc */ new Set(),
-    resources: /* alloc */ [],
-  };
-  let material;
-  for (material of description.materials || geometryEmpty) context.materials.push(materialFor(context, material));
-  return context;
-}
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+import { materialFor } from '../materials/modelMaterialFor.js';
+
+/**
+ * Create the model construction context and prepare its materials.
+ *
+ * @param {L.Layer} layer Rendering backend for the model.
+ * @param {Object} description Decoded glTF document.
+ * @param {Array} images Loaded model images.
+ *
+ * @returns {Object} Context containing materials, textures and tracked resources.
+ */
+export function createModelContext(layer, description, images) {
+  const context = /* alloc */ {
+    backend: layer, description, images,
+    textures: /* alloc */ new Map(),
+    materials: /* alloc */ [],
+    active: /* alloc */ new Set(),
+    resources: /* alloc */ [],
+  };
+  let material;
+  for (material of description.materials || geometryEmpty) context.materials.push(materialFor(context, material));
+  return context;
+}

package/src/models/decodeModel.js

@@ -1,8 +1,19 @@
 import { geometryDecoder } from '../globals/geometryDecoder.js';
-/** Decode a static glTF JSON document or GLB v2 container. */
 import { hasUnsupportedPrimitives } from './hasUnsupportedPrimitives.js';
 
-
+/**
+ * Decode a static glTF JSON document or GLB v2 container.
+ *
+ * @param {ArrayBuffer} data Encoded glTF or GLB data.
+ *
+ * @returns {Object} Decoded glTF document.
+ *
+ * @throws {Error} If the GLB header is invalid.
+ * @throws {Error} If a GLB chunk header is truncated.
+ * @throws {Error} If GLB chunk data is truncated.
+ * @throws {Error} If the GLB JSON chunk is missing.
+ * @throws {Error} If the model uses unsupported glTF features.
+ */
 export function decodeModel(data) {
   const view = /* alloc */ new DataView(data);
   const decoder = geometryDecoder;

package/src/models/hasUnsupportedPrimitives.js

@@ -1,3 +1,10 @@
+/**
+ * Check whether any mesh uses morph targets or a non-triangle primitive mode.
+ *
+ * @param {Array<Object>} meshes glTF meshes, if present.
+ *
+ * @returns {boolean} Whether unsupported primitives were found.
+ */
 export function hasUnsupportedPrimitives(meshes) {
   if (!meshes) return false;
   let mesh, primitive;

package/src/models/loadBuffer.js

@@ -1,6 +1,16 @@
-export async function loadBuffer(buffer, directory) {
-  if (buffer.binary) return;
-  const response = await fetch(/* alloc */ new URL(buffer.uri, directory).href);
-  if (!response.ok) throw /* alloc */ new Error(`Unable to load model buffer: HTTP ${response.status}`);
-  buffer.binary = await response.arrayBuffer();
-}
+/**
+ * Fetch a glTF buffer into its binary property unless already loaded.
+ *
+ * @param {Object} buffer Buffer description and URI.
+ * @param {string} directory Base URL for the buffer URI.
+ *
+ * @returns {Promise<void>} Completion of the buffer load.
+ *
+ * @throws {Error} If the buffer response is not successful.
+ */
+export async function loadBuffer(buffer, directory) {
+  if (buffer.binary) return;
+  const response = await fetch(/* alloc */ new URL(buffer.uri, directory).href);
+  if (!response.ok) throw /* alloc */ new Error(`Unable to load model buffer: HTTP ${response.status}`);
+  buffer.binary = await response.arrayBuffer();
+}

package/src/models/loadModel.js

@@ -4,9 +4,6 @@ import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
 import { rootByLayer } from '../weakmaps/rootByLayer.js';
 import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
 import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
-
-
-
 import { runSourceWorker } from '../workers/runSourceWorker.js';
 import { setParent } from '../scene/setParent.js';
 import { emptyNode } from '../scene/createSceneNode.js';
@@ -15,10 +12,16 @@ import { createModelContext } from './createModelContext.js';
 import { buildModelNodes } from './buildModelNodes.js';
 import { applyModelTransform } from './applyModelTransform.js';
 
-
-/** glTF/GLB model loading. */
-/** Load the configured GLB/glTF (static triangles) under `root`; GPU resources need attachment. */
-
+/**
+ * Load the configured static GLB/glTF model, attach it to the layer and conform it to terrain.
+ *
+ * @param {L.Layer} layer Layer that owns the model and its scene root.
+ *
+ * @returns {Promise<void>} Completion of the model load.
+ *
+ * @throws {Error} If the glTF scene is missing.
+ * @throws {Error} If the glTF scene has no root nodes.
+ */
 export async function loadModel(layer) {
   await addedByLayer.get(layer).promise;
   const url = /* alloc */ new URL(modelUrlByLayer.get(layer), document.baseURI).href;

package/src/models/loadModelResources.js

@@ -1,14 +1,22 @@
-import { geometryEmpty } from '../globals/geometryEmpty.js';
-import { loadBuffer } from './loadBuffer.js';
-import { loadImage } from '../textures/loadModelImage.js';
-
-export async function loadModelResources(description, directory) {
-  const bufferRequests = /* alloc */ [];
-  let buffer;
-  for (buffer of description.buffers || geometryEmpty) bufferRequests.push(loadBuffer(buffer, directory));
-  await Promise.all(bufferRequests);
-  const imageRequests = /* alloc */ [];
-  let image;
-  for (image of description.images || geometryEmpty) imageRequests.push(loadImage(description, directory, image));
-  return Promise.all(imageRequests);
-}
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+import { loadBuffer } from './loadBuffer.js';
+import { loadImage } from '../textures/loadModelImage.js';
+
+/**
+ * Load the buffers and images referenced by a decoded glTF document.
+ *
+ * @param {Object} description Decoded glTF document.
+ * @param {string} directory Base URL for resource URIs.
+ *
+ * @returns {Promise<Array>} Loaded images.
+ */
+export async function loadModelResources(description, directory) {
+  const bufferRequests = /* alloc */ [];
+  let buffer;
+  for (buffer of description.buffers || geometryEmpty) bufferRequests.push(loadBuffer(buffer, directory));
+  await Promise.all(bufferRequests);
+  const imageRequests = /* alloc */ [];
+  let image;
+  for (image of description.images || geometryEmpty) imageRequests.push(loadImage(description, directory, image));
+  return Promise.all(imageRequests);
+}

package/src/models/modelNode.js

@@ -1,11 +1,21 @@
 import { nextId } from '../globals/nextId.js';
 import { geometryEmpty } from '../globals/geometryEmpty.js';
-
 import { emptyNode } from '../scene/createSceneNode.js';
 import { nodeMatrix } from '../transforms/modelNodeMatrix.js';
 import { setParent } from '../scene/setParent.js';
 import { createModelGeometry } from '../geometry/createModelGeometry.js';
 
+/**
+ * Recursively construct a scene node and its mesh primitives and children.
+ *
+ * @param {Object} context Model construction context.
+ * @param {number} index Index into the glTF nodes array.
+ *
+ * @returns {Object} Constructed scene node.
+ *
+ * @throws {Error} If the node forms a cycle.
+ * @throws {Error} If the node index is invalid.
+ */
 export function modelNode(context, index) {
   const { backend: layer, description, active } = context;
   // Track only the recursion path: shared mesh references are valid, cycles are not.

package/src/models/normalizeAccessor.js

@@ -1,11 +1,21 @@
-export function normalizeAccessor(spec, Type, data, size) {
-  const normalized = /* alloc */ new Float32Array(data.length);
-  let i;
-  for (i = 0; i < data.length; i++) {
-    normalized[i] = spec.normalized
-      ? Math.max(-1, data[i] / (Type === Int8Array ? 127 : Type === Int16Array ? 32767 :
-        Type === Uint8Array ? 255 : Type === Uint32Array ? 4294967295 : 65535))
-      : data[i];
-  }
-  return /* alloc */ { data: normalized, size, indices: data };
-}
+/**
+ * Convert integer accessor data to floats, applying glTF normalization when requested.
+ *
+ * @param {Object} spec glTF accessor specification.
+ * @param {TypedArrayConstructor} Type Integer component array constructor.
+ * @param {TypedArray} data Raw accessor components.
+ * @param {number} size Components per element.
+ *
+ * @returns {Object} Float data, element size and original integer data.
+ */
+export function normalizeAccessor(spec, Type, data, size) {
+  const normalized = /* alloc */ new Float32Array(data.length);
+  let i;
+  for (i = 0; i < data.length; i++) {
+    normalized[i] = spec.normalized
+      ? Math.max(-1, data[i] / (Type === Int8Array ? 127 : Type === Int16Array ? 32767 :
+        Type === Uint8Array ? 255 : Type === Uint32Array ? 4294967295 : 65535))
+      : data[i];
+  }
+  return /* alloc */ { data: normalized, size, indices: data };
+}

package/src/models/prepareModel.js

@@ -1,19 +1,29 @@
-import { decodeModel } from './decodeModel.js';
-import { loadModelResources } from './loadModelResources.js';
-import { prepareModelGeometry } from './prepareModelGeometry.js';
-
-export async function prepareModel(url) {
-  const response = await fetch(url);
-  if (!response.ok) throw /* alloc */ new Error(`Unable to load model: HTTP ${response.status}`);
-  const description = decodeModel(await response.arrayBuffer());
-  const scene = description.scenes?.[description.scene || 0];
-  if (!scene) throw /* alloc */ new Error('Missing glTF scene');
-  const images = await loadModelResources(description, /* alloc */ new URL('.', url).href);
-  const transfers = prepareModelGeometry(description, scene);
-  let image;
-  for (image of images) transfers.push(image);
-  delete description.buffers;
-  delete description.bufferViews;
-  delete description.accessors;
-  return /* alloc */ { description, images, transfers };
-}
+import { decodeModel } from './decodeModel.js';
+import { loadModelResources } from './loadModelResources.js';
+import { prepareModelGeometry } from './prepareModelGeometry.js';
+
+/**
+ * Fetch a static model and prepare its images and geometry for transfer from a worker.
+ *
+ * @param {string} url Model URL.
+ *
+ * @returns {Promise<Object>} Prepared description, images and transferables.
+ *
+ * @throws {Error} If the model response is not successful.
+ * @throws {Error} If the glTF scene is missing.
+ */
+export async function prepareModel(url) {
+  const response = await fetch(url);
+  if (!response.ok) throw /* alloc */ new Error(`Unable to load model: HTTP ${response.status}`);
+  const description = decodeModel(await response.arrayBuffer());
+  const scene = description.scenes?.[description.scene || 0];
+  if (!scene) throw /* alloc */ new Error('Missing glTF scene');
+  const images = await loadModelResources(description, /* alloc */ new URL('.', url).href);
+  const transfers = prepareModelGeometry(description, scene);
+  let image;
+  for (image of images) transfers.push(image);
+  delete description.buffers;
+  delete description.bufferViews;
+  delete description.accessors;
+  return /* alloc */ { description, images, transfers };
+}

package/src/models/prepareModelGeometry.js

@@ -1,25 +1,35 @@
-import { geometryEmpty } from '../globals/geometryEmpty.js';
-import { prepareModelPrimitive } from './prepareModelPrimitive.js';
-
-export function prepareModelGeometry(description, scene) {
-  const pending = scene.nodes.slice(), visited = /* alloc */ new Set();
-  const meshes = /* alloc */ new Set(), transfers = /* alloc */ new Set();
-  let index, spec, primitive, attribute, child;
-  while (pending.length) {
-    index = pending.pop();
-    if (visited.has(index)) continue;
-    visited.add(index);
-    spec = description.nodes[index];
-    if (!spec) throw /* alloc */ new Error('Invalid glTF node');
-    if (spec.mesh !== undefined) meshes.add(spec.mesh);
-    for (child of spec.children || geometryEmpty) pending.push(child);
-  }
-  for (index of meshes) {
-    for (primitive of description.meshes[index].primitives) {
-      for (attribute of Object.values(prepareModelPrimitive(description, primitive))) {
-        transfers.add(attribute.data.buffer);
-      }
-    }
-  }
-  return /* alloc */ [...transfers];
-}
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+import { prepareModelPrimitive } from './prepareModelPrimitive.js';
+
+/**
+ * Prepare geometry for meshes reachable from the scene and collect their buffers.
+ *
+ * @param {Object} description Decoded glTF document with loaded buffers.
+ * @param {Object} scene glTF scene containing root node indices.
+ *
+ * @returns {Array<ArrayBuffer>} Unique geometry buffers to transfer.
+ *
+ * @throws {Error} If a referenced node is invalid.
+ */
+export function prepareModelGeometry(description, scene) {
+  const pending = scene.nodes.slice(), visited = /* alloc */ new Set();
+  const meshes = /* alloc */ new Set(), transfers = /* alloc */ new Set();
+  let index, spec, primitive, attribute, child;
+  while (pending.length) {
+    index = pending.pop();
+    if (visited.has(index)) continue;
+    visited.add(index);
+    spec = description.nodes[index];
+    if (!spec) throw /* alloc */ new Error('Invalid glTF node');
+    if (spec.mesh !== undefined) meshes.add(spec.mesh);
+    for (child of spec.children || geometryEmpty) pending.push(child);
+  }
+  for (index of meshes) {
+    for (primitive of description.meshes[index].primitives) {
+      for (attribute of Object.values(prepareModelPrimitive(description, primitive))) {
+        transfers.add(attribute.data.buffer);
+      }
+    }
+  }
+  return /* alloc */ [...transfers];
+}

package/src/models/prepareModelPrimitive.js

@@ -1,17 +1,25 @@
-import { readModelAttributes } from './readModelAttributes.js';
-import { readModelIndices } from './readModelIndices.js';
-import { vertexNormals } from '../geometry/vertexNormals.js';
-
-export function prepareModelPrimitive(description, primitive) {
-  const { attributes, vertexCount } = readModelAttributes(description, primitive);
-  readModelIndices(description, primitive, attributes, vertexCount);
-  if (!attributes.normal) {
-    attributes.normal = /* alloc */ { size: 3,
-      data: vertexNormals(attributes.position.data, attributes.index?.data) };
-  }
-  if (attributes.index?.data instanceof Uint8Array) {
-    attributes.index.data = Uint16Array.from(attributes.index.data);
-  }
-  primitive.preparedAttributes = attributes;
-  return attributes;
-}
+import { readModelAttributes } from './readModelAttributes.js';
+import { readModelIndices } from './readModelIndices.js';
+import { vertexNormals } from '../geometry/vertexNormals.js';
+
+/**
+ * Decode primitive attributes and indices, generating normals when absent.
+ *
+ * @param {Object} description Decoded glTF document with loaded buffers.
+ * @param {Object} primitive glTF mesh primitive to prepare.
+ *
+ * @returns {Object} Prepared attributes, also stored on the primitive.
+ */
+export function prepareModelPrimitive(description, primitive) {
+  const { attributes, vertexCount } = readModelAttributes(description, primitive);
+  readModelIndices(description, primitive, attributes, vertexCount);
+  if (!attributes.normal) {
+    attributes.normal = /* alloc */ { size: 3,
+      data: vertexNormals(attributes.position.data, attributes.index?.data) };
+  }
+  if (attributes.index?.data instanceof Uint8Array) {
+    attributes.index.data = Uint16Array.from(attributes.index.data);
+  }
+  primitive.preparedAttributes = attributes;
+  return attributes;
+}

package/src/models/readAccessor.js

@@ -1,13 +1,19 @@
 import { types } from '../globals/types.js';
 import { sizes } from '../globals/sizes.js';
-
-
 import { readAccessorValues } from './readAccessorValues.js';
 import { readSparseAccessor } from './readSparseAccessor.js';
 import { normalizeAccessor } from './normalizeAccessor.js';
 
-/** Decode packed, interleaved, normalized or sparse glTF accessor data. */
-
+/**
+ * Decode packed, interleaved, normalized or sparse glTF accessor data.
+ *
+ * @param {Object} description Decoded glTF document with loaded buffers.
+ * @param {number} index Accessor index.
+ *
+ * @returns {Object} Component data and size, plus original integer data when applicable.
+ *
+ * @throws {Error} If the accessor component type, shape or count is invalid.
+ */
 export function readAccessor(description, index) {
   const spec = description.accessors[index], Type = types[spec.componentType], size = sizes[spec.type];
   if (!Type || !size || !Number.isInteger(spec.count) || spec.count < 0) {

package/src/models/readAccessorValue.js

@@ -1,7 +1,16 @@
-export function readAccessorValue(input, Type, at) {
-  return Type === Int8Array ? input.getInt8(at) :
-    Type === Uint8Array ? input.getUint8(at) :
-      Type === Int16Array ? input.getInt16(at, true) :
-        Type === Uint16Array ? input.getUint16(at, true) :
-          Type === Uint32Array ? input.getUint32(at, true) : input.getFloat32(at, true);
-}
+/**
+ * Read one glTF accessor component from a data view using little-endian byte order.
+ *
+ * @param {DataView} input View containing the component.
+ * @param {TypedArrayConstructor} Type Component array constructor.
+ * @param {number} at Byte offset in the view.
+ *
+ * @returns {number} Decoded component.
+ */
+export function readAccessorValue(input, Type, at) {
+  return Type === Int8Array ? input.getInt8(at) :
+    Type === Uint8Array ? input.getUint8(at) :
+      Type === Int16Array ? input.getInt16(at, true) :
+        Type === Uint16Array ? input.getUint16(at, true) :
+          Type === Uint32Array ? input.getUint32(at, true) : input.getFloat32(at, true);
+}

package/src/models/readAccessorValues.js

@@ -1,5 +1,22 @@
 import { readAccessorValue } from './readAccessorValue.js';
 
+/**
+ * Copy packed or strided accessor components into an output array, optionally at sparse indices.
+ *
+ * @param {Object} description Decoded glTF document with loaded buffers.
+ * @param {TypedArrayConstructor} Type Component array constructor.
+ * @param {number} size Components per element.
+ * @param {TypedArray} data Destination array.
+ * @param {number} accessorCount Number of elements in the destination accessor.
+ * @param {TypedArray|null} indices Sparse destination indices, or null for sequential output.
+ * @param {number} viewIndex Index of the source buffer view.
+ * @param {number} offset Byte offset within the buffer view.
+ * @param {number} count Number of source elements.
+ * @param {number} stride Byte stride between source elements, or zero for packed data.
+ *
+ * @throws {Error} If data falls outside the buffer view.
+ * @throws {Error} If a sparse index is invalid.
+ */
 export function readAccessorValues(description, Type, size, data, accessorCount, indices, viewIndex, offset, count, stride) {
   const view = description.bufferViews[viewIndex], bytes = Type.BYTES_PER_ELEMENT;
   const buffer = description.buffers[view.buffer].binary;

package/src/models/readModelAttributes.js

@@ -1,20 +1,32 @@
-import { geometrySemantics } from '../globals/geometrySemantics.js';
-import { readAccessor } from './readAccessor.js';
-
-export function readModelAttributes(description, primitive) {
-  const attributes = /* alloc */ {};
-  let semantic, name;
-  for ([semantic, name] of geometrySemantics) {
-    if (primitive.attributes[semantic] !== undefined) {
-      attributes[name] = readAccessor(description, primitive.attributes[semantic]);
-    }
-  }
-  if (!attributes.position) throw /* alloc */ new Error('glTF mesh has no positions');
-  const vertexCount = attributes.position.data.length / 3;
-  if (attributes.position.size !== 3 || vertexCount < 3) throw /* alloc */ new Error('Invalid glTF vertex attributes');
-  let attribute;
-  for (attribute of Object.values(attributes)) {
-    if (attribute.data.length / attribute.size !== vertexCount) throw /* alloc */ new Error('Invalid glTF vertex attributes');
-  }
-  return /* alloc */ { attributes, vertexCount };
-}
+import { geometrySemantics } from '../globals/geometrySemantics.js';
+import { readAccessor } from './readAccessor.js';
+
+/**
+ * Read supported primitive attributes and validate their vertex counts.
+ *
+ * @param {Object} description Decoded glTF document.
+ * @param {Object} primitive glTF mesh primitive.
+ *
+ * @returns {Object} Attribute map and vertex count.
+ *
+ * @throws {Error} If positions are missing.
+ * @throws {Error} If the position size or vertex count is invalid.
+ * @throws {Error} If attribute vertex counts differ.
+ */
+export function readModelAttributes(description, primitive) {
+  const attributes = /* alloc */ {};
+  let semantic, name;
+  for ([semantic, name] of geometrySemantics) {
+    if (primitive.attributes[semantic] !== undefined) {
+      attributes[name] = readAccessor(description, primitive.attributes[semantic]);
+    }
+  }
+  if (!attributes.position) throw /* alloc */ new Error('glTF mesh has no positions');
+  const vertexCount = attributes.position.data.length / 3;
+  if (attributes.position.size !== 3 || vertexCount < 3) throw /* alloc */ new Error('Invalid glTF vertex attributes');
+  let attribute;
+  for (attribute of Object.values(attributes)) {
+    if (attribute.data.length / attribute.size !== vertexCount) throw /* alloc */ new Error('Invalid glTF vertex attributes');
+  }
+  return /* alloc */ { attributes, vertexCount };
+}