leaflet-city-mapper 0.0.3 → 0.0.5

package/src/materials/prepareMeshCutout.js

@@ -0,0 +1,12 @@
+export function prepareMeshCutout(renderer, mesh, base) {
+  const data = renderer.uniformData;
+  const cutout = (mesh._nativeSource || mesh._rasterSource)?.options.cutout;
+  if (cutout && (!Number.isFinite(cutout.x) || !Number.isFinite(cutout.y) ||
+      !Number.isFinite(cutout.radius) || cutout.radius < 0)) {
+    throw /* alloc */ new Error('cutout requires finite x, y and a non-negative radius in CSS pixels');
+  }
+  data[base + 36] = (cutout?.x ?? 0) * renderer.dpr;
+  data[base + 37] = (cutout?.y ?? 0) * renderer.dpr;
+  data[base + 38] = (cutout?.radius ?? 0) * renderer.dpr;
+  data[base + 39] = cutout?.outside ? 1 : 0;
+}

package/src/materials/terrainRasterProgram.js

@@ -0,0 +1,58 @@
+import { demByLayer } from '../weakmaps/demByLayer.js';
+import { rasterProgramByLayer } from '../weakmaps/rasterProgramByLayer.js';
+import { rendererByLayer } from '../weakmaps/rendererByLayer.js';
+import { terrainBoundsByLayer } from '../weakmaps/terrainBoundsByLayer.js';
+import { terrainGridsByLayer } from '../weakmaps/terrainGridsByLayer.js';
+import { terrainOriginElevationByLayer } from '../weakmaps/terrainOriginElevationByLayer.js';
+import { terrainTilesByLayer } from '../weakmaps/terrainTilesByLayer.js';
+
+import { demTexture } from '../globals/demTexture.js';
+import { demTarget } from '../globals/demTarget.js';
+import { demLayout } from '../globals/demLayout.js';
+import { demSize } from '../globals/demSize.js';
+import { createProgram } from './createProgram.js';
+import { destroyTexture } from '../textures/destroyTexture.js';
+import { terrainAtlas } from '../terrain/terrainAtlas.js';
+
+export function rasterProgram(layer, texture) {
+  const device = rendererByLayer.get(layer).device
+  if (rasterProgramByLayer.get(layer)?.device === device) return rasterProgramByLayer.get(layer);
+  // DEM atlas over the archive's tile grid; invalid or missing samples become -1e9 (the shader's no-data).
+  // ponytail: one texture, capped by maxTextureDimension2D (32x32 DEM tiles at 8192 px); split it for larger archives.
+  const bounds = terrainBoundsByLayer.get(layer), columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
+  const { elevations, low, high } = terrainAtlas(terrainTilesByLayer.get(layer), bounds);
+  if (demByLayer.get(layer)) destroyTexture(layer, demByLayer.get(layer).texture);
+  demByLayer.set(layer, /* alloc */ {
+    texture: device.createTexture((
+      demTexture.size[0] = columns * 256,
+      demTexture.size[1] = rows * 256,
+      demTexture.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+      demTexture
+    )),
+    low: Number.isFinite(low) ? low : terrainOriginElevationByLayer.get(layer),
+    high: Number.isFinite(high) ? high : terrainOriginElevationByLayer.get(layer),
+  });
+  device.queue.writeTexture((
+    demTarget.texture = demByLayer.get(layer).texture,
+    demTarget
+  ), elevations,
+    (
+      demLayout.bytesPerRow = columns * 1024,
+      demLayout
+    ), (
+      demSize[0] = columns * 256,
+      demSize[1] = rows * 256,
+      demSize
+    ));
+  demTarget.texture = null;
+  terrainGridsByLayer.set(layer, /* alloc */ new Map());
+  rasterProgramByLayer.set(layer, createProgram(layer, /* alloc */ {
+    baseTexture: texture,
+    unlit: true,
+    terrain: demByLayer.get(layer),
+    alphaMode: 'BLEND',
+    depthWrite: true,
+    doubleSided: layer.options.doubleSided,
+  }));
+  return rasterProgramByLayer.get(layer);
+}

package/src/materials/validateRoofMaterial.js

@@ -0,0 +1,10 @@
+export function validateRoofMaterial(material) {
+  let name, value;
+  for (name of /* alloc */ ['roofTexture', 'wallTexture']) {
+    value = material[name];
+    if (value !== undefined && typeof value !== 'boolean' &&
+      (!Number.isFinite(value) || value < 0 || value > 1)) {
+      throw /* alloc */ new Error(`${name} must be a boolean or a finite number between 0 and 1`);
+    }
+  }
+}

package/src/models/applyModelTransform.js

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

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 '../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;
+}

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/loadModel.js

@@ -1,69 +1,49 @@
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { modelByLayer } from '../weakmaps/modelByLayer.js';
+import { modelUrlByLayer } from '../weakmaps/modelUrlByLayer.js';
+import { rootByLayer } from '../weakmaps/rootByLayer.js';
+import { terrain3DByMap } from '../weakmaps/terrain3DByMap.js';
+
+
+
 import { decodeModel } from './decodeModel.js';
 import { setParent } from '../scene/setParent.js';
