leaflet-city-mapper 0.0.3 → 0.0.4

package/src/lighting/visitCells.js

@@ -1,15 +1,8 @@
+import { visitLightCells } from './visitLightCells.js';
+
 export function visitCells(packed, minX, minZ, cellSize, columns, offsets, data) {
-  let values, i, radius, x, z, y, c, key, j, o;
+  let values, i;
   for (values of packed) for (i = 0; i < values.length; i += 8) {
-    radius = values[i + 3], x = values[i] - minX, z = values[i + 2] - minZ;
-    for (y = Math.floor((z - radius) / cellSize); y <= Math.floor((z + radius) / cellSize); y++) {
-      for (c = Math.floor((x - radius) / cellSize); c <= Math.floor((x + radius) / cellSize); c++) {
-        key = y * columns + c;
-        if (data) {
-          for (j = 0, o = offsets[key] * 4; j < 8; j++) data[o + j] = values[i + j];
-          offsets[key] += 2;
-        } else offsets[key]++;
-      }
-    }
+    visitLightCells(values, i, minX, minZ, cellSize, columns, offsets, data);
   }
 }

package/src/lighting/visitLightCells.js

@@ -0,0 +1,13 @@
+export function visitLightCells(values, i, minX, minZ, cellSize, columns, offsets, data) {
+  const radius = values[i + 3], x = values[i] - minX, z = values[i + 2] - minZ;
+  let y, c, key;
+  for (y = Math.floor((z - radius) / cellSize); y <= Math.floor((z + radius) / cellSize); y++) {
+    for (c = Math.floor((x - radius) / cellSize); c <= Math.floor((x + radius) / cellSize); c++) {
+      key = y * columns + c;
+      if (data) {
+        writeLightCell(values, i, key, offsets, data);
+      } else offsets[key]++;
+    }
+  }
+}
+import { writeLightCell } from './writeLightCell.js';

package/src/lighting/worldLights.js

