leaflet-city-mapper 0.0.3 → 0.0.5

package/src/core/markerQuadCorners.js

@@ -1,31 +0,0 @@
-import { localPosition } from './localPosition.js';
-
-export function markerQuadCorners(state, key, image) {
-  const { source, map, backend } = state;
-  const world = new DOMPoint(...localPosition(state, source.getLatLng()), 1)
-    .matrixTransform(new DOMMatrix(backend.root.worldMatrix));
-  const clip = world.matrixTransform(new DOMMatrix(backend.camera.projectionViewMatrix));
-  const inverse = new DOMMatrix(backend.camera.projectionViewMatrix).inverse();
-  const toLocal = new DOMMatrix(backend.root.worldMatrix).inverse();
-  const options = source.options.icon.options, size = map.getSize();
-  const dimensions = options[key === 'shadow' ? 'shadowSize' : 'iconSize'] ||
-    [image.naturalWidth, image.naturalHeight];
-  const width = dimensions.x ?? dimensions[0], height = dimensions.y ?? dimensions[1];
-  const anchor = (key === 'shadow' && options.shadowAnchor) ||
-    options.iconAnchor || [Math.floor(width / 2), Math.floor(height / 2)];
-  const center = new L.Point((clip.x / clip.w + 1) * size.x / 2, (1 - clip.y / clip.w) * size.y / 2);
-  const left = center.x - (anchor.x ?? anchor[0]), top = center.y - (anchor.y ?? anchor[1]);
-  const screenCorners = [[left, top], [left + width, top],
-    [left, top + height], [left + width, top + height]];
-  const corners = [];
-  let pointX, pointY, offset, x, y, p, result;
-  for ([pointX, pointY] of screenCorners) {
-    offset = source._cameraIconPoint(pointX - center.x, pointY - center.y);
-    x = center.x + offset.x, y = center.y + offset.y;
-    p = new DOMPoint(x / size.x * 2 - 1,
-      1 - y / size.y * 2, clip.z / clip.w, 1).matrixTransform(inverse);
-    result = new DOMPoint(p.x / p.w, p.y / p.w, p.z / p.w, 1).matrixTransform(toLocal);
-    corners.push([result.x, result.y, result.z]);
-  }
-  return corners;
-}

package/src/core/nativeImageError.js

@@ -1,8 +0,0 @@
-import { nativeLayerState } from '../constants/nativeLayerState.js';
-
-export function nativeImageError(event) {
-  let state;
-  for (state of nativeLayerState.imageStates.get(event.currentTarget) || []) {
-    state.source.fire('error', { error: new Error('Unable to load native layer image') });
-  }
-}

package/src/core/nativeImageRefresh.js

@@ -1,7 +0,0 @@
-import { nativeLayerState } from '../constants/nativeLayerState.js';
-import { refreshNativeLayer } from './refreshNativeLayer.js';
-
-export function nativeImageRefresh(event) {
-  let state;
-  for (state of nativeLayerState.imageStates.get(event.currentTarget) || []) refreshNativeLayer(state);
-}

package/src/core/nativeLayer.js

