itowns 2.44.3-next.4 → 2.44.3-next.40

package/lib/Core/Prefab/TileBuilder.js

@@ -1,19 +1,28 @@
 import * as THREE from 'three';
-import TileGeometry from "../TileGeometry.js";
-import Cache from "../Scheduler/Cache.js";
-import computeBuffers from "./computeBufferTileGeometry.js";
+import { TileGeometry } from "../TileGeometry.js";
+import { LRUCache } from 'lru-cache';
+import { computeBuffers } from "./computeBufferTileGeometry.js";
 import OBB from "../../Renderer/OBB.js";
 const cacheBuffer = new Map();
-const cacheTile = new Cache();
-export default function newTileGeometry(builder, params) {
+const cacheTile = new LRUCache({
+  max: 500
+});
+
+/**
+ * Reference to a tile's extent with rigid transformations.
+ * Enables reuse of geometry, saving a bit of memory.
+ */
+
+export function newTileGeometry(builder, params) {
   const {
-    sharableExtent,
+    shareableExtent,
     quaternion,
     position
-  } = builder.computeSharableExtent(params.extent);
-  const south = sharableExtent.south.toFixed(6);
+  } = builder.computeShareableExtent(params.extent);
+  const south = shareableExtent.south.toFixed(6);
   const bufferKey = `${builder.crs}_${params.disableSkirt ? 0 : 1}_${params.segments}`;
-  let promiseGeometry = cacheTile.get(south, params.level, bufferKey);
+  const key = `s${south}l${params.level}bK${bufferKey}`;
+  let promiseGeometry = cacheTile.get(key);
 
   // build geometry if doesn't exist
   if (!promiseGeometry) {
@@ -21,50 +30,43 @@ export default function newTileGeometry(builder, params) {
     promiseGeometry = new Promise(r => {
       resolve = r;
     });
-    cacheTile.set(promiseGeometry, south, params.level, bufferKey);
-    params.extent = sharableExtent;
+    cacheTile.set(key, promiseGeometry);
+    params.extent = shareableExtent;
     params.center = builder.center(params.extent).clone();
-    // Read previously cached values (index and uv.wgs84 only depend on the # of triangles)
+    // Read previously cached values (index and uv.wgs84 only
+    // depend on the # of triangles)
     let cachedBuffers = cacheBuffer.get(bufferKey);
-    params.buildIndexAndUv_0 = !cachedBuffers;
-    params.builder = builder;
     let buffers;
     try {
-      buffers = computeBuffers(params);
+      buffers = computeBuffers(builder, params, cachedBuffers !== undefined ? {
+        index: cachedBuffers.index.array,
+        uv: cachedBuffers.uv.array
+      } : undefined);
     } catch (e) {
       return Promise.reject(e);
     }
     if (!cachedBuffers) {
-      cachedBuffers = {};
-      cachedBuffers.index = new THREE.BufferAttribute(buffers.index, 1);
-      cachedBuffers.uv = new THREE.BufferAttribute(buffers.uvs[0], 2);
+      // We know the fields will exist due to the condition
+      // matching with the one for buildIndexAndUv_0.
+      // TODO: Make this brain-based check compiler-based.
+
+      cachedBuffers = {
+        index: new THREE.BufferAttribute(buffers.index, 1),
+        uv: new THREE.BufferAttribute(buffers.uvs[0], 2)
+      };
 
       // Update cacheBuffer
       cacheBuffer.set(bufferKey, cachedBuffers);
     }
-    buffers.index = cachedBuffers.index;
-    buffers.uvs[0] = cachedBuffers.uv;
-    buffers.position = new THREE.BufferAttribute(buffers.position, 3);
-    buffers.normal = new THREE.BufferAttribute(buffers.normal, 3);
-    if (params.builder.uvCount > 1) {
-      buffers.uvs[1] = new THREE.BufferAttribute(buffers.uvs[1], 1);
-    }
-    const geometry = new TileGeometry(params, buffers);
-    geometry.OBB = new OBB(geometry.boundingBox.min, geometry.boundingBox.max);
-    geometry._count = 0;
-    geometry.dispose = () => {
-      geometry._count--;
-      if (geometry._count <= 0) {
-        // To avoid remove index buffer and attribute buffer uv
-        //  error un-bound buffer in webgl with VAO rendering.
-        // Could be removed if the attribute buffer deleting is
-        //  taken into account in the buffer binding state (in THREE.WebGLBindingStates code).
-        geometry.index = null;
-        delete geometry.attributes.uv;
-        THREE.BufferGeometry.prototype.dispose.call(geometry);
-        cacheTile.delete(south, params.level, bufferKey);
-      }
+    const gpuBuffers = {
+      index: cachedBuffers.index,
+      uvs: [cachedBuffers.uv, ...(buffers.uvs[1] !== undefined ? [new THREE.BufferAttribute(buffers.uvs[1], 1)] : [])],
+      position: new THREE.BufferAttribute(buffers.position, 3),
+      normal: new THREE.BufferAttribute(buffers.normal, 3)
     };
+    const geometry = new TileGeometry(builder, params, gpuBuffers);
+    geometry.OBB = new OBB(geometry.boundingBox.min, geometry.boundingBox.max);
+    geometry.initRefCount(cacheTile, key);
     resolve(geometry);
     return Promise.resolve({
       geometry,

package/lib/Core/Prefab/computeBufferTileGeometry.js

@@ -3,14 +3,55 @@ export function getBufferIndexSize(segments, noSkirt) {
   const triangles = segments * segments * 2 + (noSkirt ? 0 : 4 * segments * 2);
   return triangles * 3;
 }
-export default function computeBuffers(params) {
-  // Create output buffers.
-  const outBuffers = {
-    index: null,
-    position: null,
-    normal: null,
-    // 2 UV set per tile: wgs84 (uv[0]) and pm (uv[1])
-    //    - wgs84: 1 texture per tile because tiles are using wgs84 projection
+function getUintArrayConstructor(highestValue) {
+  let picked = null;
+  if (highestValue < 2 ** 8) {
+    picked = Uint8Array;
+  } else if (highestValue < 2 ** 16) {
+    picked = Uint16Array;
+  } else if (highestValue < 2 ** 32) {
+    picked = Uint32Array;
+  } else {
+    throw new Error('Value is too high');
+  }
+  return picked;
+}
+function allocateIndexBuffer(nVertex, nSeg, params, cache) {
+  const indexBufferSize = getBufferIndexSize(nSeg, params.disableSkirt);
+  const indexConstructor = getUintArrayConstructor(nVertex);
+  const tileLen = indexBufferSize;
+  const skirtLen = 4 * nSeg;
+  if (cache !== undefined) {
+    return {
+      index: cache,
+      skirt: cache.subarray(tileLen, tileLen + skirtLen)
+    };
+  }
+  const indexBuffer = new ArrayBuffer((
+  // Tile
+  tileLen
+  // Skirt
+  + (params.disableSkirt ? 0 : skirtLen)) * indexConstructor.BYTES_PER_ELEMENT);
+  const index = new indexConstructor(indexBuffer);
+  const skirt = !params.disableSkirt ? index.subarray(tileLen, tileLen + skirtLen) : undefined;
+  return {
+    index,
+    skirt
+  };
+}
+function allocateBuffers(nVertex, nSeg, builder, params, cache) {
+  const {
+    index,
+    skirt
+  } = allocateIndexBuffer(nVertex, nSeg, params, cache?.index);
+  return {
+    index,
+    skirt,
+    position: new Float32Array(nVertex * 3),
+    normal: new Float32Array(nVertex * 3),
+    // 2 UV set per tile: wgs84 (uv[0]) and pseudo-mercator (pm, uv[1])
+    //    - wgs84: 1 texture per tile because tiles are using wgs84
+    //          projection
     //    - pm: use multiple textures per tile.
     //      +-------------------------+
     //      |                         |
@@ -24,142 +65,160 @@ export default function computeBuffers(params) {
     //      +-------------------------+
     //        * u = wgs84.u
     //        * v = textureid + v in builder texture
-    uvs: []
+    uvs: [cache?.uv ?? new Float32Array(nVertex * 2), builder.computeExtraOffset !== undefined ? new Float32Array(nVertex) : undefined]
+  };
+}
+function computeUv0(uv, id, u, v) {
+  uv[id * 2 + 0] = u;
+  uv[id * 2 + 1] = v;
+}
+function initComputeUv1(value) {
+  return (uv, id) => {
+    uv[id] = value;
   };
-  const computeUvs = [];
-  const builder = params.builder;
-  const nSeg = params.segments;
-  // segments count :
-  // Tile : (nSeg + 1) * (nSeg + 1)
-  // Skirt : 8 * (nSeg - 1)
-  const nVertex = (nSeg + 1) * (nSeg + 1) + (params.disableSkirt ? 0 : 4 * nSeg);
-  if (nVertex > 2 ** 32) {
+}
+/** Compute buffers describing a tile according to a builder and its params. */
+// TODO: Split this even further into subfunctions
+export function computeBuffers(builder, params, cache) {
+  //     n seg, n+1 vert    + <- skirt, n verts per side
+  //    <---------------> / |
+  //    +---+---+---+---+   |
+  //    | / | / | / | / |   |  Vertices:
+  //    +---+---+---+---+ - +     tile = (n + 1)^2
+  //    | / | / | / | / |   |    skirt = 4n
+  //    +---+---+---+---+ - +
+  //    | / | / | / | / |   |  Segments:
+  //    +---+---+---+---+ - +     tile = 2 * n * (n + 1) + n^2
+  //    | / | / | / | / |   |    skirt = 2n * 4
+  //    +---+---+---+---+   |
+  const nSeg = Math.max(2, params.segments);
+  const nVertex = nSeg + 1;
+  const nTileVertex = nVertex ** 2;
+  const nSkirtVertex = params.disableSkirt ? 0 : 4 * nSeg;
+  const nTotalVertex = nTileVertex + nSkirtVertex;
+
+  // Computer should combust before this happens
+  if (nTotalVertex > 2 ** 32) {
     throw new Error('Tile segments count is too big');
   }
-  outBuffers.position = new Float32Array(nVertex * 3);
-  outBuffers.normal = new Float32Array(nVertex * 3);
-  const uvCount = params.builder.uvCount;
-  if (uvCount > 1) {
-    outBuffers.uvs[1] = new Float32Array(nVertex);
-  }
-  computeUvs[0] = () => {};
-  const bufferIndexSize = getBufferIndexSize(nSeg, params.disableSkirt);
-  if (params.buildIndexAndUv_0) {
-    if (nVertex < 2 ** 8) {
-      outBuffers.index = new Uint8Array(bufferIndexSize);
-    } else if (nVertex < 2 ** 16) {
-      outBuffers.index = new Uint16Array(bufferIndexSize);
-    } else if (nVertex < 2 ** 32) {
-      outBuffers.index = new Uint32Array(bufferIndexSize);
-    }
-    outBuffers.uvs[0] = new Float32Array(nVertex * 2);
-    computeUvs[0] = (id, u, v) => {
-      outBuffers.uvs[0][id * 2 + 0] = u;
-      outBuffers.uvs[0][id * 2 + 1] = v;
-    };
-  }
-  const widthSegments = Math.max(2, Math.floor(nSeg) || 2);
-  const heightSegments = Math.max(2, Math.floor(nSeg) || 2);
-  let idVertex = 0;
-  const vertices = [];
-  let skirt = [];
-  const skirtEnd = [];
-  builder.prepare(params);
-  for (let y = 0; y <= heightSegments; y++) {
-    const verticesRow = [];
-    const v = y / heightSegments;
-    builder.vProjecte(v, params);
-    if (uvCount > 1) {
-      const u = builder.computeUvs[1](params);
-      computeUvs[1] = id => {
-        outBuffers.uvs[1][id] = u;
-      };
+  const outBuffers = allocateBuffers(nTotalVertex, nSeg, builder, params, cache);
+  const computeUvs = [cache === undefined ? computeUv0 : () => {}];
+  params = builder.prepare(params);
+  for (let y = 0; y <= nSeg; y++) {
+    const v = y / nSeg;
+    params.coordinates.y = builder.vProject(v, params.extent);
+    if (builder.computeExtraOffset !== undefined) {
+      computeUvs[1] = initComputeUv1(builder.computeExtraOffset(params));
     }
-    for (let x = 0; x <= widthSegments; x++) {
-      const u = x / widthSegments;
-      const id_m3 = idVertex * 3;
-      builder.uProjecte(u, params);
-      const vertex = builder.vertexPosition(params, params.projected);
-      const normal = builder.vertexNormal(params);
+    for (let x = 0; x <= nSeg; x++) {
+      const u = x / nSeg;
+      const id_m3 = (y * nVertex + x) * 3;
+      params.coordinates.x = builder.uProject(u, params.extent);
+      const vertex = builder.vertexPosition(params.coordinates);
+      const normal = builder.vertexNormal();
 
       // move geometry to center world
       vertex.sub(params.center);
 
       // align normal to z axis
-      if (params.quatNormalToZ) {
-        vertex.applyQuaternion(params.quatNormalToZ);
-        normal.applyQuaternion(params.quatNormalToZ);
+      // HACK: this check style is not great
+      if ('quatNormalToZ' in params) {
+        const quat = params.quatNormalToZ;
+        vertex.applyQuaternion(quat);
+        normal.applyQuaternion(quat);
       }
       vertex.toArray(outBuffers.position, id_m3);
       normal.toArray(outBuffers.normal, id_m3);
-      for (const computeUv of computeUvs) {
-        computeUv(idVertex, u, v);
-      }
-      if (!params.disableSkirt) {
-        if (y !== 0 && y !== heightSegments) {
-          if (x === widthSegments) {
-            skirt.push(idVertex);
-          } else if (x === 0) {
-            skirtEnd.push(idVertex);
-          }
+      for (const [index, computeUv] of computeUvs.entries()) {
+        if (computeUv !== undefined) {
+          computeUv(outBuffers.uvs[index], y * nVertex + x, u, v);
         }
       }
-      verticesRow.push(idVertex);
-      idVertex++;
-    }
-    vertices.push(verticesRow);
-    if (y === 0) {
-      skirt = skirt.concat(verticesRow);
-    } else if (y === heightSegments) {
-      skirt = skirt.concat(verticesRow.slice().reverse());
     }
   }
-  if (!params.disableSkirt) {
-    skirt = skirt.concat(skirtEnd.reverse());
+
+  // Fill skirt index buffer
+  if (cache === undefined && !params.disableSkirt) {
+    for (let x = 0; x < nVertex; x++) {
+      //   -------->
+      //   0---1---2
+      //   | / | / |   [0-9] = assign order
+      //   +---+---+
+      //   | / | / |
+      //   +---+---+
+      outBuffers.skirt[x] = x;
+      //   +---+---+
+      //   | / | / |   [0-9] = assign order
+      //   +---+---x   x = skipped for now
+      //   | / | / |
+      //   0---1---2
+      //   <--------
+      outBuffers.skirt[2 * nVertex - 2 + x] = nVertex ** 2 - (x + 1);
+    }
+    for (let y = 1; y < nVertex - 1; y++) {
+      //   +---+---s |
+      //   | / | / | | o = stored vertices
+      //   +---+---o | s = already stored
+      //   | / | / | |
+      //   +---+---s v
+      outBuffers.skirt[nVertex - 1 + y] = y * nVertex + (nVertex - 1);
+      // ^ s---+---+
+      // | | / | / |   o = stored vertices
+      // | o---+---+   s = already stored
+      // | | / | / |
+      // | s---+---+
+      outBuffers.skirt[3 * nVertex - 3 + y] = nVertex * (nVertex - 1 - y);
+    }
   }
-  function bufferize(va, vb, vc, idVertex) {
-    outBuffers.index[idVertex + 0] = va;
-    outBuffers.index[idVertex + 1] = vb;
-    outBuffers.index[idVertex + 2] = vc;
-    return idVertex + 3;
+
+  /** Copy passed indices at the desired index of the output index buffer. */
+  function bufferizeTri(id, va, vb, vc) {
+    outBuffers.index[id + 0] = va;
+    outBuffers.index[id + 1] = vb;
+    outBuffers.index[id + 2] = vc;
   }
-  let idVertex2 = 0;
-  if (params.buildIndexAndUv_0) {
-    for (let y = 0; y < heightSegments; y++) {
-      for (let x = 0; x < widthSegments; x++) {
-        const v1 = vertices[y][x + 1];
-        const v2 = vertices[y][x];
-        const v3 = vertices[y + 1][x];
-        const v4 = vertices[y + 1][x + 1];
-        idVertex2 = bufferize(v4, v2, v1, idVertex2);
-        idVertex2 = bufferize(v4, v3, v2, idVertex2);
+  if (cache === undefined) {
+    for (let y = 0; y < nSeg; y++) {
+      for (let x = 0; x < nSeg; x++) {
+        const v1 = y * nVertex + (x + 1);
+        const v2 = y * nVertex + x;
+        const v3 = (y + 1) * nVertex + x;
+        const v4 = (y + 1) * nVertex + (x + 1);
+        const id = (y * nSeg + x) * 6;
+        bufferizeTri(id, /**/v4, v2, v1);
+        bufferizeTri(id + 3, v4, v3, v2);
       }
     }
   }
-  const iStart = idVertex;
 
-  // TODO: WARNING beware skirt's size influences performance
-  // The size of the skirt is now a ratio of the size of the tile.
-  // To be perfect it should depend on the real elevation delta but too heavy to compute
+  // PERF: Beware skirt's size influences performance
+  // INFO: The size of the skirt is now a ratio of the size of the tile.
+  // To be perfect it should depend on the real elevation delta but too heavy
+  // to compute
   if (!params.disableSkirt) {
-    // We compute the actual size of tile segment to use later for the skirt.
+    // We compute the actual size of tile segment to use later for
+    // the skirt.
     const segmentSize = new THREE.Vector3().fromArray(outBuffers.position).distanceTo(new THREE.Vector3().fromArray(outBuffers.position, 3));
-    let buildIndexSkirt = function () {};
-    let buildUVSkirt = function () {};
-    if (params.buildIndexAndUv_0) {
-      buildIndexSkirt = function (id, v1, v2, v3, v4) {
-        id = bufferize(v1, v2, v3, id);
-        id = bufferize(v1, v3, v4, id);
-        return id;
-      };
-      buildUVSkirt = function (id) {
-        outBuffers.uvs[0][idVertex * 2 + 0] = outBuffers.uvs[0][id * 2 + 0];
-        outBuffers.uvs[0][idVertex * 2 + 1] = outBuffers.uvs[0][id * 2 + 1];
-      };
-    }
-    for (let i = 0; i < skirt.length; i++) {
-      const id = skirt[i];
-      const id_m3 = idVertex * 3;
+    const buildSkirt = cache === undefined ? {
+      index: (id, v1, v2, v3, v4) => {
+        bufferizeTri(id, v1, v2, v3);
+        bufferizeTri(id + 3, v1, v3, v4);
+        return id + 6;
+      },
+      uv: (buf, idTo, idFrom) => {
+        buf[idTo * 2 + 0] = buf[idFrom * 2 + 0];
+        buf[idTo * 2 + 1] = buf[idFrom * 2 + 1];
+      }
+    } : {
+      index: () => {},
+      uv: () => {}
+    };
+
+    // Alias for readability
+    const start = nTileVertex;
+    for (let i = 0; i < outBuffers.skirt.length; i++) {
+      const id = outBuffers.skirt[i];
+      const id_m3 = (start + i) * 3;
       const id2_m3 = id * 3;
       outBuffers.position[id_m3 + 0] = outBuffers.position[id2_m3 + 0] - outBuffers.normal[id2_m3 + 0] * segmentSize;
       outBuffers.position[id_m3 + 1] = outBuffers.position[id2_m3 + 1] - outBuffers.normal[id2_m3 + 1] * segmentSize;
@@ -167,17 +226,23 @@ export default function computeBuffers(params) {
       outBuffers.normal[id_m3 + 0] = outBuffers.normal[id2_m3 + 0];
       outBuffers.normal[id_m3 + 1] = outBuffers.normal[id2_m3 + 1];
       outBuffers.normal[id_m3 + 2] = outBuffers.normal[id2_m3 + 2];
-      buildUVSkirt(id);
-      if (uvCount > 1) {
-        outBuffers.uvs[1][idVertex] = outBuffers.uvs[1][id];
+      buildSkirt.uv(outBuffers.uvs[0], start + i, id);
+      if (outBuffers.uvs[1] !== undefined) {
+        outBuffers.uvs[1][start + i] = outBuffers.uvs[1][id];
       }
-      const idf = (i + 1) % skirt.length;
-      const v2 = idVertex;
-      const v3 = idf === 0 ? iStart : idVertex + 1;
-      const v4 = skirt[idf];
-      idVertex2 = buildIndexSkirt(idVertex2, id, v2, v3, v4);
-      idVertex++;
+      const idf = (i + 1) % outBuffers.skirt.length;
+      const v2 = start + i;
+      const v3 = idf === 0 ? start : start + i + 1;
+      const v4 = outBuffers.skirt[idf];
+      buildSkirt.index(6 * nSeg ** 2 + i * 6, id, v2, v3, v4);
     }
   }
-  return outBuffers;
+
+  // Dropping skirt view
+  return {
+    index: outBuffers.index,
+    position: outBuffers.position,
+    uvs: outBuffers.uvs,
+    normal: outBuffers.normal
+  };
 }