@@ -1,7 +1,8 @@
+import { lightScale } from '../globals/lightScale.js';
 
 /** World-space [x, y, z, radius, r, g, b, intensity] for one mesh's point lights. */
 export function worldLights(lights, m) {
-  const values = new Float32Array(lights.length * 8);
+  const values = /* alloc */ new Float32Array(lights.length * 8);
   let i, x, y, z, radius, color, flux, w;
   for (i = 0; i < lights.length; i++) {
     ({
@@ -11,17 +12,14 @@ export function worldLights(lights, m) {
       flux
     } = lights[i]);
     w = m[3] * x + m[7] * y + m[11] * z + m[15];
-    values.set(
-      [
-        (m[0] * x + m[4] * y + m[8] * z + m[12]) / w,
-        (m[1] * x + m[5] * y + m[9] * z + m[13]) / w,
-       (m[2] * x + m[6] * y + m[10] * z + m[14]) / w,
-       radius,
-       ...color,
-       flux / (4 * Math.PI) * 0.03
-      ],
-       i * 8
-    );
+    values[i * 8] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+    values[i * 8 + 1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+    values[i * 8 + 2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+    values[i * 8 + 3] = radius;
+    values[i * 8 + 4] = color[0];
+    values[i * 8 + 5] = color[1];
+    values[i * 8 + 6] = color[2];
+    values[i * 8 + 7] = flux * lightScale;
   }
   return values;
 }

package/src/lighting/writeLightCell.js

@@ -0,0 +1,5 @@
+export function writeLightCell(values, i, key, offsets, data) {
+  let j, o;
+  for (j = 0, o = offsets[key] * 4; j < 8; j++) data[o + j] = values[i + j];
+  offsets[key] += 2;
+}

package/src/models/applyModelTransform.js

@@ -0,0 +1,13 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+export function applyModelTransform(backend) {
+  const model = sceneByLayer.get(backend).model;
+  if (backend.options.rotation) {
+    const [x, y = x, z = x] = backend.options.rotation;
+    model.rotation[0] = x; model.rotation[1] = y; model.rotation[2] = z;
+  }
+  if (backend.options.scale) {
+    const [x, y = x, z = x] = backend.options.scale;
+    model.scale[0] = x; model.scale[1] = y; model.scale[2] = z;
+  }
+}

package/src/models/buildModelNodes.js

@@ -0,0 +1,14 @@
+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;
+}

package/src/models/createModelContext.js

@@ -0,0 +1,15 @@
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+import { materialFor } from './materialFor.js';
+
+export function createModelContext(backend, description, images) {
+  const context = /* alloc */ {
+    backend, 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/createModelGeometry.js

@@ -0,0 +1,40 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { vertexNormals } from '../geometry/vertexNormals.js';
+import { createProgram } from '../rendering/createProgram.js';
+
+export function createModelGeometry(context, primitive, attributes) {
+  let normals;
+  if (!attributes.normal) {
+    normals = vertexNormals(attributes.position.data, attributes.index?.data);
+    attributes.normal = /* alloc */ { size: 3, data: normals };
+  }
+  const style = context.materials[primitive.material] || /* alloc */ {
+    color: /* alloc */ [1, 1, 1], metallic: 1,
+  };
+  if ((style.baseTexture || style.metalTexture || style.emissiveTexture || style.occlusionTexture) && !attributes.uv) {
+    throw /* alloc */ new Error('Textured model mesh requires UV coordinates');
+  }
+  const program = createProgram(context.backend, style);
+  context.resources.push(program);
+  const device = sceneByLayer.get(context.backend).renderer.device;
+  if (attributes.index?.data instanceof Uint8Array) attributes.index.data = Uint16Array.from(attributes.index.data);
+  let name, attribute;
+  for ([name, attribute] of Object.entries(attributes)) {
+    attribute.size ||= 1;
+    attribute.count = attribute.data.length / attribute.size;
+    attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
+    attribute.buffer = device.createBuffer(/* alloc */ {
+      size: Math.max(4, attribute.data.byteLength),
+      usage: name === 'index'
+        ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
+        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
+  }
+  const geometry = /* alloc */ {
+    device, attributes,
+    drawRange: /* alloc */ { start: 0, count: attributes.index?.count || attributes.position.count },
+  };
+  context.resources.push(geometry);
+  return /* alloc */ { device, geometry, program };
+}

package/src/models/decodeModel.js

@@ -1,24 +1,27 @@
+import { geometryDecoder } from '../globals/geometryDecoder.js';
 /** Decode a static glTF JSON document or GLB v2 container. */
 import { hasUnsupportedPrimitives } from './hasUnsupportedPrimitives.js';
 
+
 export function decodeModel(data) {
-  const view = new DataView(data), decoder = new TextDecoder();
+  const view = /* alloc */ new DataView(data);
+  const decoder = geometryDecoder;
   let description;
   let offset, length, type, chunk;
   if (view.getUint32(0, true) === 0x46546c67) {
     // Decode GLB v2 chunks; unknown types are skipped.
     if (view.getUint32(4, true) !== 2 || view.getUint32(8, true) !== data.byteLength) {
-      throw new Error('Invalid GLB header');
+      throw /* alloc */ new Error('Invalid GLB header');
     }
     let binary;
     for (offset = 12; offset < data.byteLength;) {
       if (offset + 8 > data.byteLength) {
-        throw new Error('Truncated GLB chunk');
+        throw /* alloc */ new Error('Truncated GLB chunk');
       }
       length = view.getUint32(offset, true), type = view.getUint32(offset + 4, true);
       offset += 8;
       if (offset + length > data.byteLength) {
-        throw new Error('Truncated GLB data');
+        throw /* alloc */ new Error('Truncated GLB data');
       }
       chunk = data.slice(offset, offset + length);
       if (type === 0x4e4f534a) {
@@ -30,7 +33,7 @@ export function decodeModel(data) {
       offset += length;
     }
     if (!description) {
-      throw new Error('Missing GLB JSON');
+      throw /* alloc */ new Error('Missing GLB JSON');
     }
     if (binary) {
       description.buffers[0].binary = binary;
@@ -39,7 +42,7 @@ export function decodeModel(data) {
     description = JSON.parse(decoder.decode(data));
   }
   if (description.skins?.length || description.animations?.length || description.extensionsRequired?.length || hasUnsupportedPrimitives(description.meshes)) {
-    throw new Error('Layer3D supports static triangle glTF models without required extensions');
+    throw /* alloc */ new Error('Layer3D supports static triangle glTF models without required extensions');
   }
   return description;
 }

package/src/models/loadBuffer.js

@@ -1,6 +1,6 @@
 export async function loadBuffer(buffer, directory) {
   if (buffer.binary) return;
-  const response = await fetch(new URL(buffer.uri, directory).href);
-  if (!response.ok) throw new Error(`Unable to load model buffer: HTTP ${response.status}`);
+  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/loadImage.js

@@ -1,15 +1,19 @@
+import { geometryImageOptions } from '../globals/geometryImageOptions.js';
+
+
 export async function loadImage(description, directory, image) {
   let blob;
   if (image.bufferView !== undefined) {
     const view = description.bufferViews[image.bufferView];
     const buffer = description.buffers[view.buffer].binary;
-    blob = new Blob([buffer.slice(view.byteOffset || 0, (view.byteOffset || 0) + view.byteLength)],
-      { type: image.mimeType });
+    blob = /* alloc */ new Blob(
+      /* alloc */ [buffer.slice(view.byteOffset || 0, (view.byteOffset || 0) + view.byteLength)],
+      /* alloc */ { type: image.mimeType });
   } else {
-    const response = await fetch(new URL(image.uri, directory).href);
-    if (!response.ok) throw new Error(`Unable to load model texture: HTTP ${response.status}`);
+    const response = await fetch(/* alloc */ new URL(image.uri, directory).href);
+    if (!response.ok) throw /* alloc */ new Error(`Unable to load model texture: HTTP ${response.status}`);
     blob = await response.blob();
   }
   // Preserve straight alpha and raw samples; GPU sRGB formats do color decoding.
-  return createImageBitmap(blob, { premultiplyAlpha: 'none', colorSpaceConversion: 'none' });
+  return createImageBitmap(blob, geometryImageOptions);
 }

package/src/models/loadModel.js

@@ -1,69 +1,44 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+
 import { decodeModel } from './decodeModel.js';
 import { setParent } from '../scene/setParent.js';
 import { emptyNode } from '../scene/emptyNode.js';
 import { conformModelToTerrain } from '../geometry/conformModelToTerrain.js';
-import { loadBuffer } from './loadBuffer.js';
-import { loadImage } from './loadImage.js';
-import { materialFor } from './materialFor.js';
-import { modelNode } from './modelNode.js';
+import { loadModelResources } from './loadModelResources.js';
+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. */
 
 export async function loadModel(backend) {
-  await backend._added.promise;
-  const url = new URL(backend.modelUrl, document.baseURI).href;
+  await sceneByLayer.get(backend)._added.promise;
+  const url = /* alloc */ new URL(sceneByLayer.get(backend).modelUrl, document.baseURI).href;
   const response = await fetch(url);
   if (!response.ok) {
-    throw new Error(`Unable to load model: HTTP ${response.status}`);
+    throw /* alloc */ new Error(`Unable to load model: HTTP ${response.status}`);
   }
   const data = await response.arrayBuffer();
   const description = decodeModel(data);
-  const directory = new URL('.', url).href;
-  const bufferRequests = [];
-  let buffer, image, material, index, resource, attribute, node;
-  for (buffer of description.buffers || []) bufferRequests.push(loadBuffer(buffer, directory));
-  await Promise.all(bufferRequests);
-  await backend._added.promise;
-  const imageRequests = [];
-  for (image of description.images || []) imageRequests.push(loadImage(description, directory, image));
-  const images = await Promise.all(imageRequests);
-  await backend._map?._terrain3D?._terrainPromise;
-  const context = { backend, description, images, textures: new Map(), materials: [], active: new Set(), resources: [] };
-  // Convert glTF materials directly to the shader's retained CPU styles.
-  for (material of description.materials || []) context.materials.push(materialFor(context, material));
+  const directory = /* alloc */ new URL('.', url).href;
+  const images = await loadModelResources(backend, description, directory);
+  const context = createModelContext(backend, description, images);
   const scene = description.scenes?.[description.scene || 0];
-  if (!scene) throw new Error('Missing glTF scene');
-  const nodes = [];
-  try {
-    for (index of scene.nodes) nodes.push(modelNode(context, index));
-  } catch (error) {
-    // Parsing can fail after earlier primitives allocated buffers/programs.
-    for (resource of context.resources) {
-      if (resource.attributes) {
-        for (attribute of Object.values(resource.attributes)) attribute.buffer.destroy();
-      } else {
-        resource.pipelineCache.clear();
-      }
-    }
-    throw error;
-  }
-  const model = {
+  if (!scene) throw /* alloc */ new Error('Missing glTF scene');
+  const nodes = buildModelNodes(context, scene);
+  const model = /* alloc */ {
     ...emptyNode(),
     id: url,
-    extras: description.extras || {},
+    extras: description.extras || /* alloc */ {},
   };
-  if (!nodes.length) throw new Error('Expected a glTF model with a non-empty scene');
+  if (!nodes.length) throw /* alloc */ new Error('Expected a glTF model with a non-empty scene');
+  let node;
   for (node of nodes) setParent(node, model);
-  backend.model = model;
-  if (backend.options.rotation) {
-    const [x, y = x, z = x] = backend.options.rotation;
-    backend.model.rotation[0] = x; backend.model.rotation[1] = y; backend.model.rotation[2] = z;
-  }
-  if (backend.options.scale) {
-    const [x, y = x, z = x] = backend.options.scale;
-    backend.model.scale[0] = x; backend.model.scale[1] = y; backend.model.scale[2] = z;
-  }
-  setParent(backend.model, backend.root);
-  conformModelToTerrain(backend, backend._map?._terrain3D);
+  sceneByLayer.get(backend).model = model;
+  applyModelTransform(backend);
+  setParent(sceneByLayer.get(backend).model, sceneByLayer.get(backend).root);
+  conformModelToTerrain(backend, cameraByMap.get(backend._map)?._terrain3D);
 }

package/src/models/loadModelResources.js

@@ -0,0 +1,19 @@
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+import { cameraByMap } from '../globals/cameraByMap.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { loadBuffer } from './loadBuffer.js';
+import { loadImage } from './loadImage.js';
+
+export async function loadModelResources(backend, description, directory) {
+  const bufferRequests = /* alloc */ [];
+  let buffer;
+  for (buffer of description.buffers || geometryEmpty) bufferRequests.push(loadBuffer(buffer, directory));
+  await Promise.all(bufferRequests);
+  await sceneByLayer.get(backend)._added.promise;
+  const imageRequests = /* alloc */ [];
+  let image;
+  for (image of description.images || geometryEmpty) imageRequests.push(loadImage(description, directory, image));
+  const images = await Promise.all(imageRequests);
+  await sceneByLayer.get(cameraByMap.get(backend._map)?._terrain3D)?._terrainPromise;
+  return images;
+}

package/src/models/materialFor.js

@@ -2,17 +2,17 @@ import { textureFor } from './textureFor.js';
 
 export function materialFor(context, material) {
   const { backend } = context;
-  const pbr = material.pbrMetallicRoughness || {};
-  return {
-    color: (pbr.baseColorFactor || [1, 1, 1, 1]).slice(0, 3),
-    opacity: pbr.baseColorFactor?.[3] ?? 1,
-    metallic: pbr.metallicFactor ?? 1,
-    roughness: pbr.roughnessFactor ?? 1,
-    baseTexture: textureFor(context, pbr.baseColorTexture, true),
-    metalTexture: textureFor(context, pbr.metallicRoughnessTexture),
+  const pbr = material.pbrMetallicRoughness;
+  return /* alloc */ {
+    color: pbr?.baseColorFactor ? pbr.baseColorFactor.slice(0, 3) : /* alloc */ [1, 1, 1],
+    opacity: pbr?.baseColorFactor?.[3] ?? 1,
+    metallic: pbr?.metallicFactor ?? 1,
+    roughness: pbr?.roughnessFactor ?? 1,
+    baseTexture: textureFor(context, pbr?.baseColorTexture, true),
+    metalTexture: textureFor(context, pbr?.metallicRoughnessTexture),
     emissiveTexture: textureFor(context, material.emissiveTexture, true),
     occlusionTexture: textureFor(context, material.occlusionTexture),
-    emissive: material.emissiveFactor || [0, 0, 0],
+    emissive: material.emissiveFactor || /* alloc */ [0, 0, 0],
     occlusionStrength: material.occlusionTexture?.strength ?? 1,
     alphaMode: backend.options.alphaMode || material.alphaMode || 'OPAQUE',
     alphaCutoff: material.alphaCutoff ?? 0.5,

package/src/models/modelNode.js

@@ -1,93 +1,49 @@
-import { cityMapper } from '../constants/cityMapper.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { nextId } from '../globals/nextId.js';
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+
 import { emptyNode } from '../scene/emptyNode.js';
 import { nodeMatrix } from './nodeMatrix.js';
-import { readAccessor } from './readAccessor.js';
 import { setParent } from '../scene/setParent.js';
-import { vertexNormals } from '../geometry/vertexNormals.js';
-import { createProgram } from '../rendering/createProgram.js';
+import { readModelAttributes } from './readModelAttributes.js';
+import { readModelIndices } from './readModelIndices.js';
+import { createModelGeometry } from './createModelGeometry.js';
 
 export function modelNode(context, index) {
-  const { backend, description, materials, active, resources } = context;
+  const { backend, description, active } = context;
   // Track only the recursion path: shared mesh references are valid, cycles are not.
-  if (active.has(index)) throw new Error('Cyclic glTF nodes');
+  if (active.has(index)) throw /* alloc */ new Error('Cyclic glTF nodes');
   const spec = description.nodes[index];
-  if (!spec) throw new Error('Invalid glTF node');
+  if (!spec) throw /* alloc */ new Error('Invalid glTF node');
   active.add(index);
-  const group = {
+  const group = /* alloc */ {
     ...emptyNode(),
     name: spec.name
   };
   group.matrix = nodeMatrix(spec);
-  let primitive, attributes, semantic, name, vertexCount, attribute, index2, i, normals, style, program;
-  let device, geometry, mesh, child;
+  let primitive, attributeData, attributes, vertexCount, built, mesh, child;
   if (spec.mesh !== undefined) {
     for (primitive of description.meshes[spec.mesh].primitives) {
-      attributes = {};
-      for ([semantic, name] of [['POSITION', 'position'], ['NORMAL', 'normal'], ['TEXCOORD_0', 'uv']]) {
-        if (primitive.attributes[semantic] !== undefined) attributes[name] = readAccessor(description, primitive.attributes[semantic]);
-      }
-      if (!attributes.position) throw new Error('glTF mesh has no positions');
-      vertexCount = attributes.position.data.length / 3;
-      if (attributes.position.size !== 3 || vertexCount < 3) throw new Error('Invalid glTF vertex attributes');
-      for (attribute of Object.values(attributes)) {
-        if (attribute.data.length / attribute.size !== vertexCount) throw new Error('Invalid glTF vertex attributes');
-      }
-      if (primitive.indices !== undefined) {
-        index2 = readAccessor(description, primitive.indices);
-        attributes.index = { size: 1, data: index2.indices };
-        if (!(index2.indices instanceof Uint8Array || index2.indices instanceof Uint16Array || index2.indices instanceof Uint32Array) ||
-          index2.size !== 1 || index2.indices.length % 3) throw new Error('Invalid glTF triangle indices');
-        for (i of index2.indices) {
-          if (i >= vertexCount) throw new Error('Invalid glTF triangle indices');
-        }
-      }
-      if (!attributes.index && vertexCount % 3) throw new Error('Incomplete glTF triangle');
-      if (!attributes.normal) {
-        normals = vertexNormals(attributes.position.data, attributes.index?.data);
-        attributes.normal = { size: 3, data: normals };
-      }
-      style = materials[primitive.material] || { color: [1, 1, 1], metallic: 1 };
-      if ((style.baseTexture || style.metalTexture || style.emissiveTexture || style.occlusionTexture) && !attributes.uv) {
-        throw new Error('Textured model mesh requires UV coordinates');
-      }
-      program = createProgram(backend, style);
-      resources.push(program);
-      device = backend.renderer.device;
-      if (attributes.index?.data instanceof Uint8Array) {
-        attributes.index.data = Uint16Array.from(attributes.index.data);
-      }
-      for ([name, attribute] of Object.entries(attributes)) {
-        attribute.size ||= 1;
-        attribute.count = attribute.data.length / attribute.size;
-        attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
-        attribute.buffer = device.createBuffer({
-          size: Math.max(4, attribute.data.byteLength),
-          usage: name === 'index'
-            ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
-            : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-        });
-        device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-      }
-      geometry = {
-        device,
-        attributes,
-        drawRange: { start: 0, count: attributes.index?.count || attributes.position.count },
-      };
-      resources.push(geometry);
-      mesh = {
+      attributeData = readModelAttributes(description, primitive);
+      attributes = attributeData.attributes;
+      vertexCount = attributeData.vertexCount;
+      readModelIndices(description, primitive, attributes, vertexCount);
+      built = createModelGeometry(context, primitive, attributes);
+      mesh = /* alloc */ {
         ...emptyNode(),
-        device,
-        geometry,
-        program,
+        device: built.device,
+        geometry: built.geometry,
+        program: built.program,
         fadeDuration: 250,
-        id: cityMapper.nextId++,
+        id: nextId.value++,
         renderOrder: 0
       };
-      mesh.name = description.meshes[spec.mesh].name; mesh.extras = spec.extras || {};
+      mesh.name = description.meshes[spec.mesh].name;
+      mesh.extras = spec.extras || /* alloc */ {};
       setParent(mesh, group);
     }
   }
-  for (child of spec.children || []) setParent(modelNode(context, child), group);
+  for (child of spec.children || geometryEmpty) setParent(modelNode(context, child), group);
   active.delete(index);
   return group;
 }

package/src/models/nodeMatrix.js

@@ -1,10 +1,15 @@
+import { geometryQuaternion } from '../globals/geometryQuaternion.js';
+import { geometryScale } from '../globals/geometryScale.js';
+import { geometryTranslation } from '../globals/geometryTranslation.js';
 /** glTF quaternion/translation/scale to a column-major matrix. */
 
+
 export function nodeMatrix(spec) {
   if (spec.matrix) return Array.from(spec.matrix);
   // glTF stores quaternions [x,y,z,w]; convert directly to a scaled column-major matrix.
-  const [x, y, z, w] = spec.rotation || [0, 0, 0, 1], [sx, sy, sz] = spec.scale || [1, 1, 1];
-  return [
+  const [x, y, z, w] = spec.rotation || geometryQuaternion;
+  const [sx, sy, sz] = spec.scale || geometryScale;
+  return /* alloc */ [
     (1 - 2 * (y * y + z * z)) * sx,
     2 * (x * y + z * w) * sx,
     2 * (x * z - y * w) * sx,
@@ -16,7 +21,7 @@ export function nodeMatrix(spec) {
     2 * (y * z - x * w) * sz,
     (1 - 2 * (x * x + y * y)) * sz,
     0,
-    ...(spec.translation || [0, 0, 0]),
+    ...(spec.translation || geometryTranslation),
     1,
   ];
 }

package/src/models/normalizeAccessor.js

@@ -0,0 +1,11 @@
+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/readAccessor.js

@@ -1,15 +1,19 @@
-import { types } from "../constants/accessorTypes.js";
-import { sizes } from "../constants/accessorSizes.js";
+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. */
 
 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) {
-    throw new Error('Invalid glTF accessor');
+    throw /* alloc */ new Error('Invalid glTF accessor');
   }
-  const data = new Type(spec.count * size);
+  const data = /* alloc */ new Type(spec.count * size);
   if (spec.bufferView !== undefined) {
     readAccessorValues(
       description, Type, size, data, spec.count, null,
@@ -20,34 +24,10 @@ export function readAccessor(description, index) {
     );
   }
   if (spec.sparse) {
-    const sparse = spec.sparse, Index = types[sparse.indices.componentType];
-    if (![Uint8Array, Uint16Array, Uint32Array].includes(Index)) {
-      throw new Error('Invalid sparse glTF indices');
-    }
-    const view = description.bufferViews[sparse.indices.bufferView];
-    const offset = (view.byteOffset || 0) + (sparse.indices.byteOffset || 0);
-    if (sparse.count > spec.count || (sparse.indices.byteOffset || 0) + sparse.count * Index.BYTES_PER_ELEMENT > view.byteLength) {
-      throw new Error('Invalid sparse glTF indices');
-    }
-    const indices = new Index(description.buffers[view.buffer].binary.slice(offset, offset + sparse.count * Index.BYTES_PER_ELEMENT));
-    readAccessorValues(
-      description, Type, size, data, spec.count, indices,
-      sparse.values.bufferView,
-      sparse.values.byteOffset || 0,
-      sparse.count,
-      0
-    );
+    readSparseAccessor(description, spec, Type, size, data);
   }
   if (spec.componentType === 5126) {
-    return { data, size };
-  }
-  const normalized = new Float32Array(data.length);
-  // Normalization is a glTF accessor rule, not sRGB conversion; indices stay integers.
-  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, size };
   }
-  return { data: normalized, size, indices: data };
+  return normalizeAccessor(spec, Type, data, size);
 }

package/src/models/readAccessorValue.js

@@ -0,0 +1,7 @@
+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);
+}