leaflet-city-mapper 0.0.2 → 0.0.4

package/src/geometry/nativeGeometry.js

@@ -0,0 +1,21 @@
+import { L } from '../globals/L.js';
+import { visit } from './visit.js';
+import { dashValues } from './dashValues.js';
+import { circleGeometry } from './circleGeometry.js';
+
+/** Leaflet paths become flat triangles; pixel-sized strokes are rebuilt on zoom. */
+export function nativeGeometry(source, map, point) {
+  const fill = /* alloc */ [];
+  const stroke = /* alloc */ [];
+  const options = source.options;
+  const width = Number(options.weight) || 0;
+  const dash = dashValues(options);
+  const context = /* alloc */ { fill, stroke, options, width, dash, point, map };
+  if (source instanceof L.CircleMarker) {
+    circleGeometry(source, context);
+  } else {
+    const closed = source instanceof L.Polygon;
+    visit(context, source.getLatLngs(), closed);
+  }
+  return /* alloc */ { fill, stroke };
+}

package/src/geometry/nativeTriangle.js

@@ -0,0 +1,3 @@
+export function triangle(point, target, a, b, c) {
+  return target.push(...point(a), ...point(b), ...point(c));
+}

package/src/geometry/polygon.js

@@ -0,0 +1,23 @@
+import { triangle } from './nativeTriangle.js';
+import { line } from './line.js';
+import { triangulate } from '../triangulation/triangulate.js';
+
+export function polygon(context, rings, closed) {
+  const { options, fill, point, map } = context;
+  const projected = /* alloc */ [];
+  let ring, path, latlng, indices;
+  for (ring of rings) {
+    path = /* alloc */ [];
+    for (latlng of ring) path.push(map.project(latlng));
+    projected.push(path);
+  }
+  if (closed && options.fill && projected[0]?.length >= 3) {
+    const valid = /* alloc */ [];
+    for (ring of projected) if (ring.length >= 3) valid.push(ring);
+    const vertices = valid.flat();
+    for (indices of triangulate(valid[0], valid.slice(1))) {
+      triangle(point, fill, vertices[indices[0]], vertices[indices[1]], vertices[indices[2]]);
+    }
+  }
+  for (ring of projected) line(context, ring, closed);
+}

package/src/geometry/push.js

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

@@ -0,0 +1,9 @@
+export function quad(addTriangle, color, a, b, c, d, height, nx, ny, nz) {
+  if (typeof nx !== 'number') {
+    addTriangle(a, height, b, height, c, height, ...nx, color);
+    addTriangle(a, height, c, height, d, height, ...nx, color);
+  } else {
+    addTriangle(a, height, b, height, c, height, nx, ny, nz, color);
+    addTriangle(a, height, c, height, d, height, nx, ny, nz, color);
+  }
+}

package/src/geometry/roofCoverage.js

@@ -0,0 +1,23 @@
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+import { roofFootprint } from './roofFootprint.js';
+import { subtractRoofTile } from './subtractRoofTile.js';
+
+/** Test the mesh's ground footprint against loaded imagery, including coarse parent tiles. */
+export function roofCoverage(mesh, backend, rasters) {
+  let intersectsArchive = false, pending = false;
+  let layer, footprint, remaining, tile;
+  for (layer of rasters) {
+    if (!sceneByLayer.get(layer).header) { pending = true; continue; }
+    footprint = roofFootprint(mesh, backend, layer);
+    if (!footprint) continue;
+    intersectsArchive = true;
+    remaining = /* alloc */ [footprint];
+    for (tile of sceneByLayer.get(layer)._rasterTiles.values()) {
+      // Failed imagery already reports an error; do not hide the building indefinitely.
+      if (!tile.done && !tile.error) continue;
+      remaining = subtractRoofTile(remaining, tile, sceneByLayer.get(layer)._tileZoom);
+      if (!remaining.length) return true;
+    }
+  }
+  return !intersectsArchive && !pending;
+}

package/src/geometry/roofFootprint.js

