itowns 2.44.3-next.21 → 2.44.3-next.23

package/lib/Core/Prefab/GlobeView.js

@@ -5,7 +5,6 @@ import Coordinates from "../Geographic/Coordinates.js";
 import GlobeLayer from "./Globe/GlobeLayer.js";
 import Atmosphere from "./Globe/Atmosphere.js";
 import CameraUtils from "../../Utils/CameraUtils.js";
-import CRS from "../Geographic/Crs.js";
 import { ellipsoidSizes } from "../Math/Ellipsoid.js";
 
 /**
@@ -129,11 +128,11 @@ class GlobeView extends View {
       return Promise.reject(new Error('Add Layer type object'));
     }
     if (layer.isColorLayer) {
-      if (!this.tileLayer.tileMatrixSets.includes(CRS.formatToTms(layer.source.crs))) {
+      if (!this.tileLayer.tileMatrixSets.includes(layer.source.crs)) {
         return layer._reject(`Only ${this.tileLayer.tileMatrixSets} tileMatrixSet are currently supported for color layers`);
       }
     } else if (layer.isElevationLayer) {
-      if (CRS.formatToTms(layer.source.crs) !== this.tileLayer.tileMatrixSets[0]) {
+      if (layer.source.crs !== this.tileLayer.tileMatrixSets[0]) {
         return layer._reject(`Only ${this.tileLayer.tileMatrixSets[0]} tileMatrixSet is currently supported for elevation layers`);
       }
     }

package/lib/Core/Prefab/Planar/PlanarLayer.js

@@ -1,21 +1,19 @@
 import * as THREE from 'three';
 import TiledGeometryLayer from "../../../Layer/TiledGeometryLayer.js";
 import { globalExtentTMS } from "../../Tile/TileGrid.js";
-import CRS from "../../Geographic/Crs.js";
-import PlanarTileBuilder from "./PlanarTileBuilder.js";
+import { PlanarTileBuilder } from "./PlanarTileBuilder.js";
 
 /**
  * @property {boolean} isPlanarLayer - Used to checkout whether this layer is a
  * PlanarLayer. Default is true. You should not change this, as it is used
  * internally for optimisation.
+ * @extends TiledGeometryLayer
  */
 class PlanarLayer extends TiledGeometryLayer {
   /**
    * A {@link TiledGeometryLayer} to use with a {@link PlanarView}. It has
    * specific method for updating and subdivising its grid.
    *
-   * @extends TiledGeometryLayer
-   *
    * @param {string} id - The id of the layer, that should be unique. It is
    * not mandatory, but an error will be emitted if this layer is added a
    * {@link View} that already has a layer going by that id.
@@ -35,19 +33,27 @@ class PlanarLayer extends TiledGeometryLayer {
    */
   constructor(id, extent, object3d) {
     let config = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    const tms = CRS.formatToTms(extent.crs);
+    const {
+      minSubdivisionLevel = 0,
+      maxSubdivisionLevel = 5,
+      ...tiledConfig
+    } = config;
+    const tileMatrixSets = [extent.crs];
     if (!globalExtentTMS.get(extent.crs)) {
       // Add new global extent for this new crs projection.
       globalExtentTMS.set(extent.crs, extent);
     }
-    config.tileMatrixSets = [tms];
-    super(id, object3d || new THREE.Group(), [extent], new PlanarTileBuilder({
+    const builder = new PlanarTileBuilder({
       crs: extent.crs
-    }), config);
+    });
+    super(id, object3d || new THREE.Group(), [extent], builder, {
+      tileMatrixSets,
+      ...tiledConfig
+    });
     this.isPlanarLayer = true;
     this.extent = extent;
-    this.minSubdivisionLevel = this.minSubdivisionLevel == undefined ? 0 : this.minSubdivisionLevel;
-    this.maxSubdivisionLevel = this.maxSubdivisionLevel == undefined ? 5 : this.maxSubdivisionLevel;
+    this.minSubdivisionLevel = minSubdivisionLevel;
+    this.maxSubdivisionLevel = maxSubdivisionLevel;
   }
 }
 export default PlanarLayer;

package/lib/Core/Prefab/Planar/PlanarTileBuilder.js

@@ -3,70 +3,70 @@ import Coordinates from "../../Geographic/Coordinates.js";
 import Extent from "../../Geographic/Extent.js";
 const quaternion = new THREE.Quaternion();
 const center = new THREE.Vector3();