@@ -1,97 +0,0 @@
-import { nativeMethodHandlers } from '../constants/nativeMethodHandlers.js';
-import { createMesh } from '../rendering/createMesh.js';
-import { destroyTexture } from '../rendering/destroyTexture.js';
-import { disposeMesh } from '../rendering/disposeMesh.js';
-import { nativeGeometry } from '../geometry/nativeGeometry.js';
-import { nativeEvents } from './nativeEvents.js';
-import { removeNativeEvents } from './removeNativeEvents.js';
-import { parseColor } from '../utils/parseColor.js';
-import { update } from '../scene/update.js';
-import { nativeLayerState } from '../constants/nativeLayerState.js';
-import { current } from './current.js';
-import { refreshNativeLayer } from './refreshNativeLayer.js';
-import { refreshNativeEvent } from './refreshNativeEvent.js';
-import { reorderNativeLayer } from './reorderNativeLayer.js';
-import { nativeSetLatLng } from './nativeSetLatLng.js';
-import { nativeSetLatLngs } from './nativeSetLatLngs.js';
-import { nativeAddLatLng } from './nativeAddLatLng.js';
-import { nativeSetRadius } from './nativeSetRadius.js';
-import { nativeSetStyle } from './nativeSetStyle.js';
-import { nativeRedraw } from './nativeRedraw.js';
-import { nativeSetIcon } from './nativeSetIcon.js';
-import { nativeSetUrl } from './nativeSetUrl.js';
-import { nativeSetBounds } from './nativeSetBounds.js';
-import { nativeSetOpacity } from './nativeSetOpacity.js';
-import { nativeSetZIndex } from './nativeSetZIndex.js';
-import { nativeSetZIndexOffset } from './nativeSetZIndexOffset.js';
-import { nativeBringToFront } from './nativeBringToFront.js';
-import { nativeBringToBack } from './nativeBringToBack.js';
-import { disposeNativeLayer } from './disposeNativeLayer.js';
-import { resolveNativeReady } from './resolveNativeReady.js';
-import { rejectNativeReady } from './rejectNativeReady.js';
-import { forwardNativeError } from './forwardNativeError.js';
-import { updateNativeLayerView } from './updateNativeLayerView.js';
-import { synchronizeNativeLayer } from './synchronizeNativeLayer.js';
-import { beforeNativeRender } from './beforeNativeRender.js';
-
-nativeLayerState.imageStates = new WeakMap();
-nativeLayerState.geometryPixelStates = [];
-
-/** Render from coordinates and detached raster sources; only accessible marker controls remain DOM. */
-export async function nativeLayer(state) {
-  const { source, map } = state;
-  const backend = state.backend = new L.Layer({ source: { type: '3d' } });
-  state.meshes = new Map();
-  state.textures = new Map();
-  state.methods = new Map();
-  state.originalMethods = new Map();
-  state.images = new Set();
-  map._nativeGPUOrder ||= 0;
-  map._nativeGPUBack ||= 0;
-  state.dirty = true;
-  state.viewDirty = true;
-  state.failed = false;
-  state.order = ++map._nativeGPUOrder;
-  state.marker = source instanceof L.Marker;
-  state.paneOrder = Number(getComputedStyle(source.getPane()).zIndex) || 0;
-  state.refresh = refreshNativeLayer;
-  state.reorder = reorderNativeLayer;
-  state.dispose = disposeNativeLayer;
-  const currentEvents = 'load tileload tileunload move drag';
-  source.on(currentEvents, refreshNativeEvent, state);
-  map.on('zoomend', refreshNativeEvent, state);
-  if (state.marker) map.on('move zoom rotate pitch resize viewreset', updateNativeLayerView, state);
-  nativeEvents(state);
-  let name, own, original;
-  for (name of ['setLatLng', 'setLatLngs', 'addLatLng', 'setRadius', 'setStyle', 'redraw',
-    'setIcon', 'setUrl', 'setBounds', 'setOpacity', 'setZIndex', 'setZIndexOffset', 'bringToFront', 'bringToBack']) {
-    if (typeof source[name] !== 'function') continue;
-    own = Object.getOwnPropertyDescriptor(source, name), original = source[name];
-    state.methods.set(name, { own, original });
-    state.originalMethods.set(name, original);
-    source[name] = nativeMethodHandlers[name];
-  }
-  const ready = state.ready = Promise.withResolvers();
-  backend.once('ready', resolveNativeReady, state);
-  backend.once('error', rejectNativeReady, state);
-  backend.on('error', forwardNativeError, state);
-  refreshNativeLayer(state);
-  backend.addTo(map);
-  try {
-    await ready.promise;
-  } catch (error) {
-    disposeNativeLayer.call(state);
-    throw error;
-  }
-  if (!current(state)) return source;
-
-  backend._beforeRender = beforeNativeRender.bind(null, state);
-  try {
-    synchronizeNativeLayer(state);
-  } catch (error) {
-    disposeNativeLayer.call(state);
-    throw error;
-  }
-  update(state.backend);
-  return source;
-}