@@ -0,0 +1,29 @@
+import { radians } from '../globals/radians.js';
+import { earthCirc } from '../globals/earthCirc.js';
+import { sceneByLayer } from '../globals/sceneByLayer.js';
+
+export function roofFootprint(mesh, backend, layer) {
+  const map = backend._map, bounds = mesh.geometry.bounds, world = mesh.worldMatrix;
+  const state = sceneByLayer.get(layer), zoom = state._tileZoom;
+  const origin = map.project(sceneByLayer.get(backend)._sceneOrigin, zoom);
+  const scale = map.options.crs.scale(zoom) / (earthCirc * Math.cos(sceneByLayer.get(backend)._sceneOrigin.lat * radians));
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  let i, x, y, z, px, py, nw, se;
+  for (i = 0; i < 8; i++) {
+    x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];
+    z = i & 4 ? bounds.max[2] : bounds.min[2];
+    px = origin.x + (world[0] * x + world[4] * y + world[8] * z + world[12]) * scale;
+    py = origin.y + (world[2] * x + world[6] * y + world[10] * z + world[14]) * scale;
+    minX = Math.min(minX, px); minY = Math.min(minY, py);
+    maxX = Math.max(maxX, px); maxY = Math.max(maxY, py);
+  }
+  if (state.header.maxLat !== undefined && state.header.minLon !== undefined &&
+    state.header.minLat !== undefined && state.header.maxLon !== undefined) {
+    nw = map.project(/* alloc */ [state.header.maxLat, state.header.minLon], zoom);
+    se = map.project(/* alloc */ [state.header.minLat, state.header.maxLon], zoom);
+    minX = Math.max(minX, nw.x); minY = Math.max(minY, nw.y);
+    maxX = Math.min(maxX, se.x); maxY = Math.min(maxY, se.y);
+    if (minX >= maxX || minY >= maxY) return null;
+  }
+  return /* alloc */ [minX, minY, maxX, maxY];
+}

package/src/geometry/samePoint.js

@@ -0,0 +1,3 @@
+export function samePoint(a, b) {
+  return Math.abs(a[0] - b[0]) < 1e-10 && Math.abs(a[1] - b[1]) < 1e-10;
+}

package/src/geometry/segment.js

@@ -0,0 +1,22 @@
+import { L } from '../globals/L.js';
+import { triangle } from './nativeTriangle.js';
+import { disk } from './disk.js';
+
+export function segment(context, a, b, startCap, endCap) {
+  const { options, width, stroke, point } = context;
+  const radius = width / 2;
+  const length = a.distanceTo(b);
+  if (!length) return;
+  const direction = b.subtract(a).divideBy(length);
+  const normal = /* alloc */ new L.Point(-direction.y * radius, direction.x * radius);
+  if (options.lineCap === 'square') {
+    if (startCap) a = a.subtract(direction.multiplyBy(radius));
+    if (endCap) b = b.add(direction.multiplyBy(radius));
+  }
+  triangle(point, stroke, a.add(normal), a.subtract(normal), b.add(normal));
+  triangle(point, stroke, b.add(normal), a.subtract(normal), b.subtract(normal));
+  if (options.lineCap === 'round') {
+    if (startCap) disk(point, a, radius, stroke);
+    if (endCap) disk(point, b, radius, stroke);
+  }
+}

package/src/geometry/setVertexColor.js

@@ -0,0 +1,17 @@
+/**
+ * Paints the vertices `[start, end)` of a mesh and marks its color buffer dirty.
+ * @param {Object} mesh Layer-created mesh with a color attribute.
+ * @param {number} start Inclusive vertex index, not an offset into the RGB array.
+ * @param {number} end Exclusive vertex index.
+ * @param {Object} color sRGB {r,g,b}, typically from parseColor().
+ */
+
+export function setVertexColor(mesh, start, end, color) {
+  const rgb = /* alloc */ [];
+  let i;
+  for (i = start; i < end; i++) {
+    rgb[0] = color.r; rgb[1] = color.g; rgb[2] = color.b;
+    mesh.geometry.attributes.color.data.set(rgb, i * 3);
+  }
+  mesh.geometry.attributes.color.needsUpdate = true;
+}

package/src/geometry/sub.js

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

package/src/geometry/subtractRoofTile.js

@@ -0,0 +1,19 @@
+export function subtractRoofTile(remaining, tile, zoom) {
+  const size = 256 * 2 ** (zoom - tile.coords.z);
+  const left = tile.coords.x * size, top = tile.coords.y * size;
+  const pieces = /* alloc */ [];
+  let x0, y0, x1, y1, l, t, r, b;
+  for ([x0, y0, x1, y1] of remaining) {
+    l = Math.max(x0, left), t = Math.max(y0, top);
+    r = Math.min(x1, left + size), b = Math.min(y1, top + size);
+    if (l >= r || t >= b) {
+      pieces.push(/* alloc */ [x0, y0, x1, y1]);
+      continue;
+    }
+    if (y0 < t) pieces.push(/* alloc */ [x0, y0, x1, t]);
+    if (b < y1) pieces.push(/* alloc */ [x0, b, x1, y1]);
+    if (x0 < l) pieces.push(/* alloc */ [x0, t, l, b]);
+    if (r < x1) pieces.push(/* alloc */ [r, t, x1, b]);
+  }
+  return pieces;
+}