-class PlanarTileBuilder {
-  constructor() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    /* istanbul ignore next */
+
+/** Specialized parameters for the [PlanarTileBuilder]. */
+
+/**
+ * TileBuilder implementation for the purpose of generating planar
+ * tile arrangements.
+ */
+export class PlanarTileBuilder {
+  constructor(options) {
     if (options.projection) {
-      console.warn('PlanarTileBuilder projection parameter is deprecated, use crs instead.');
-      options.crs = options.crs || options.projection;
-    }
-    if (options.crs) {
-      this.crs = options.crs;
-    } else {
-      throw new Error('options.crs is mandatory for PlanarTileBuilder');
+      console.warn('PlanarTileBuilder projection parameter is deprecated,' + ' use crs instead.');
+      options.crs ??= options.projection;
     }
-    this.tmp = {
+    this._crs = options.crs;
+    this._transform = {
       coords: new Coordinates('EPSG:4326', 0, 0),
       position: new THREE.Vector3(),
       normal: new THREE.Vector3(0, 0, 1)
     };
-    this.uvCount = options.uvCount || 1;
+    this._uvCount = options.uvCount ?? 1;
+  }
+  get uvCount() {
+    return this._uvCount;
+  }
+  get crs() {
+    return this._crs;
   }
-  // prepare params
-  // init projected object -> params.projected
   prepare(params) {
-    params.nbRow = 2 ** (params.zoom + 1.0);
-    params.projected = new THREE.Vector3();
+    const newParams = params;
+    newParams.nbRow = 2 ** (params.level + 1.0);
+    newParams.coordinates = new Coordinates(this.crs);
+    return newParams;
   }
-
-  // get center tile in cartesian 3D
   center(extent) {
-    extent.center(this.tmp.coords);
-    center.set(this.tmp.coords.x, this.tmp.coords.y, 0);
+    extent.center(this._transform.coords);
+    center.set(this._transform.coords.x, this._transform.coords.y, 0);
     return center;
   }
-
-  // get position 3D cartesian
-  vertexPosition(params) {
-    this.tmp.position.set(params.projected.x, params.projected.y, 0);
-    return this.tmp.position;
+  vertexPosition(coordinates) {
+    this._transform.position.set(coordinates.x, coordinates.y, 0);
+    return this._transform.position;
   }
-
-  // get normal for last vertex
   vertexNormal() {
-    return this.tmp.normal;
+    return this._transform.normal;
   }
-
-  // coord u tile to projected
-  uProjecte(u, params) {
-    params.projected.x = params.extent.west + u * (params.extent.east - params.extent.west);
+  uProject(u, extent) {
+    return extent.west + u * (extent.east - extent.west);
   }
-
-  // coord v tile to projected
-  vProjecte(v, params) {
-    params.projected.y = params.extent.south + v * (params.extent.north - params.extent.south);
+  vProject(v, extent) {
+    return extent.south + v * (extent.north - extent.south);
   }
-  computeSharableExtent(extent) {
-    // compute sharable extent to pool the geometries
+  computeShareableExtent(extent) {
+    // compute shareable extent to pool the geometries
     // the geometry in common extent is identical to the existing input
     // with a translation
-    const sharableExtent = new Extent(extent.crs, 0, Math.abs(extent.west - extent.east), 0, Math.abs(extent.north - extent.south));
     return {
-      sharableExtent,
+      shareableExtent: new Extent(extent.crs, {
+        west: 0,
+        east: Math.abs(extent.west - extent.east),
+        south: 0,
+        north: Math.abs(extent.north - extent.south)
+      }),
       quaternion,
       position: this.center(extent).clone()
     };
   }
-}
-export default PlanarTileBuilder;
+}

package/lib/Core/Prefab/TileBuilder.js

@@ -1,17 +1,23 @@
 import * as THREE from 'three';
-import TileGeometry from "../TileGeometry.js";
+import { TileGeometry } from "../TileGeometry.js";
 import Cache from "../Scheduler/Cache.js";
-import computeBuffers from "./computeBufferTileGeometry.js";
+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) {
+
+/**
+ * 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);
 
@@ -22,49 +28,38 @@ export default function newTileGeometry(builder, params) {
       resolve = r;
     });
     cacheTile.set(promiseGeometry, south, params.level, bufferKey);
-    params.extent = sharableExtent;
+    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);
     } catch (e) {
       return Promise.reject(e);
     }
     if (!cachedBuffers) {
       cachedBuffers = {};
+      // 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);
       cachedBuffers.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, [south, params.level, bufferKey]);
     resolve(geometry);
     return Promise.resolve({
       geometry,

package/lib/Core/Prefab/computeBufferTileGeometry.js

@@ -3,14 +3,52 @@ 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) {
+  if (!params.buildIndexAndUv_0) {
+    return undefined;
+  }
+  const indexBufferSize = getBufferIndexSize(nSeg, params.disableSkirt);
+  const indexConstructor = getUintArrayConstructor(nVertex);
+  const tileLen = indexBufferSize;
+  const skirtLen = 4 * nSeg;
+  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) {
+  const {
+    index,
+    skirt
+  } = allocateIndexBuffer(nVertex, nSeg, params) ?? {};
+  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 +62,157 @@ export default function computeBuffers(params) {
     //      +-------------------------+
     //        * u = wgs84.u
     //        * v = textureid + v in builder texture
-    uvs: []
+    uvs: [params.buildIndexAndUv_0 ? new Float32Array(nVertex * 2) : undefined, 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) {
+  //     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);
+  const outBuffers = allocateBuffers(nTotalVertex, nSeg, builder, params);
+  const computeUvs = [params.buildIndexAndUv_0 ? 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));
     }
-    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;
-      };
-    }
-    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 (params.buildIndexAndUv_0 && !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);
+    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
-  if (!params.disableSkirt) {
-    // We compute the actual size of tile segment to use later for the skirt.
+  // 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.buildIndexAndUv_0 && !params.disableSkirt) {
+    // 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 = {
+      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];
+      }
+    };
+
+    // 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 +220,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
+  };
 }