package/src/core/quadNativeMesh.js

@@ -1,15 +0,0 @@
-import { textureFor } from './textureFor.js';
-import { putNativeMesh } from './putNativeMesh.js';
-
-export function quadNativeMesh(state, key, image, corners, opacity) {
-  const texture = textureFor(state, key, image);
-  if (!texture) return;
-  const indices = [0, 2, 1, 1, 2, 3];
-  const position = [], uv = [], textureCoords = [[0, 0], [1, 0], [0, 1], [1, 1]];
-  let index;
-  for (index of indices) {
-    position.push(...corners[index]);
-    uv.push(...textureCoords[index]);
-  }
-  return putNativeMesh(state, key, position, [1, 1, 1], opacity, texture, uv);
-}

package/src/core/readyNativeGPU.js

@@ -1,6 +0,0 @@
-import { nativeLayer } from './nativeLayer.js';
-
-export function readyNativeGPU(state) {
-  if (state.source._nativeGPU !== state) return state.source;
-  return nativeLayer(state);
-}

package/src/core/refreshNativeLayer.js

@@ -1,29 +0,0 @@
-import { nativeImageRefresh } from './nativeImageRefresh.js';
-import { nativeImageError } from './nativeImageError.js';
-import { removeImageState } from './removeImageState.js';
-import { addImageState } from './addImageState.js';
-import { update } from '../scene/update.js';
-
-export function refreshNativeLayer(state = this) {
-  state.dirty = true;
-  state.viewDirty = true;
-  state.failed = false;
-  state.hide();
-  const activeImages = [state.source._icon, state.source._shadow, state.source._image];
-  let image;
-  for (image of state.images) {
-    if (activeImages.includes(image)) continue;
-    image.removeEventListener('load', nativeImageRefresh);
-    image.removeEventListener('error', nativeImageError);
-    removeImageState(image, state);
-    state.images.delete(image);
-  }
-  for (image of activeImages) {
-    if (!(image instanceof HTMLImageElement) || state.images.has(image)) continue;
-    state.images.add(image);
-    addImageState(image, state);
-    image.addEventListener('load', nativeImageRefresh);
-    image.addEventListener('error', nativeImageError);
-  }
-  if (state.backend._shared) update(state.backend);
-}

package/src/core/refreshNativeLayerContract.js

@@ -1,3 +0,0 @@
-export function refreshNativeLayerContract(layer = this) {
-  layer?._nativeGPU?.refresh?.();
-}

package/src/core/removeImageState.js

@@ -1,8 +0,0 @@
-import { nativeLayerState } from '../constants/nativeLayerState.js';
-
-export function removeImageState(image, state) {
-  const states = nativeLayerState.imageStates.get(image);
-  if (!states) return;
-  states.delete(state);
-  if (!states.size) nativeLayerState.imageStates.delete(image);
-}

package/src/core/removeTargets.js

@@ -1,8 +0,0 @@
-export function removeTargets(state) {
-  if (state.source._nativeGPU === state) state.source._nativeGPU = null;
-  state.dispose?.();
-  let element;
-  for (element of state.hidden) {
-    element.classList.remove('leaflet-webgpu-target');
-  }
-}

package/src/core/reorderNativeLayer.js

@@ -1,6 +0,0 @@
-import { refreshNativeLayer } from './refreshNativeLayer.js';
-
-export function reorderNativeLayer(front) {
-  this.order = front ? ++this.map._nativeGPUOrder : --this.map._nativeGPUBack;
-  refreshNativeLayer(this);
-}

package/src/core/runGridFades.js

@@ -1,14 +0,0 @@
-import { indexState } from '../constants/indexState.js';
-import { updateGridOpacity } from './updateGridOpacity.js';
-
-export function runGridFades() {
-  indexState.gridFadeFrame = null;
-  const layers = [...indexState.pendingGridFades];
-  let layer, version;
-  for ([layer, version] of layers) {
-    if (indexState.pendingGridFades.get(layer) !== version) continue;
-    indexState.pendingGridFades.delete(layer);
-    layer._fadeFrame = null;
-    updateGridOpacity.call(layer);
-  }
-}