package/src/geometry/surface.js

@@ -0,0 +1,18 @@
+import { ringDirections } from '../globals/ringDirections.js';
+
+import { ring } from './treeRing.js';
+
+export function surface(point, addTriangle, lowRadius, low, highRadius, high, color) {
+  const lower = ring(point, lowRadius), upper = ring(point, highRadius);
+  let i, next, slope, length, nx, nz, ny, normalX, normalZ;
+  for (i = 0; i < 8; i++) {
+    next = (i + 1) % 8;
+    slope = (lowRadius - highRadius) / (high - low);
+    length = Math.hypot(1, slope);
+    ({ nx, nz } = ringDirections[i]);
+    ny = slope / length;
+    normalX = nx / length, normalZ = nz / length;
+    if (lowRadius) addTriangle(lower[i], low, lower[next], low, upper[next], high, normalX, ny, normalZ, color);
+    if (highRadius) addTriangle(lower[i], low, upper[next], high, upper[i], high, normalX, ny, normalZ, color);
+  }
+}

package/src/geometry/treeGeometry.js

@@ -0,0 +1,30 @@
+import { roundProfile } from '../globals/roundProfile.js';
+
+
+import { parseColor } from "../utils/parseColor.js";
+import { ring } from './treeRing.js';
+import { surface } from './surface.js';
+import { validateTree } from './validateTree.js';
+
+/** Low-poly tree, sharing the source block's buffers, picking and terrain offset. */
+
+export function treeGeometry(point, style, addTriangle) {
+  const { top, bottom = 0, trunkRadius, crownRadius, crownBottom, crownShape = 'round' } = style;
+  validateTree(trunkRadius, crownRadius, crownBottom, bottom, top, crownShape);
+  const trunk = parseColor(style.trunkColor ?? 0x72513a);
+  const crown = parseColor(style.color ?? 0x4f823b);
+  surface(point, addTriangle, trunkRadius, bottom, trunkRadius, crownBottom + (top - crownBottom) * 0.25, trunk);
+  let i, low, lr, high, hr;
+  if (crownShape === 'cone') {
+    const base = ring(point, crownRadius);
+    for (i = 0; i < 8; i++) addTriangle(point, crownBottom, base[i], crownBottom,
+      base[(i + 1) % 8], crownBottom, 0, -1, 0, crown);
+    surface(point, addTriangle, crownRadius, crownBottom, 0, top, crown);
+  } else {
+    for (i = 1; i < roundProfile.length; i++) {
+      [low, lr] = roundProfile[i - 1], [high, hr] = roundProfile[i];
+      surface(point, addTriangle, lr * crownRadius, crownBottom + low * (top - crownBottom),
+        hr * crownRadius, crownBottom + high * (top - crownBottom), crown);
+    }
+  }
+}

package/src/geometry/treeRing.js

@@ -0,0 +1,15 @@
+import { ringDirections } from '../globals/ringDirections.js';
+
+
+export function ring(point, radius) {
+  const result = /* alloc */ new Array(ringDirections.length);
+  let i;
+  for (i = 0; i < result.length; i++) {
+    result[i] = /* alloc */ {
+      x: point.x + ringDirections[i].x * radius,
+      y: point.y + ringDirections[i].y * radius,
+      ground: point.ground,
+    };
+  }
+  return result;
+}

package/src/geometry/triangle.js

@@ -0,0 +1,13 @@
+export function triangle(position, normal, color, a, b, c, tint) {
+  const ux = b[0] - a[0], uy = b[1] - a[1], uz = b[2] - a[2];
+  const vx = c[0] - a[0], vy = c[1] - a[1], vz = c[2] - a[2];
+  const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+  const length = Math.hypot(nx, ny, nz);
+  let i, point;
+  for (i = 0; i < 3; i++) {
+    point = i === 0 ? a : i === 1 ? b : c;
+    position.push(...point);
+    normal.push(nx / length, ny / length, nz / length);
+    color.push(...tint);
+  }
+}