-import { emptyNode } from '../scene/emptyNode.js';
+import { emptyNode } from '../scene/createSceneNode.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;
+export async function loadModel(layer) {
+  await addedByLayer.get(layer).promise;
+  const url = /* alloc */ new URL(modelUrlByLayer.get(layer), 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(layer, description, directory);
+  const context = createModelContext(layer, 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);
+  modelByLayer.set(layer, model);
+  applyModelTransform(layer);
+  setParent(modelByLayer.get(layer), rootByLayer.get(layer));
+  conformModelToTerrain(layer, terrain3DByMap.get(layer._map));
 }

package/src/models/loadModelResources.js

@@ -0,0 +1,20 @@
+import { addedByLayer } from '../weakmaps/addedByLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
+
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+import { loadBuffer } from './loadBuffer.js';
+import { loadImage } from '../textures/loadModelImage.js';
+
+export async function loadModelResources(layer, description, directory) {
+  const bufferRequests = /* alloc */ [];
+  let buffer;
+  for (buffer of description.buffers || geometryEmpty) bufferRequests.push(loadBuffer(buffer, directory));
+  await Promise.all(bufferRequests);
+  await addedByLayer.get(layer).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 cameraViewByMap.get(layer._map);
+  return images;
+}

package/src/models/modelNode.js

@@ -1,93 +1,48 @@
-import { cityMapper } from '../constants/cityMapper.js';
-import { emptyNode } from '../scene/emptyNode.js';
-import { nodeMatrix } from './nodeMatrix.js';
-import { readAccessor } from './readAccessor.js';
+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 { vertexNormals } from '../geometry/vertexNormals.js';
-import { createProgram } from '../rendering/createProgram.js';
+import { readModelAttributes } from './readModelAttributes.js';
+import { readModelIndices } from './readModelIndices.js';
+import { createModelGeometry } from '../geometry/createModelGeometry.js';
 
 export function modelNode(context, index) {
-  const { backend, description, materials, active, resources } = context;
+  const { backend: layer, 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/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);
+}

package/src/models/readAccessorValues.js

@@ -1,16 +1,20 @@
+import { readAccessorValue } from './readAccessorValue.js';
+
 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;
   stride ||= size * bytes;
   if (!buffer || stride < size * bytes || offset < 0 ||
     (view.byteOffset || 0) + view.byteLength > buffer.byteLength ||
-    (count - 1) * stride + size * bytes + offset > view.byteLength) throw new Error('glTF accessor outside buffer view');
-  let i, values, output;
+    (count - 1) * stride + size * bytes + offset > view.byteLength) throw /* alloc */ new Error('glTF accessor outside buffer view');
+  const input = /* alloc */ new DataView(buffer);
+  let i, j, at, output;
   for (i = 0; i < count; i++) {
-    values = new Type(buffer.slice((view.byteOffset || 0) + offset + i * stride,
-      (view.byteOffset || 0) + offset + i * stride + size * bytes));
     output = indices ? indices[i] : i;
-    if (indices && output >= accessorCount) throw new Error('Invalid sparse glTF index');
-    data.set(values, output * size);
+    if (indices && output >= accessorCount) throw /* alloc */ new Error('Invalid sparse glTF index');
+    for (j = 0; j < size; j++) {
+      at = (view.byteOffset || 0) + offset + i * stride + j * bytes;
+      data[output * size + j] = readAccessorValue(input, Type, at);
+    }
   }
 }

package/src/models/readModelAttributes.js

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

package/src/models/readModelIndices.js

@@ -0,0 +1,16 @@
+import { readAccessor } from './readAccessor.js';
+
+export function readModelIndices(description, primitive, attributes, vertexCount) {
+  if (primitive.indices !== undefined) {
+    const index = readAccessor(description, primitive.indices);
+    attributes.index = /* alloc */ { size: 1, data: index.indices };
+    if (!(index.indices instanceof Uint8Array || index.indices instanceof Uint16Array ||
+      index.indices instanceof Uint32Array) || index.size !== 1 || index.indices.length % 3) {
+      throw /* alloc */ new Error('Invalid glTF triangle indices');
+    }
+    let value;
+    for (value of index.indices) if (value >= vertexCount) throw /* alloc */ new Error('Invalid glTF triangle indices');
+  } else if (vertexCount % 3) {
+    throw /* alloc */ new Error('Incomplete glTF triangle');
+  }
+}

package/src/models/readSparseAccessor.js

@@ -0,0 +1,19 @@
+import { types } from '../globals/types.js';
+import { readAccessorValues } from './readAccessorValues.js';
+
+export function readSparseAccessor(description, spec, Type, size, data) {
+  const sparse = spec.sparse, Index = types[sparse.indices.componentType];
+  if (Index !== Uint8Array && Index !== Uint16Array && Index !== Uint32Array) {
+    throw /* alloc */ 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 /* alloc */ new Error('Invalid sparse glTF indices');
+  }
+  const indices = /* alloc */ 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);
+}

package/src/models/releaseModelResources.js

@@ -0,0 +1,10 @@
+export function releaseModelResources(context) {
+  let resource, attribute;
+  for (resource of context.resources) {
+    if (resource.attributes) {
+      for (attribute of Object.values(resource.attributes)) attribute.buffer.destroy();
+    } else {
+      resource.pipelineCache.clear();
+    }
+  }
+}

package/src/{core → native}/beforeNativeRender.js

@@ -5,6 +5,6 @@ export function beforeNativeRender(state) {
     synchronizeNativeLayer(state);
   } catch (error) {
     state.failed = true;
-    state.source.fire('error', { error });
+    state.source.fire('error', /* alloc */ { error });
   }
 }

package/src/native/bypassNativeEvent.js

@@ -0,0 +1,11 @@
+import { updateNativeHover } from './updateNativeHover.js';
+
+export function bypassNativeEvent(map, context, event, type) {
+  const target = event.target;
+  const dom = target instanceof Element &&
+    target.closest('.leaflet-marker-icon,.leaflet-popup,.leaflet-tooltip,.leaflet-control');
+  if (dom && context.hovered && (type === context.move || type === context.out)) {
+    updateNativeHover(map, context, event, null);
+  }
+  return dom || type === context.move && (map.dragging?.moving() || map._animatingZoom);
+}