package/src/core/runMarkerPanFrame.js

@@ -1,12 +0,0 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
-
-export function runMarkerPanFrame() {
-  mapCameraState.markerPanFrame = null;
-  const pending = [...mapCameraState.pendingMarkerPan];
-  mapCameraState.pendingMarkerPan.clear();
-  let drag, event;
-  for ([drag, event] of pending) {
-    drag._panRequest = null;
-    drag._adjustPan(event);
-  }
-}

package/src/core/scheduleGridFade.js

@@ -1,9 +0,0 @@
-import { indexState } from '../constants/indexState.js';
-import { runGridFades } from './runGridFades.js';
-
-export function scheduleGridFade(layer) {
-  layer._fadeVersion = (layer._fadeVersion || 0) + 1;
-  indexState.pendingGridFades.set(layer, layer._fadeVersion);
-  if (indexState.gridFadeFrame === null) indexState.gridFadeFrame = requestAnimationFrame(runGridFades);
-  layer._fadeFrame = indexState.gridFadeFrame;
-}

package/src/core/scheduleMarkerPan.js

@@ -1,8 +0,0 @@
-import { mapCameraState } from '../constants/mapCameraState.js';
-import { runMarkerPanFrame } from './runMarkerPanFrame.js';
-
-export function scheduleMarkerPan(drag, event) {
-  mapCameraState.pendingMarkerPan.set(drag, event);
-  if (mapCameraState.markerPanFrame === null) mapCameraState.markerPanFrame = requestAnimationFrame(runMarkerPanFrame);
-  drag._panRequest = mapCameraState.markerPanFrame;
-}

package/src/core/syncVectorLayer.js

@@ -1,26 +0,0 @@
-import { nativeLayerState } from '../constants/nativeLayerState.js';
-import { nativeGeometry } from '../geometry/nativeGeometry.js';
-import { localPixelForGeometry } from './localPixelForGeometry.js';
-import { parseColor } from '../utils/parseColor.js';
-import { putNativeMesh } from './putNativeMesh.js';
-
-export function syncVectorLayer(state) {
-  const { source } = state;
-  nativeLayerState.geometryPixelStates.push(state);
-  let geometry;
-  try {
-    geometry = nativeGeometry(source, state.map, localPixelForGeometry);
-  } finally {
-    nativeLayerState.geometryPixelStates.pop();
-  }
-  const { fill, stroke } = geometry;
-  let key, positions, color, opacity, r, g, b;
-  for ([key, positions, color, opacity] of [
-    ['fill', fill, source.options.fillColor || source.options.color, source.options.fillOpacity],
-    ['stroke', stroke, source.options.color, source.options.opacity],
-  ]) {
-    if (!positions.length) continue;
-    ({ r, g, b } = parseColor(color));
-    putNativeMesh(state, key, positions, [r, g, b], opacity ?? 1);
-  }
-}

package/src/core/updateNativeLayerView.js

@@ -1,6 +0,0 @@
-import { update } from '../scene/update.js';
-
-export function updateNativeLayerView() {
-  this.viewDirty = true;
-  if (this.backend._shared) update(this.backend);
-}

package/src/geometry/below.js

@@ -1,3 +0,0 @@
-export function below(p) {
-  return [p[0], p[1] - 1.2, p[2]];
-}

package/src/geometry/bridgeLocal.js

@@ -1,4 +0,0 @@
-export function local([lng, lat, z], crs, origin, metres, base) {
-  const p = crs.project(new L.LatLng(lat, lng));
-  return [(p.x - origin.x) * metres, z - base, -(p.y - origin.y) * metres];
-}

package/src/geometry/cross.js

@@ -1,3 +0,0 @@
-export function cross(a, b) {
-  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
-}

package/src/geometry/dot.js

@@ -1,6 +0,0 @@
-export function dot(a, b) {
-  let sum = 0;
-  let i;
-  for (i = 0; i < a.length; i++) sum += a[i] * b[i];
-  return sum;
-}