package/src/geometry/validateTree.js

@@ -0,0 +1,7 @@
+export function validateTree(trunkRadius, crownRadius, crownBottom, bottom, top, crownShape) {
+  if (!Number.isFinite(trunkRadius) || !Number.isFinite(crownRadius) || !Number.isFinite(crownBottom) ||
+    trunkRadius <= 0 || crownRadius < trunkRadius || crownBottom <= bottom || crownBottom >= top ||
+    crownShape !== 'round' && crownShape !== 'cone') {
+    throw /* alloc */ new Error('Invalid tree dimensions or crown shape');
+  }
+}

package/src/geometry/vertexNormals.js

@@ -0,0 +1,26 @@
+/** Area-weighted vertex normals, for indexed or non-indexed triangles. */
+
+export function vertexNormals(p, indices) {
+  // Accumulate area-weighted face normals for shared vertices, then normalize.
+  const normals = /* alloc */ new Float32Array(p.length);
+  let i, a, b, c, ux, uy, uz, vx, vy, vz, j, nx, ny, nz, index, length;
+  for (i = 0; i < (indices?.length || p.length / 3); i += 3) {
+    a = indices ? indices[i] : i, b = indices ? indices[i + 1] : i + 1, c = indices ? indices[i + 2] : i + 2;
+    ux = p[b * 3] - p[a * 3], uy = p[b * 3 + 1] - p[a * 3 + 1], uz = p[b * 3 + 2] - p[a * 3 + 2];
+    vx = p[c * 3] - p[a * 3], vy = p[c * 3 + 1] - p[a * 3 + 1], vz = p[c * 3 + 2] - p[a * 3 + 2];
+    nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+    for (j = 0; j < 3; j++) {
+      index = j === 0 ? a : j === 1 ? b : c;
+      normals[index * 3] += nx;
+      normals[index * 3 + 1] += ny;
+      normals[index * 3 + 2] += nz;
+    }
+  }
+  for (i = 0; i < normals.length; i += 3) {
+    length = Math.hypot(normals[i], normals[i + 1], normals[i + 2]) || 1;
+    for (j = 0; j < 3; j++) {
+      normals[i + j] /= length;
+    }
+  }
+  return normals;
+}

package/src/geometry/visit.js

@@ -0,0 +1,10 @@
+import { L } from '../globals/L.js';
+import { polygon } from './polygon.js';
+
+export function visit(context, coordinates, closed) {
+  if (!coordinates.length) return;
+  let child;
+  if (coordinates[0] instanceof L.LatLng) polygon(context, /* alloc */ [coordinates], closed);
+  else if (closed && coordinates[0][0] instanceof L.LatLng) polygon(context, coordinates, closed);
+  else for (child of coordinates) visit(context, child, closed);
+}

package/src/globals/CELL.js

@@ -0,0 +1,3 @@
+// Walls (non-horizontal triangles) of a mesh in world space, bucketed by 8 m cells; `origin` is the world translation
+// at build time, since layer roots only move vertically with the terrain afterwards.
+export const CELL = 8;

package/src/globals/Compass.js

@@ -0,0 +1 @@
+export const Compass = { value: undefined };

package/src/globals/ContainerResize.js

@@ -0,0 +1 @@
+export const ContainerResize = { value: undefined };

package/src/globals/HEIGHT.js

@@ -0,0 +1 @@
+export const HEIGHT = 8;

package/src/globals/L.js

@@ -0,0 +1 @@
+export const L = globalThis.L;

package/src/globals/PitchDrag.js

@@ -0,0 +1 @@
+export const PitchDrag = { value: undefined };

package/src/globals/ShiftRotate.js

@@ -0,0 +1 @@
+export const ShiftRotate = { value: undefined };

package/src/globals/TILE_RADIUS.js

@@ -0,0 +1 @@
+export const TILE_RADIUS = 6;

package/src/globals/TILE_SIZE.js

@@ -0,0 +1 @@
+export const TILE_SIZE = 256;

package/src/globals/TouchMode.js

@@ -0,0 +1 @@
+export const TouchMode = { value: undefined };

package/src/globals/alphaBlend.js

@@ -0,0 +1,12 @@
+export const alphaBlend = {
+  color: {
+    srcFactor: 'src-alpha',
+    dstFactor: 'one-minus-src-alpha',
+    operation: 'add'
+  },
+  alpha: {
+    srcFactor: 'one',
+    dstFactor: 'one-minus-src-alpha',
+    operation: 'add'
+  },
+};