package/src/geometry/lampRing.js

@@ -1,11 +0,0 @@
-export function ring(point, radius) {
-  const points = [];
-  let i;
-  for (i = 0; i < 6; i++) {
-    points.push({
-      x: point.x + Math.cos(i * Math.PI / 3) * radius,
-      y: point.y + Math.sin(i * Math.PI / 3) * radius, ground: point.ground, uv: [3, 3],
-    });
-  }
-  return points;
-}

package/src/geometry/push.js

@@ -1,3 +0,0 @@
-export function push(position, normal, color, p, n) {
-  position.push(...p); normal.push(...n); color.push(0.6, 0.58, 0.54);
-}

package/src/geometry/sub.js

@@ -1,6 +0,0 @@
-export function sub(a, b) {
-  const result = [];
-  let i;
-  for (i = 0; i < a.length; i++) result.push(a[i] - b[i]);
-  return result;
-}

package/src/geometry/treeRing.js

@@ -1,14 +0,0 @@
-import { ringDirections } from '../constants/ringDirections.js';
-
-export function ring(point, radius) {
-  const result = [];
-  let direction;
-  for (direction of ringDirections) {
-    result.push({
-      x: point.x + direction.x * radius,
-      y: point.y + direction.y * radius,
-      ground: point.ground,
-    });
-  }
-  return result;
-}

package/src/lighting/visitCells.js

@@ -1,15 +0,0 @@
-export function visitCells(packed, minX, minZ, cellSize, columns, offsets, data) {
-  let values, i, radius, x, z, y, c, key, j, o;
-  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]++;
-      }
-    }
-  }
-}

package/src/models/loadImage.js

@@ -1,15 +0,0 @@
-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 });
-  } 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}`);
-    blob = await response.blob();
-  }
-  // Preserve straight alpha and raw samples; GPU sRGB formats do color decoding.
-  return createImageBitmap(blob, { premultiplyAlpha: 'none', colorSpaceConversion: 'none' });
-}

package/src/models/materialFor.js

@@ -1,21 +0,0 @@
-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),
-    emissiveTexture: textureFor(context, material.emissiveTexture, true),
-    occlusionTexture: textureFor(context, material.occlusionTexture),
-    emissive: material.emissiveFactor || [0, 0, 0],
-    occlusionStrength: material.occlusionTexture?.strength ?? 1,
-    alphaMode: backend.options.alphaMode || material.alphaMode || 'OPAQUE',
-    alphaCutoff: material.alphaCutoff ?? 0.5,
-    doubleSided: material.doubleSided,
-  };
-}

package/src/models/textureSampler.js

@@ -1,10 +0,0 @@
-/** Translate glTF sampler constants into WebGPU sampler options. */
-
-export function textureSampler(sampler) {
-  return {
-    addressModeU: sampler.wrapS === 33071 ? 'clamp-to-edge' : sampler.wrapS === 33648 ? 'mirror-repeat' : 'repeat',
-    addressModeV: sampler.wrapT === 33071 ? 'clamp-to-edge' : sampler.wrapT === 33648 ? 'mirror-repeat' : 'repeat',
-    magFilter: sampler.magFilter === 9728 ? 'nearest' : 'linear',
-    minFilter: sampler.minFilter === 9728 || sampler.minFilter === 9984 || sampler.minFilter === 9986 ? 'nearest' : 'linear',
-  };
-}

package/src/raster/createGeometry.js

@@ -1,22 +0,0 @@
-
-
-export function createGeometry(device) {
-  const attributes = {
-    position: { size: 3, data: new Float32Array([0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1]) },
-    normal: { size: 3, data: new Float32Array([0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0]) },
-    uv: { size: 2, data: new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]) },
-    index: { data: new Uint16Array([0, 2, 1, 1, 2, 3]) },
-  };
-  let name, attribute;
-  for ([name, attribute] of Object.entries(attributes)) {
-    attribute.count = attribute.data.length / (attribute.size || 1);
-    attribute.indexFormat = 'uint16';
-    attribute.buffer = device.createBuffer({
-      size: attribute.data.byteLength,
-      usage: name === 'index' ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
-        : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-    });
-    device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-  }
-  return { device, attributes, drawRange: { start: 0, count: attributes.index.count } };
-}

package/src/raster/finishAttachment.js

@@ -1,11 +0,0 @@
-import { setRasterTerrain } from "./setRasterTerrain.js";
-
-export async function finishAttachment(backend, map, attached) {
-  try {
-    await attached;
-    backend._added.resolve();
-    setRasterTerrain(backend, map._terrain3D);
-  } catch (error) {
-    backend.fire('error', { error });
-  }
-}

package/src/raster/isLoading.js

@@ -1,5 +0,0 @@
-
-
-export function isLoading(layer) {
-  return layer._loadingTiles > 0;
-}

package/src/rendering/composeRoofAtlas.js

@@ -1,52 +0,0 @@
-import { getRasterTileSize } from '../raster/getRasterTileSize.js';
-import { compareRoofTiles } from './compareRoofTiles.js';
-
-export function composeRoofAtlas(backend, tiles, zoom, min, size, width, height) {
-  const renderer = backend.renderer, device = renderer.device, map = backend._map;
-  const opacities = new Float32Array(Math.max(1, tiles.length) * 64);
-  const opacityBuffer = device.createBuffer({
-    size: opacities.byteLength,
-    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-  });
-  const encoder = device.createCommandEncoder();
-  const atlasPass = encoder.beginRenderPass({
-    colorAttachments: [{
-      view: backend._roofRaster.texture.texture.createView(),
-      clearValue: { r: 0, g: 0, b: 0, a: 0 },
-      loadOp: 'clear',
-      storeOp: 'store',
-    }],
-  });
-  atlasPass.setPipeline(renderer.roofBlit.pipeline);
-  tiles.sort(compareRoofTiles);
-  let i, tile, layer, coords, image, source, tileSize, offset, x, y;
-  for ([i, { tile, layer }] of tiles.entries()) {
-    ({ coords, image } = tile);
-    source = tile.texture;
-    if (source.uploaded !== source.image) {
-      device.queue.copyExternalImageToTexture({ source: image }, { texture: source.texture },
-        [source.texture.width, source.texture.height]);
-      source.uploaded = source.image;
-    }
-
-    opacities[i * 64] = layer.options.opacity;
-    tileSize = getRasterTileSize().multiplyBy(map.getZoomScale(zoom, coords.z));
-    offset = new L.Point(coords.x, coords.y).scaleBy(tileSize).subtract(min);
-    x = offset.x * width / size.x, y = offset.y * height / size.y;
-    atlasPass.setViewport(x, y, Math.min(tileSize.x * width / size.x, width - x),
-      Math.min(tileSize.y * height / size.y, height - y), 0, 1);
-    atlasPass.setBindGroup(0, device.createBindGroup({
-      layout: renderer.roofBlit.pipeline.getBindGroupLayout(0),
-      entries: [
-        { binding: 0, resource: source.texture.createView() },
-        { binding: 1, resource: renderer.roofBlit.sampler },
-        { binding: 2, resource: { buffer: opacityBuffer, offset: i * 256, size: 4 } },
-      ],
-    }));
-    atlasPass.draw(4);
-  }
-  atlasPass.end();
-  device.queue.writeBuffer(opacityBuffer, 0, opacities);
-  device.queue.submit([encoder.finish()]);
-  opacityBuffer.destroy();
-}

package/src/rendering/createProgram.js

@@ -1,92 +0,0 @@
-import { materialShaders } from '../shaders/materialShaders.js';
-import { elevationWGSL } from '../constants/elevationWGSL.js';
-import { reportCompilation } from './reportCompilation.js';
-
-
-export function createProgram(backend, material = {}) {
-  const shaders = materialShaders(
-    material,
-    !!backend.options.nightSparkle,
-    material.terrain ? elevationWGSL : ''
-  );
-  const vertex = backend.renderer.device.createShaderModule({ code: shaders.vertex });
-  const fragment = backend.renderer.device.createShaderModule({ code: shaders.fragment });
-  reportCompilation(backend, [
-    vertex.getCompilationInfo(),
-    fragment.getCompilationInfo()
-  ]);
-  const vertexBuffers = [
-    { arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }] },
-    { arrayStride: 12, attributes: [{ shaderLocation: 1, offset: 0, format: 'float32x3' }] },
-    material.vertexColors ? { arrayStride: 12, attributes: [{ shaderLocation: 2, offset: 0, format: 'float32x3' }] } : null,
-    shaders.textured ? { arrayStride: 8, attributes: [{ shaderLocation: 3, offset: 0, format: 'float32x2' }] } : null,
-  ];
-  if (material.instanced) vertexBuffers.push({
-    arrayStride: 16, stepMode: 'instance',
-    attributes: [{ shaderLocation: 4, offset: 0, format: 'float32x4' }],
-  });
-  const bindGroupEntries = [{
-    binding: 0,
-    visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
-    buffer: { type: 'uniform', hasDynamicOffset: true },
-  }, {
-    binding: 1,
-    visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
-    buffer: { type: 'uniform' },
-  }];
-  if (shaders.hasTerrain) {
-    bindGroupEntries.push({
-      binding: 2,
-      visibility: GPUShaderStage.VERTEX,
-      texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
-    });
-  }
-
-  let texture;
-  for (texture of shaders.bindings) {
-    bindGroupEntries.push({
-      binding: texture.texture,
-      visibility: GPUShaderStage.FRAGMENT,
-      texture: { sampleType: 'float', viewDimension: '2d' },
-    });
-    bindGroupEntries.push({
-      binding: texture.sampler,
-      visibility: GPUShaderStage.FRAGMENT,
-      sampler: { type: 'filtering' },
-    });
-  }
-  const bindGroupLayout = backend.renderer.device.createBindGroupLayout({ entries: bindGroupEntries });
-  const pipelineLayout = backend.renderer.device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout, backend.renderer.sunlight.layout] });
-  return {
-    device: backend.renderer.device,
-    vertex,
-    fragment,
-    bindings: shaders.bindings,
-    vertexBuffers,
-    bindGroupLayout,
-    pipelineLayout,
-    pipelineCache: new Map(),
-    cullMode: material.doubleSided ? 'none' : 'back',
-    transparent: material.alphaMode === 'BLEND',
-    depthWrite: material.depthWrite ?? material.alphaMode !== 'BLEND',
-    depthTest: material.depthTest !== false,
-    terrain: material.terrain,
-    nightLight: Boolean(material.nightLight),
-    nightSparkle: !!backend.options.nightSparkle,
-    uniforms: {
-      baseColor: { value: material.color || [1, 1, 1] },
-      metallic: { value: material.metallic ?? 0 },
-      roughness: { value: material.roughness ?? 0.85 },
-      opacity: { value: material.opacity ?? 1 },
-      alphaCutoff: { value: material.alphaCutoff ?? 0.5 },
-      occlusionStrength: { value: material.occlusionStrength ?? 1 },
-      emissive: { value: material.emissive || [0, 0, 0] },
-      ...(material.baseTexture ? { baseTexture: { value: material.baseTexture } } : {}),
-      ...(material.metalTexture ? { metalTexture: { value: material.metalTexture } } : {}),
-      ...(material.emissiveTexture ? { emissiveTexture: { value: material.emissiveTexture } } : {}),
-      ...(material.occlusionTexture ? { occlusionTexture: { value: material.occlusionTexture } } : {}),
-      ...(material.roofTexture ? { roofTexture: { value: null } } : {}),
-    },
-    _layerMaterial: material,
-  };
-}

package/src/rendering/destroyTexture.js

@@ -1,6 +0,0 @@
-
-import { destroyAfterSubmission } from './destroyAfterSubmission.js';
-
-export function destroyTexture(layer, texture) {
-  destroyAfterSubmission(layer, texture, layer.renderer.device.queue.onSubmittedWorkDone());
-}