package/src/globals/archiveDecoder.js

@@ -0,0 +1 @@
+export const archiveDecoder = new TextDecoder();

package/src/globals/archiveNorthWest.js

@@ -0,0 +1 @@
+export const archiveNorthWest = [0, 0];

package/src/globals/archiveSouthEast.js

@@ -0,0 +1 @@
+export const archiveSouthEast = [0, 0];

package/src/globals/atmosphereColor.js

@@ -0,0 +1 @@
+export const atmosphereColor = [0, 0, 0];

package/src/globals/atmosphereStops.js

@@ -0,0 +1,22 @@
+export const atmosphereStops = [
+  [-18, [3, 7, 20],
+    [17, 28, 54],
+    [0.025, 0.04, 0.09]
+  ],
+  [-6, [37, 53, 84],
+    [182, 106, 86],
+    [0.12, 0.10, 0.14]
+  ],
+  [0, [101, 131, 171],
+    [246, 170, 115],
+    [0.38, 0.24, 0.18]
+  ],
+  [10, [74, 147, 208],
+    [197, 221, 237],
+    [0.80, 0.75, 0.68]
+  ],
+  [25, [53, 144, 213],
+    [223, 238, 250],
+    [1, 1, 1]
+  ],
+];

package/src/globals/blobParts.js

@@ -0,0 +1 @@
+export const blobParts = [null];

package/src/globals/boundsMethods.js

@@ -0,0 +1 @@
+export const boundsMethods = new WeakMap();

package/src/globals/cameraAngles.js

@@ -0,0 +1 @@
+export const cameraAngles = [1, 0, 1, 0];

package/src/globals/cameraAnimatedOptions.js

@@ -0,0 +1,3 @@
+export const cameraAnimatedOptions = Object.freeze({
+  animate: true
+});

package/src/globals/cameraAnimationFrame.js

@@ -0,0 +1 @@
+export const cameraAnimationFrame = { value: null };

package/src/globals/cameraAnimations.js

@@ -0,0 +1 @@
+export const cameraAnimations = new Map();

package/src/globals/cameraBearingSensitivity.js

@@ -0,0 +1 @@
+export const cameraBearingSensitivity = Object.freeze([0.8, 0]);

package/src/globals/cameraByMap.js

@@ -0,0 +1 @@
+export const cameraByMap = new WeakMap();

package/src/globals/cameraDragSensitivity.js

@@ -0,0 +1 @@
+export const cameraDragSensitivity = Object.freeze([0.8, 0.5]);

package/src/globals/cameraDrags.js

@@ -0,0 +1 @@
+export const cameraDrags = { value: new Set() };

package/src/globals/cameraEmptyOptions.js

@@ -0,0 +1 @@
+export const cameraEmptyOptions = Object.freeze({});

package/src/globals/cameraFocusOptions.js

@@ -0,0 +1,3 @@
+export const cameraFocusOptions = Object.freeze({
+  preventScroll: true
+});

package/src/globals/cameraFov.js

@@ -0,0 +1,3 @@
+import { degrees } from './degrees.js';
+
+export const cameraFov = 2 * Math.atan(1 / 3) * degrees;

package/src/globals/cameraListenerOptions.js

@@ -0,0 +1,4 @@
+export const cameraListenerOptions = Object.freeze({
+  capture: true,
+  passive: false
+});

package/src/globals/cameraTouchStates.js

@@ -0,0 +1 @@
+export const cameraTouchStates = new Set();

package/src/globals/cameraZeroPadding.js

@@ -0,0 +1 @@
+export const cameraZeroPadding = Object.freeze([0, 0]);

package/src/globals/closestMethods.js

@@ -0,0 +1 @@
+export const closestMethods = new WeakMap();

package/src/globals/cogTags.js

@@ -0,0 +1 @@
+export const cogTags = [256, 257, 258, 259, 262, 277, 284, 317, 322, 323, 324, 325, 339, 33550, 33922, 34735];

package/src/globals/colliders.js

@@ -0,0 +1 @@
+export const colliders = new WeakMap();

package/src/globals/colorLayout.js

@@ -0,0 +1,8 @@
+export const colorLayout = Object.freeze({
+  arrayStride: 12,
+  attributes: Object.freeze([Object.freeze({
+    shaderLocation: 2,
+    offset: 0,
+    format: 'float32x3'
+  })])
+});

package/src/globals/coreEventTypes.js

@@ -0,0 +1,4 @@
+export const coreEventTypes = new Set([
+  'click', 'preclick', 'dblclick', 'contextmenu', 'mousedown', 'mouseup', 'mousemove', 'mouseover', 'mouseout',
+  'pointerdown', 'pointerup', 'pointermove', 'pointerover', 'pointerout',
+]);

package/src/globals/coreMatrixKeys.js

@@ -0,0 +1,4 @@
+export const coreMatrixKeys = Object.freeze([
+  'm11', 'm12', 'm13', 'm14', 'm21', 'm22', 'm23', 'm24',
+  'm31', 'm32', 'm33', 'm34', 'm41', 'm42', 'm43', 'm44',
+]);

package/src/globals/coreQuadIndices.js

@@ -0,0 +1 @@
+export const coreQuadIndices = Object.freeze([0, 2, 1, 1, 2, 3]);

package/src/globals/coreQuadUV.js

@@ -0,0 +1 @@
+export const coreQuadUV = Object.freeze([0, 0, 1, 0, 0, 1, 1, 1]);

package/src/globals/coreSampler.js

@@ -0,0 +1,4 @@
+export const coreSampler = Object.freeze({
+  minFilter: 'linear',
+  magFilter: 'linear'
+});

package/src/globals/coreWhite.js

@@ -0,0 +1 @@
+export const coreWhite = Object.freeze([1, 1, 1]);

package/src/globals/cosObliquity.js

@@ -0,0 +1,3 @@
+import { radians } from './radians.js';
+
+export const cosObliquity = Math.cos(23.4397 * radians);

package/src/globals/coverageTiles.js

@@ -0,0 +1 @@
+export const coverageTiles = new Map();

package/src/globals/dark.js

@@ -0,0 +1 @@
+export const dark = [0.08, 0.07, 0.06];

package/src/globals/defaultMaterial.js

@@ -0,0 +1 @@
+export const defaultMaterial = Object.freeze({});

package/src/globals/degrees.js

@@ -0,0 +1 @@
+export const degrees = 180 / Math.PI;

package/src/globals/demBuffer.js

@@ -0,0 +1,4 @@
+export const demBuffer = {
+  size: null,
+  usage: null
+};

package/src/globals/demLayout.js

@@ -0,0 +1,3 @@
+export const demLayout = {
+  bytesPerRow: null
+};

package/src/globals/demSize.js

@@ -0,0 +1 @@
+export const demSize = [null, null];

package/src/globals/demTarget.js

@@ -0,0 +1,3 @@
+export const demTarget = {
+  texture: null
+};

package/src/globals/demTexture.js

@@ -0,0 +1,5 @@
+export const demTexture = {
+  size: [null, null],
+  format: 'r32float',
+  usage: null
+};

package/src/globals/depthBindGroup.js

@@ -0,0 +1,9 @@
+export const depthBindGroup = {
+  layout: null,
+  entries: [{
+    binding: 0,
+    resource: {
+      buffer: null
+    }
+  }]
+};

package/src/globals/depthTexture.js

@@ -0,0 +1,5 @@
+export const depthTexture = {
+  size: [null, null],
+  format: 'depth24plus',
+  usage: null
+};

package/src/globals/directoryReader.js

@@ -0,0 +1,4 @@
+export const directoryReader = {
+  bytes: null,
+  cursor: 0
+};

package/src/globals/disabledShadow.js

@@ -0,0 +1 @@
+export const disabledShadow = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0]);

package/src/globals/dragByHandler.js

@@ -0,0 +1 @@
+export const dragByHandler = new WeakMap();

package/src/globals/dragStates.js

@@ -0,0 +1 @@
+export const dragStates = { value: new WeakMap() };

package/src/globals/drawEntries.js

@@ -0,0 +1 @@
+export const drawEntries = [];

package/src/globals/drawFrameEntry.js

@@ -0,0 +1,7 @@
+export const drawFrameEntry = {
+  binding: 1,
+  resource: {
+    buffer: null,
+    size: 240
+  }
+};

package/src/globals/drawMeshEntry.js

@@ -0,0 +1,7 @@
+export const drawMeshEntry = {
+  binding: 0,
+  resource: {
+    buffer: null,
+    size: 160
+  }
+};